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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2326 - (hide annotations) (download)
Thu Mar 8 19:40:14 2012 UTC (12 years ago) by persson
File size: 18429 byte(s)
* bugfix: instrument loading crashed for sfz and sf2 in Ardour (#176)
* more thread safety fixes for the instrument loading thread

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 persson 2326 * Copyright (C) 2005-2012 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     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 wylder 816 pid_t main_pid;
69 senoner 1502 #endif
70 schoenebeck 420 bool bPrintStatistics = false;
71 senkov 325 bool profile = false;
72     bool tune = true;
73 schoenebeck 1830 static bool bShowStackTrace = false;
74 senkov 667 unsigned long int lscp_addr;
75     unsigned short int lscp_port;
76 iliev 2306 String ExecAfterInit;
77 schoenebeck 9
78     void parse_options(int argc, char **argv);
79     void signal_handler(int signal);
80 schoenebeck 271 void kill_app();
81 persson 1534 static atomic_t running = ATOMIC_INIT(1);
82 schoenebeck 9
83     int main(int argc, char **argv) {
84    
85 schoenebeck 1830 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 schoenebeck 271 // initialize the stack trace mechanism with our binary file
99 schoenebeck 1830 // (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 schoenebeck 271
120 schoenebeck 1830 dmsg(1,("LinuxSampler %s\n", VERSION));
121     dmsg(1,("Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck\n"));
122 persson 2326 dmsg(1,("Copyright (C) 2005-2012 Christian Schoenebeck\n"));
123 schoenebeck 1830
124 senoner 1502 #if defined(WIN32)
125 persson 1888 #if 0
126 senoner 1502 // 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 persson 1888 dmsg(2,("page size=%d\n", siSysInfo.dwPageSize));
131 senoner 1502
132     MEMORYSTATUSEX statex;
133     statex.dwLength = sizeof (statex);
134     GlobalMemoryStatusEx (&statex);
135 persson 1888 dmsg(2, ("There are %*I64d total Kbytes of physical memory.\n",
136 senoner 1502 8, statex.ullTotalPhys));
137 persson 1888 dmsg(2, ("There are %*I64d free Kbytes of physical memory.\n",
138 senoner 1502 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 persson 1888 dmsg(2,("AFTER GetProcessWorkingSetSize: res = %d MinimumWorkingSetSize=%d, MaximumWorkingSetSize=%d\n", res,MinimumWorkingSetSize, MaximumWorkingSetSize));
171     #endif
172 schoenebeck 1830 #endif // WIN32
173 senoner 1502
174 schoenebeck 579 if (tune) {
175 persson 425 // detect and print system / CPU specific features
176     Features::detect();
177 schoenebeck 579 dmsg(1,("Detected features: %s\n", Features::featuresAsString().c_str()));
178     // prevent slow denormal FPU modes
179     Features::enableDenormalsAreZeroMode();
180 senkov 325 }
181 schoenebeck 319
182 schoenebeck 1830 dmsg(1,("Automatic Stacktrace: %s\n", (bShowStackTrace) ? "On" : "Off"));
183    
184 schoenebeck 53 // create LinuxSampler instance
185 schoenebeck 123 dmsg(1,("Creating Sampler..."));
186 schoenebeck 53 pSampler = new Sampler;
187 schoenebeck 123 dmsg(1,("OK\n"));
188 schoenebeck 53
189 schoenebeck 900 dmsg(1,("Registered sampler engines: %s\n", EngineFactory::AvailableEngineTypesAsString().c_str()));
190 schoenebeck 207 dmsg(1,("Registered MIDI input drivers: %s\n", MidiInputDeviceFactory::AvailableDriversAsString().c_str()));
191 schoenebeck 123 dmsg(1,("Registered audio output drivers: %s\n", AudioOutputDeviceFactory::AvailableDriversAsString().c_str()));
192 schoenebeck 1212 dmsg(1,("Registered instrument editors: %s\n", InstrumentEditorFactory::AvailableEditorsAsString().c_str()));
193 schoenebeck 2124 dmsg(1,("Registered internal effect systems: %s\n", EffectFactory::AvailableEffectSystemsAsString().c_str()));
194     dmsg(1,("Registered internal effects: %d\n", EffectFactory::AvailableEffectsCount()));
195 schoenebeck 123
196 schoenebeck 53 // start LSCP network server
197 senkov 667 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 schoenebeck 53 pLSCPServer->StartThread();
202 schoenebeck 211 pLSCPServer->WaitUntilInitialized();
203 schoenebeck 12 dmsg(1,("OK\n"));
204 schoenebeck 9
205 senkov 325 if (profile)
206     {
207 persson 425 dmsg(1,("Calibrating profiler..."));
208 iliev 1161 LinuxSampler::gig::Profiler::Calibrate();
209     LinuxSampler::gig::Profiler::Reset();
210     LinuxSampler::gig::Profiler::enable();
211 persson 425 dmsg(1,("OK\n"));
212 senkov 325 }
213    
214 schoenebeck 563 printf("LinuxSampler initialization completed. :-)\n\n");
215 iliev 2306
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 schoenebeck 9
223 persson 1534 while (atomic_read(&running)) {
224 schoenebeck 420 if (bPrintStatistics) {
225 persson 840 const std::set<Engine*>& engines = EngineFactory::EngineInstances();
226 schoenebeck 420 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 persson 425
237 persson 1534 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 persson 425
249 persson 1765 pSampler->fireStatistics();
250 senoner 10 }
251 persson 1534 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 schoenebeck 9 return EXIT_SUCCESS;
258     }
259    
260 schoenebeck 271 void signal_handler(int iSignal) {
261     switch (iSignal) {
262 persson 1534 case SIGINT:
263     atomic_set(&running, 0);
264 schoenebeck 271 return;
265 senoner 1502 #if defined(WIN32)
266     // FIXME: under WIN32 we ignore the signals below due to the missing sigaction call
267     #else
268 schoenebeck 271 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 senoner 1502 #endif
287 schoenebeck 271 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 schoenebeck 9 }
292 schoenebeck 271 signal(iSignal, SIG_DFL); // Reinstall default handler to prevent race conditions
293 schoenebeck 1830 if (bShowStackTrace) {
294     std::cerr << "Showing stack trace...\n" << std::flush;
295     StackTrace();
296     sleep(2);
297     }
298 schoenebeck 271 std::cerr << "Killing LinuxSampler...\n" << std::flush;
299     kill_app(); // Use abort() if we want to generate a core dump.
300 schoenebeck 9 }
301    
302 schoenebeck 271 void kill_app() {
303 senoner 1502 #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 wylder 816 kill(main_pid, SIGKILL);
308 senoner 1502 #endif
309 schoenebeck 271 }
310    
311 senkov 325 void parse_options(int argc, char **argv) {
312 schoenebeck 9 int res;
313     int option_index = 0;
314     static struct option long_options[] =
315     {
316     {"help",0,0,0},
317 senkov 325 {"version",0,0,0},
318     {"profile",0,0,0},
319     {"no-tune",0,0,0},
320 schoenebeck 420 {"statistics",0,0,0},
321 iliev 1208 {"instruments-db-location",1,0,0},
322 iliev 1187 {"create-instruments-db",1,0,0},
323 senkov 667 {"lscp-addr",1,0,0},
324     {"lscp-port",1,0,0},
325 schoenebeck 1830 {"stacktrace",0,0,0},
326 iliev 2306 {"exec-after-init",1,0,0},
327 schoenebeck 9 {0,0,0,0}
328     };
329    
330     while (true) {
331 schoenebeck 361 /*
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 schoenebeck 9 if(res == -1) break;
337     if (res == 0) {
338     switch(option_index) {
339 senkov 325 case 0: // --help
340     printf("usage: linuxsampler [OPTIONS]\n\n");
341 iliev 1208 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 schoenebeck 1830 printf("--stacktrace automatically shows stacktrace if crashes\n");
351     printf(" (broken on most systems at the moment)\n");
352 iliev 2306 printf("--exec-after-init executes a command after initialization\n");
353 senkov 325 exit(EXIT_SUCCESS);
354 schoenebeck 9 break;
355 senkov 325 case 1: // --version
356 schoenebeck 328 printf("LinuxSampler %s\n", VERSION);
357     exit(EXIT_SUCCESS);
358 schoenebeck 9 break;
359 senkov 325 case 2: // --profile
360 persson 425 profile = true;
361 schoenebeck 2047 //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 schoenebeck 20 break;
365 senkov 325 case 3: // --no-tune
366 persson 425 tune = false;
367 schoenebeck 9 break;
368 schoenebeck 420 case 4: // --statistics
369     bPrintStatistics = true;
370     break;
371 iliev 1208 case 5: // --instruments-db-location
372 iliev 1187 #if HAVE_SQLITE3
373     try {
374     if (optarg) {
375 iliev 1208 struct stat statBuf;
376     int res = stat(optarg, &statBuf);
377    
378     if (res) {
379     std::stringstream ss;
380 schoenebeck 1364 ss << "Failed to stat `" << optarg << "`: " << strerror(errno);
381 iliev 1208 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 schoenebeck 1364 std::cerr << "Could not open instruments DB file: "
394     << e.Message() << std::endl;
395     exit(EXIT_FAILURE);
396 iliev 1208 }
397 schoenebeck 1364 break;
398 iliev 1208 #else
399     std::cerr << "LinuxSampler was not build with ";
400 schoenebeck 1364 std::cerr << "instruments database support!\n";
401     exit(EXIT_FAILURE);
402     break;
403     #endif
404 iliev 1208 case 6: // --create-instruments-db
405     #if HAVE_SQLITE3
406     try {
407     if (optarg) {
408 iliev 1187 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 schoenebeck 1364 std::cerr << "not build with instruments database support!\n";
423 iliev 1187 exit(EXIT_FAILURE);
424     return;
425 schoenebeck 1364 #endif
426 schoenebeck 1830 case 7: { // --lscp-addr
427 iliev 1187 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 senkov 667 break;
433 schoenebeck 1830 }
434     case 8: {// --lscp-port
435 iliev 1187 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 senkov 667 break;
441 schoenebeck 1830 }
442     case 9: // --stacktrace
443     bShowStackTrace = true;
444     break;
445 iliev 2306 case 10: // --exec-after-init
446     ExecAfterInit = optarg;
447     break;
448 schoenebeck 9 }
449     }
450     }
451 senkov 325 }

  ViewVC Help
Powered by ViewVC