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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1208 - (hide annotations) (download)
Sat May 26 22:20:46 2007 UTC (12 years, 3 months ago) by iliev
File size: 14468 byte(s)
* added --instruments-db-location command line switch
* fixed bug regarding the scanning progress notifications
* directories containing no instrument files are now not re-created
  in the instruments databese when recursive scan is performed

1 schoenebeck 9 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5 capela 1012 * Copyright (C) 2003-2004 by Benno Senoner and Christian Schoenebeck *
6     * Copyright (C) 2005-2007 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    
27 schoenebeck 53 #include "Sampler.h"
28 schoenebeck 420 #include "engines/EngineFactory.h"
29 schoenebeck 207 #include "drivers/midi/MidiInputDeviceFactory.h"
30 schoenebeck 203 #include "drivers/audio/AudioOutputDeviceFactory.h"
31 senkov 325 #include "engines/gig/Profiler.h"
32 schoenebeck 35 #include "network/lscpserver.h"
33 schoenebeck 271 #include "common/stacktrace.h"
34 schoenebeck 319 #include "common/Features.h"
35 schoenebeck 9
36 schoenebeck 53 using namespace LinuxSampler;
37    
38 schoenebeck 211 Sampler* pSampler = NULL;
39     LSCPServer* pLSCPServer = NULL;
40 schoenebeck 271 pthread_t main_thread;
41 wylder 816 pid_t main_pid;
42 schoenebeck 420 bool bPrintStatistics = false;
43 senkov 325 bool profile = false;
44     bool tune = true;
45 senkov 667 unsigned long int lscp_addr;
46     unsigned short int lscp_port;
47 schoenebeck 9
48     void parse_options(int argc, char **argv);
49     void signal_handler(int signal);
50 schoenebeck 271 void kill_app();
51 schoenebeck 9
52     int main(int argc, char **argv) {
53    
54 schoenebeck 271 // initialize the stack trace mechanism with our binary file
55     StackTraceInit(argv[0], -1);
56    
57 wylder 816 main_pid = getpid();
58 schoenebeck 271 main_thread = pthread_self();
59    
60 schoenebeck 9 // setting signal handler for catching SIGINT (thus e.g. <CTRL><C>)
61     signal(SIGINT, signal_handler);
62    
63 schoenebeck 271 // register signal handler for all unusual signals
64     // (we will print the stack trace and exit)
65     struct sigaction sact;
66     sigemptyset(&sact.sa_mask);
67     sact.sa_flags = 0;
68     sact.sa_handler = signal_handler;
69     sigaction(SIGSEGV, &sact, NULL);
70     sigaction(SIGBUS, &sact, NULL);
71     sigaction(SIGILL, &sact, NULL);
72     sigaction(SIGFPE, &sact, NULL);
73     sigaction(SIGUSR1, &sact, NULL);
74     sigaction(SIGUSR2, &sact, NULL);
75    
76 senkov 667 lscp_addr = htonl(LSCP_ADDR);
77     lscp_port = htons(LSCP_PORT);
78    
79 schoenebeck 9 // parse and assign command line options
80 senkov 325 parse_options(argc, argv);
81 schoenebeck 9
82 schoenebeck 207 dmsg(1,("LinuxSampler %s\n", VERSION));
83 capela 1012 dmsg(1,("Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck\n"));
84     dmsg(1,("Copyright (C) 2005-2007 Christian Schoenebeck\n"));
85 schoenebeck 123
86 schoenebeck 579 if (tune) {
87 persson 425 // detect and print system / CPU specific features
88     Features::detect();
89 schoenebeck 579 dmsg(1,("Detected features: %s\n", Features::featuresAsString().c_str()));
90     // prevent slow denormal FPU modes
91     Features::enableDenormalsAreZeroMode();
92 senkov 325 }
93 schoenebeck 319
94 schoenebeck 53 // create LinuxSampler instance
95 schoenebeck 123 dmsg(1,("Creating Sampler..."));
96 schoenebeck 53 pSampler = new Sampler;
97 schoenebeck 123 dmsg(1,("OK\n"));
98 schoenebeck 53
99 schoenebeck 900 dmsg(1,("Registered sampler engines: %s\n", EngineFactory::AvailableEngineTypesAsString().c_str()));
100 schoenebeck 207 dmsg(1,("Registered MIDI input drivers: %s\n", MidiInputDeviceFactory::AvailableDriversAsString().c_str()));
101 schoenebeck 123 dmsg(1,("Registered audio output drivers: %s\n", AudioOutputDeviceFactory::AvailableDriversAsString().c_str()));
102    
103 schoenebeck 53 // start LSCP network server
104 senkov 667 struct in_addr addr;
105     addr.s_addr = lscp_addr;
106     dmsg(1,("Starting LSCP network server (%s:%d)...", inet_ntoa(addr), ntohs(lscp_port)));
107     pLSCPServer = new LSCPServer(pSampler, lscp_addr, lscp_port);
108 schoenebeck 53 pLSCPServer->StartThread();
109 schoenebeck 211 pLSCPServer->WaitUntilInitialized();
110 schoenebeck 12 dmsg(1,("OK\n"));
111 schoenebeck 9
112 senkov 325 if (profile)
113     {
114 persson 425 dmsg(1,("Calibrating profiler..."));
115 iliev 1161 LinuxSampler::gig::Profiler::Calibrate();
116     LinuxSampler::gig::Profiler::Reset();
117     LinuxSampler::gig::Profiler::enable();
118 persson 425 dmsg(1,("OK\n"));
119 senkov 325 }
120    
121 schoenebeck 563 printf("LinuxSampler initialization completed. :-)\n\n");
122 schoenebeck 9
123 senkov 360 std::list<LSCPEvent::event_t> rtEvents;
124     rtEvents.push_back(LSCPEvent::event_voice_count);
125     rtEvents.push_back(LSCPEvent::event_stream_count);
126     rtEvents.push_back(LSCPEvent::event_buffer_fill);
127 iliev 778 rtEvents.push_back(LSCPEvent::event_total_voice_count);
128 senkov 360
129 schoenebeck 420 while (true) {
130     if (bPrintStatistics) {
131 persson 840 const std::set<Engine*>& engines = EngineFactory::EngineInstances();
132 schoenebeck 420 std::set<Engine*>::iterator itEngine = engines.begin();
133     for (int i = 0; itEngine != engines.end(); itEngine++, i++) {
134     Engine* pEngine = *itEngine;
135     printf("Engine %d) Voices: %3.3d (Max: %3.3d) Streams: %3.3d (Max: %3.3d)\n", i,
136     pEngine->VoiceCount(), pEngine->VoiceCountMax(),
137     pEngine->DiskStreamCount(), pEngine->DiskStreamCountMax()
138     );
139     fflush(stdout);
140     }
141     }
142 persson 425
143 senkov 325 sleep(1);
144     if (profile)
145     {
146 persson 425 unsigned int samplingFreq = 48000; //FIXME: hardcoded for now
147 iliev 1161 unsigned int bv = LinuxSampler::gig::Profiler::GetBogoVoices(samplingFreq);
148 persson 425 if (bv != 0)
149     {
150     printf(" BogoVoices: %i \r", bv);
151     fflush(stdout);
152     }
153 senkov 325 }
154 persson 425
155 senkov 360 if (LSCPServer::EventSubscribers(rtEvents))
156     {
157 persson 425 LSCPServer::LockRTNotify();
158     std::map<uint,SamplerChannel*> channels = pSampler->GetSamplerChannels();
159     std::map<uint,SamplerChannel*>::iterator iter = channels.begin();
160     for (; iter != channels.end(); iter++) {
161     SamplerChannel* pSamplerChannel = iter->second;
162     EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
163     if (!pEngineChannel) continue;
164     Engine* pEngine = pEngineChannel->GetEngine();
165     if (!pEngine) continue;
166 iliev 1130 pSampler->fireVoiceCountChanged(iter->first, pEngine->VoiceCount());
167     pSampler->fireStreamCountChanged(iter->first, pEngine->DiskStreamCount());
168     pSampler->fireBufferFillChanged(iter->first, pEngine->DiskStreamBufferFillPercentage());
169     pSampler->fireTotalVoiceCountChanged(pSampler->GetVoiceCount());
170 persson 425 }
171     LSCPServer::UnlockRTNotify();
172 senkov 360 }
173    
174 senoner 10 }
175    
176 schoenebeck 9 return EXIT_SUCCESS;
177     }
178    
179 schoenebeck 271 void signal_handler(int iSignal) {
180     switch (iSignal) {
181     case SIGINT: {
182     if (pthread_equal(pthread_self(), main_thread)) {
183     if (pLSCPServer) {
184     pLSCPServer->StopThread();
185     delete pLSCPServer;
186     }
187     if (pSampler) delete pSampler;
188 iliev 1161 #if HAVE_SQLITE3
189     InstrumentsDb::Destroy();
190     #endif
191 schoenebeck 271 printf("LinuxSampler stopped due to SIGINT.\n");
192     exit(EXIT_SUCCESS);
193     }
194     return;
195 schoenebeck 53 }
196 schoenebeck 271 case SIGSEGV:
197     std::cerr << ">>> FATAL ERROR: Segmentation fault (SIGSEGV) occured! <<<\n" << std::flush;
198     break;
199     case SIGBUS:
200     std::cerr << ">>> FATAL ERROR: Access to undefined portion of a memory object (SIGBUS) occured! <<<\n" << std::flush;
201     break;
202     case SIGILL:
203     std::cerr << ">>> FATAL ERROR: Illegal instruction (SIGILL) occured! <<<\n" << std::flush;
204     break;
205     case SIGFPE:
206     std::cerr << ">>> FATAL ERROR: Erroneous arithmetic operation (SIGFPE) occured! <<<\n" << std::flush;
207     break;
208     case SIGUSR1:
209     std::cerr << ">>> User defined signal 1 (SIGUSR1) received <<<\n" << std::flush;
210     break;
211     case SIGUSR2:
212     std::cerr << ">>> User defined signal 2 (SIGUSR2) received <<<\n" << std::flush;
213     break;
214     default: { // this should never happen, as we register for the signals we want
215     std::cerr << ">>> FATAL ERROR: Unknown signal received! <<<\n" << std::flush;
216     break;
217     }
218 schoenebeck 9 }
219 schoenebeck 271 signal(iSignal, SIG_DFL); // Reinstall default handler to prevent race conditions
220     std::cerr << "Showing stack trace...\n" << std::flush;
221     StackTrace();
222     sleep(2);
223     std::cerr << "Killing LinuxSampler...\n" << std::flush;
224     kill_app(); // Use abort() if we want to generate a core dump.
225 schoenebeck 9 }
226    
227 schoenebeck 271 void kill_app() {
228 wylder 816 kill(main_pid, SIGKILL);
229 schoenebeck 271 }
230    
231 senkov 325 void parse_options(int argc, char **argv) {
232 schoenebeck 9 int res;
233     int option_index = 0;
234     static struct option long_options[] =
235     {
236     {"help",0,0,0},
237 senkov 325 {"version",0,0,0},
238     {"profile",0,0,0},
239     {"no-tune",0,0,0},
240 schoenebeck 420 {"statistics",0,0,0},
241 iliev 1208 {"instruments-db-location",1,0,0},
242 iliev 1187 {"create-instruments-db",1,0,0},
243 senkov 667 {"lscp-addr",1,0,0},
244     {"lscp-port",1,0,0},
245 schoenebeck 9 {0,0,0,0}
246     };
247    
248     while (true) {
249 schoenebeck 361 /*
250     Stephane Letz : letz@grame.fr
251     getopt_long_only does not exist on OSX : replaced by getopt_long for now.
252     */
253     res = getopt_long(argc, argv, "", long_options, &option_index);
254 schoenebeck 9 if(res == -1) break;
255     if (res == 0) {
256     switch(option_index) {
257 senkov 325 case 0: // --help
258     printf("usage: linuxsampler [OPTIONS]\n\n");
259 iliev 1208 printf("--help prints this message\n");
260     printf("--version prints version information\n");
261     printf("--profile profile synthesis algorithms\n");
262     printf("--no-tune disable assembly optimization\n");
263     printf("--statistics periodically prints statistics\n");
264     printf("--lscp-addr set LSCP address (default: any)\n");
265     printf("--lscp-port set LSCP port (default: 8888)\n");
266     printf("--create-instruments-db creates an instruments DB\n");
267     printf("--instruments-db-location specifies the instruments DB file\n");
268 senkov 325 exit(EXIT_SUCCESS);
269 schoenebeck 9 break;
270 senkov 325 case 1: // --version
271 schoenebeck 328 printf("LinuxSampler %s\n", VERSION);
272     exit(EXIT_SUCCESS);
273 schoenebeck 9 break;
274 senkov 325 case 2: // --profile
275 persson 425 profile = true;
276 schoenebeck 20 break;
277 senkov 325 case 3: // --no-tune
278 persson 425 tune = false;
279 schoenebeck 9 break;
280 schoenebeck 420 case 4: // --statistics
281     bPrintStatistics = true;
282     break;
283 iliev 1208 case 5: // --instruments-db-location
284 iliev 1187 #if HAVE_SQLITE3
285     try {
286     if (optarg) {
287 iliev 1208 struct stat statBuf;
288     int res = stat(optarg, &statBuf);
289    
290     if (res) {
291     std::stringstream ss;
292     ss << "Fail to stat `" << optarg << "`: " << strerror(errno);
293     throw Exception(ss.str());
294     }
295    
296     if (!S_ISREG(statBuf.st_mode)) {
297     std::stringstream ss;
298     ss << "`" << optarg << "` is not a regular file";
299     throw Exception(ss.str());
300     }
301    
302     InstrumentsDb::GetInstrumentsDb()->SetDbFile(String(optarg));
303     }
304     } catch(Exception e) {
305     std::cerr << e.Message() << std::endl << std::endl;
306     return;
307     }
308    
309     return;
310     #else
311     std::cerr << "LinuxSampler was not build with ";
312     std::cerr << "instruments database support." <<std::endl;
313     return;
314     #endif
315     case 6: // --create-instruments-db
316     #if HAVE_SQLITE3
317     try {
318     if (optarg) {
319 iliev 1187 std::cout << "Creating instruments database..." << std::endl;
320     InstrumentsDb::CreateInstrumentsDb(String(optarg));
321     InstrumentsDb::Destroy();
322     std::cout << "Done" << std::endl;
323     }
324     } catch(Exception e) {
325     std::cerr << e.Message() << std::endl;
326     exit(EXIT_FAILURE);
327     return;
328     }
329    
330     exit(EXIT_SUCCESS);
331     return;
332     #else
333     std::cerr << "Failed to create the database. LinuxSampler was ";
334     std::cerr << "not build with instruments database support." <<std::endl;
335     exit(EXIT_FAILURE);
336     return;
337     #endif
338 iliev 1208 case 7: // --lscp-addr
339 iliev 1187 struct in_addr addr;
340     if (inet_aton(optarg, &addr) == 0)
341     printf("WARNING: Failed to parse lscp-addr argument, ignoring!\n");
342     else
343     lscp_addr = addr.s_addr;
344 senkov 667 break;
345 iliev 1208 case 8: // --lscp-port
346 iliev 1187 long unsigned int port = 0;
347     if ((sscanf(optarg, "%u", &port) != 1) || (port == 0) || (port > 65535))
348     printf("WARNING: Failed to parse lscp-port argument, ignoring!\n");
349     else
350     lscp_port = htons(port);
351 senkov 667 break;
352 schoenebeck 9 }
353     }
354     }
355 senkov 325 }

  ViewVC Help
Powered by ViewVC