jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
549 Commits
8 Branches
255MB
Tree: 0d088889f1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0d088889f1'
${ noResults }
jack2/common/Jackdmp.cpp

433 lines
13KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2001 Paul Davis 

  3. Copyright (C) 2004-2008 Grame

  4. 

  5. This program is free software; you can redistribute it and/or modify

  6. it under the terms of the GNU General Public License as published by

  7. the Free Software Foundation; either version 2 of the License, or

  8. (at your option) any later version.

  9. 

  10. This program is distributed in the hope that it will be useful,

  11. but WITHOUT ANY WARRANTY; without even the implied warranty of

  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13. GNU General Public License for more details.

  14. 

  15. You should have received a copy of the GNU General Public License

  16. along with this program; if not, write to the Free Software

  17. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  18. 

  19. */

  20. 

  21. #include <iostream>

  22. #include <assert.h>

  23. #include <signal.h>

  24. #include <pwd.h>

  25. #include <sys/types.h>

  26. #include <dirent.h>

  27. #include <getopt.h>

  28. 

  29. #include "JackServer.h"

  30. #include "JackConstants.h"

  31. #include "driver_interface.h"

  32. #include "driver_parse.h"

  33. #include "JackDriverLoader.h"

  34. #include "jslist.h"

  35. #include "JackError.h"

  36. #include "JackTools.h"

  37. #include "shm.h"

  38. #include "jack.h"

  39. 

  40. #ifdef __APPLE_

  41. #include <CoreFoundation/CFNotificationCenter.h>

  42. #endif

  43. 

  44. using namespace Jack;

  45. 

  46. static JackServer* fServer;

  47. static char* server_name = NULL;

  48. static int realtime_priority = 10;

  49. static int do_mlock = 1;

  50. static unsigned int port_max = 128;

  51. static int realtime = 0;

  52. static int loopback = 0;

  53. static int temporary = 0;

  54. static int client_timeout = 0; /* msecs; if zero, use period size. */

  55. static int do_unlock = 0;

  56. static JSList* drivers = NULL;

  57. static sigset_t signals;

  58. 

  59. static void silent_jack_error_callback(const char *desc)

  60. {}

  61. 

  62. static void copyright(FILE* file)

  63. {

  64.     fprintf(file, "jackdmp " VERSION "\n"

  65.              "Copyright 2001-2005 Paul Davis and others.\n"

  66.              "Copyright 2004-2008 Grame.\n"

  67.              "jackdmp comes with ABSOLUTELY NO WARRANTY\n"

  68.              "This is free software, and you are welcome to redistribute it\n"

  69.              "under certain conditions; see the file COPYING for details\n");

  70. }

  71. 

  72. static void usage(FILE* file)

  73. {

  74.     copyright(file);

  75.     fprintf(file, "\n"

  76.              "usage: jackdmp [ --realtime OR -R [ --realtime-priority OR -P priority ] ]\n"

  77. 			 "               [ --name OR -n server-name ]\n"

  78.              // "               [ --no-mlock OR -m ]\n"

  79.              // "               [ --unlock OR -u ]\n"

  80.              "               [ --timeout OR -t client-timeout-in-msecs ]\n"

  81.              "               [ --loopback OR -L loopback-port-number ]\n"

  82.              // "               [ --port-max OR -p maximum-number-of-ports]\n"

  83.              "               [ --verbose OR -v ]\n"

  84. 			 "               [ --replace-registry OR -r ]\n"

  85.              "               [ --silent OR -s ]\n"

  86.              "               [ --sync OR -S ]\n"

  87. 			 "               [ --temporary OR -T ]\n"

  88.              "               [ --version OR -V ]\n"

  89.              "         -d driver [ ... driver args ... ]\n"

  90.              "             where driver can be `alsa', `coreaudio', 'portaudio' or `dummy'\n"

  91.              "       jackdmp -d driver --help\n"

  92.              "             to display options for each driver\n\n");

  93. }

  94. 

  95. 

  96. static void DoNothingHandler(int sig)

  97. {

  98.     /* this is used by the child (active) process, but it never

  99.        gets called unless we are already shutting down after

  100.        another signal.

  101.     */

  102.     char buf[64];

  103.     snprintf(buf, sizeof(buf), "received signal %d during shutdown(ignored)\n", sig);

  104.     write(1, buf, strlen(buf));

  105. }

  106. 

  107. static int JackStart(const char* server_name, jack_driver_desc_t* driver_desc, JSList* driver_params, int sync, int temporary, int time_out_ms, int rt, int priority, int loopback, int verbose)

  108. {

  109.     JackLog("Jackdmp: sync = %ld timeout = %ld rt = %ld priority = %ld verbose = %ld \n", sync, time_out_ms, rt, priority, verbose);

  110.     fServer = new JackServer(sync, temporary, time_out_ms, rt, priority, loopback, verbose, server_name);

  111.     int res = fServer->Open(driver_desc, driver_params);

  112.     return (res < 0) ? res : fServer->Start();

  113. }

  114. 

  115. static int JackStop()

  116. {

  117.     fServer->Stop();

  118.     fServer->Close();

  119.     JackLog("Jackdmp: server close\n");

  120.     delete fServer;

  121.     JackLog("Jackdmp: delete server\n");

  122.     return 0;

  123. }

  124. 

  125. static int JackDelete()

  126. {

  127.     delete fServer;

  128.     JackLog("Jackdmp: delete server\n");

  129.     return 0;

  130. }

  131. 

  132. static void FilterSIGPIPE()

  133. {

  134.     sigset_t set;

  135.     sigemptyset(&set);

  136.     sigaddset(&set, SIGPIPE);

  137.     //sigprocmask(SIG_BLOCK, &set, 0);

  138.     pthread_sigmask(SIG_BLOCK, &set, 0);

  139. }

  140. 

  141. int main(int argc, char* argv[])

  142. {

  143.     int sig;

  144.     sigset_t allsignals;

  145.     struct sigaction action;

  146.     int waiting;

  147. 

  148.     jack_driver_desc_t* driver_desc;

  149.     const char *options = "-ad:P:uvrshVRL:STFl:t:mn:p:";

  150.     struct option long_options[] = {

  151.                                        { "driver", 1, 0, 'd' },

  152.                                        { "verbose", 0, 0, 'v' },

  153.                                        { "help", 0, 0, 'h' },

  154.                                        { "port-max", 1, 0, 'p' },

  155.                                        { "no-mlock", 0, 0, 'm' },

  156.                                        { "name", 0, 0, 'n' },

  157.                                        { "unlock", 0, 0, 'u' },

  158.                                        { "realtime", 0, 0, 'R' },

  159. 									   { "replace-registry", 0, 0, 'r' },

  160.                                        { "loopback", 0, 0, 'L' },

  161.                                        { "realtime-priority", 1, 0, 'P' },

  162.                                        { "timeout", 1, 0, 't' },

  163.                                        { "temporary", 0, 0, 'T' },

  164.                                        { "version", 0, 0, 'V' },

  165.                                        { "silent", 0, 0, 's' },

  166.                                        { "sync", 0, 0, 'S' },

  167.                                        { 0, 0, 0, 0 }

  168.                                    };

  169.     int opt = 0;

  170.     int option_index = 0;

  171.     int seen_driver = 0;

  172.     char *driver_name = NULL;

  173.     char **driver_args = NULL;

  174.     JSList* driver_params;

  175.     int driver_nargs = 1;

  176.     int show_version = 0;

  177. 	int replace_registry = 0;

  178.     int sync = 0;

  179.     int rc, i;

  180. 

  181.     opterr = 0;

  182.     while (!seen_driver &&

  183.             (opt = getopt_long(argc, argv, options,

  184.                                long_options, &option_index)) != EOF) {

  185.         switch (opt) {

  186. 

  187.             case 'd':

  188.                 seen_driver = 1;

  189.                 driver_name = optarg;

  190.                 break;

  191. 

  192.             case 'v':

  193.                 jack_verbose = 1;

  194.                 break;

  195. 

  196.             case 's':

  197.                 jack_set_error_function(silent_jack_error_callback);

  198.                 break;

  199. 

  200.             case 'S':

  201.                 sync = 1;

  202.                 break;

  203. 

  204.             case 'n':

  205.                 server_name = optarg;

  206.                 break;

  207. 

  208.             case 'm':

  209.                 do_mlock = 0;

  210.                 break;

  211. 

  212.             case 'p':

  213.                 port_max = (unsigned int)atol(optarg);

  214.                 break;

  215. 

  216.             case 'P':

  217.                 realtime_priority = atoi(optarg);

  218.                 break;

  219. 			

  220. 			case 'r':

  221. 				replace_registry = 1;

  222. 				break;

  223. 				

  224.             case 'R':

  225.                 realtime = 1;

  226.                 break;

  227. 

  228.             case 'L':

  229.                 loopback = atoi(optarg);

  230.                 break;

  231. 

  232.             case 'T':

  233.                 temporary = 1;

  234.                 break;

  235. 

  236.             case 't':

  237.                 client_timeout = atoi(optarg);

  238.                 break;

  239. 

  240.             case 'u':

  241.                 do_unlock = 1;

  242.                 break;

  243. 

  244.             case 'V':

  245.                 show_version = 1;

  246.                 break;

  247. 

  248.             default:

  249.                 fprintf(stderr, "unknown option character %c\n",

  250.                         optopt);

  251.                 /*fallthru*/

  252.             case 'h':

  253.                 usage(stdout);

  254.                 return -1;

  255.         }

  256.     }

  257. 

  258.     /*

  259.     if (show_version) {

  260.     	printf ( "jackd version " VERSION 

  261.     			" tmpdir " DEFAULT_TMP_DIR 

  262.     			" protocol " PROTOCOL_VERSION

  263.     			"\n");

  264.     	return -1;

  265.     }

  266.     */

  267. 

  268.     if (!seen_driver) {

  269.         usage(stderr);

  270.         exit(1);

  271.     }

  272. 

  273.     drivers = jack_drivers_load(drivers);

  274.     if (!drivers) {

  275.         fprintf(stderr, "jackdmp: no drivers found; exiting\n");

  276.         exit(1);

  277.     }

  278. 

  279.     driver_desc = jack_find_driver_descriptor(drivers, driver_name);

  280.     if (!driver_desc) {

  281.         fprintf(stderr, "jackdmp: unknown driver '%s'\n", driver_name);

  282.         exit(1);

  283.     }

  284. 

  285.     if (optind < argc) {

  286.         driver_nargs = 1 + argc - optind;

  287.     } else {

  288.         driver_nargs = 1;

  289.     }

  290. 

  291.     if (driver_nargs == 0) {

  292.         fprintf(stderr, "No driver specified ... hmm. JACK won't do"

  293.                  " anything when run like this.\n");

  294.         return -1;

  295.     }

  296. 

  297.     driver_args = (char **) malloc(sizeof(char *) * driver_nargs);

  298.     driver_args[0] = driver_name;

  299. 

  300.     for (i = 1; i < driver_nargs; i++) {

  301.         driver_args[i] = argv[optind++];

  302.     }

  303. 

  304.     if (jack_parse_driver_params(driver_desc, driver_nargs,

  305.                                   driver_args, &driver_params)) {

  306.         exit(0);

  307.     }

  308. 

  309.     if (server_name == NULL)

  310.         server_name = (char*)JackTools::DefaultServerName();

  311. 

  312.     copyright(stdout);

  313. 

  314.     rc = jack_register_server(server_name, replace_registry);

  315.     switch (rc) {

  316.         case EEXIST:

  317.             fprintf(stderr, "`%s' server already active\n", server_name);

  318.             exit(1);

  319.         case ENOSPC:

  320.             fprintf(stderr, "too many servers already active\n");

  321.             exit(2);

  322.         case ENOMEM:

  323.             fprintf(stderr, "no access to shm registry\n");

  324.             exit(3);

  325.         default:

  326.             if (jack_verbose)

  327.                 fprintf(stderr, "server `%s' registered\n", server_name);

  328.     }

  329. 

  330.     /* clean up shared memory and files from any previous

  331.      * instance of this server name */

  332.     jack_cleanup_shm();

  333.     JackTools::CleanupFiles(server_name);

  334. 

  335.     pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);

  336. 

  337.     sigemptyset(&signals);

  338.     sigaddset(&signals, SIGHUP);

  339.     sigaddset(&signals, SIGINT);

  340.     sigaddset(&signals, SIGQUIT);

  341.     sigaddset(&signals, SIGPIPE);

  342.     sigaddset(&signals, SIGTERM);

  343.     sigaddset(&signals, SIGUSR1);

  344.     sigaddset(&signals, SIGUSR2);

  345. 

  346.     // all child threads will inherit this mask unless they

  347.     // explicitly reset it

  348. 

  349.     FilterSIGPIPE();

  350.     pthread_sigmask(SIG_BLOCK, &signals, 0);

  351. 

  352.     if (!realtime && client_timeout == 0)

  353.         client_timeout = 500; /* 0.5 sec; usable when non realtime. */

  354. 

  355.     int res = JackStart(server_name, driver_desc, driver_params, sync, temporary, client_timeout, realtime, realtime_priority, loopback, jack_verbose);

  356.     if (res < 0) {

  357.         jack_error("Cannot start server... exit");

  358.         JackDelete();

  359.         return 0;

  360.     }

  361. 

  362. #ifdef __APPLE__

  363. 	CFStringRef ref = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);

  364.     // Send notification to be used in the JackRouter plugin

  365.     CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),

  366. 													CFSTR("com.grame.jackserver.start"),

  367. 													ref,

  368. 													NULL,

  369. 													kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);

  370. 	CFRelease(ref);

  371. #endif

  372. 	

  373.     // install a do-nothing handler because otherwise pthreads

  374.     // behaviour is undefined when we enter sigwait.

  375. 

  376.     sigfillset(&allsignals);

  377.     action.sa_handler = DoNothingHandler;

  378.     action.sa_mask = allsignals;

  379.     action.sa_flags = SA_RESTART | SA_RESETHAND;

  380. 

  381.     for (i = 1; i < NSIG; i++) {

  382.         if (sigismember(&signals, i)) {

  383.             sigaction(i, &action, 0);

  384.         }

  385.     }

  386. 

  387.     waiting = TRUE;

  388. 

  389.     while (waiting) {

  390.         sigwait(&signals, &sig);

  391.         fprintf(stderr, "jack main caught signal %d\n", sig);

  392. 

  393.         switch (sig) {

  394.             case SIGUSR1:

  395.                 //jack_dump_configuration(engine, 1);

  396.                 break;

  397.             case SIGUSR2:

  398.                 // driver exit

  399.                 waiting = FALSE;

  400.                 break;

  401.             default:

  402.                 waiting = FALSE;

  403.                 break;

  404.         }

  405.     }

  406. 

  407.     if (sig != SIGSEGV) {

  408.         // unblock signals so we can see them during shutdown.

  409.         // this will help prod developers not to lose sight of

  410.         // bugs that cause segfaults etc. during shutdown.

  411.         sigprocmask(SIG_UNBLOCK, &signals, 0);

  412.     }

  413. 	

  414. 	JackStop();

  415. 

  416.     jack_cleanup_shm();

  417.     JackTools::CleanupFiles(server_name);

  418.     jack_unregister_server(server_name);

  419. 

  420. #ifdef __APPLE__

  421. 	CFStringRef ref1 = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);

  422.     // Send notification to be used in the JackRouter plugin

  423.     CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),

  424. 													CFSTR("com.grame.jackserver.stop"),

  425. 													ref1,

  426. 													NULL,

  427. 													kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);

  428. 	CFRelease(ref1);

  429. #endif

  430. 

  431.     return 1;

  432. }