videohubctrl can be used to control Blackmagic Design Videohub SDI router device over the network.
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.

videohubctrl.c 20KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536
  1. /*
  2. * Blackmagic Design Videohub control application
  3. * Copyright (C) 2014 Unix Solutions Ltd.
  4. * Written by Georgi Chorbadzhiyski
  5. *
  6. * Released under MIT license.
  7. * See LICENSE-MIT.txt for license terms.
  8. *
  9. */
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <getopt.h>
  14. #include <unistd.h>
  15. #include <sys/types.h>
  16. #include <sys/stat.h>
  17. #include <unistd.h>
  18. #include <errno.h>
  19. #include "data.h"
  20. #include "cmd.h"
  21. #include "net.h"
  22. #include "util.h"
  23. #include "display.h"
  24. #include "version.h"
  25. #include "libfuncs/libfuncs.h"
  26. int debug;
  27. int quiet;
  28. static struct videohub_data maindata;
  29. static int show_info = 1;
  30. static int show_monitor = 0;
  31. static int show_backup = 0;
  32. static int show_list = 0;
  33. static char *test_data;
  34. enum list_actions {
  35. action_list_device = (1 << 0),
  36. action_list_vinputs = (1 << 1),
  37. action_list_voutputs = (1 << 2),
  38. action_list_moutputs = (1 << 3),
  39. action_list_serial = (1 << 4),
  40. action_list_proc_units = (1 << 5),
  41. action_list_frames = (1 << 6),
  42. };
  43. static const char *program_id = PROGRAM_NAME " Version: " VERSION " Git: " GIT_VER;
  44. static const char short_options[] = "h:p:T:qdHVimb";
  45. static const struct option long_options[] = {
  46. { "host", required_argument, NULL, 'h' },
  47. { "port", required_argument, NULL, 'p' },
  48. { "test-input", required_argument, NULL, 'T' },
  49. { "quiet", no_argument, NULL, 'q' },
  50. { "debug", no_argument, NULL, 'd' },
  51. { "help", no_argument, NULL, 'H' },
  52. { "version", no_argument, NULL, 'V' },
  53. { "info", no_argument, NULL, 'i' },
  54. { "monitor", no_argument, NULL, 'm' },
  55. { "backup", no_argument, NULL, 'b' },
  56. { "list-device", no_argument, NULL, 901 },
  57. { "list-inputs", no_argument, NULL, 902 },
  58. { "list-vinputs", no_argument, NULL, 902 },
  59. { "list-outputs", no_argument, NULL, 903 },
  60. { "list-voutputs", no_argument, NULL, 903 },
  61. { "list-monitoring", no_argument, NULL, 904 },
  62. { "list-moutputs", no_argument, NULL, 904 },
  63. { "list-serial", no_argument, NULL, 905 },
  64. { "list-proc-units", no_argument, NULL, 906 },
  65. { "list-frames", no_argument, NULL, 907 },
  66. { "set-name", required_argument, NULL, 950 },
  67. { "in-name", required_argument, NULL, 1001 },
  68. { "in-output", required_argument, NULL, 1002 },
  69. { "in-monitor", required_argument, NULL, 1003 },
  70. { "vi-name", required_argument, NULL, 1001 },
  71. { "vi-output", required_argument, NULL, 1002 },
  72. { "vi-monitor", required_argument, NULL, 1003 },
  73. { "out-name", required_argument, NULL, 2001 },
  74. { "out-input", required_argument, NULL, 2002 },
  75. { "out-route", required_argument, NULL, 2002 }, // Alias
  76. { "out-lock", required_argument, NULL, 2003 },
  77. { "out-unlock", required_argument, NULL, 2004 },
  78. { "vo-name", required_argument, NULL, 2001 },
  79. { "vo-input", required_argument, NULL, 2002 },
  80. { "vo-route", required_argument, NULL, 2002 }, // Alias
  81. { "vo-lock", required_argument, NULL, 2003 },
  82. { "vo-unlock", required_argument, NULL, 2004 },
  83. { "mon-name", required_argument, NULL, 3001 },
  84. { "mon-input", required_argument, NULL, 3002 },
  85. { "mon-route", required_argument, NULL, 3002 }, // Alias
  86. { "mon-lock", required_argument, NULL, 3003 },
  87. { "mon-unlock", required_argument, NULL, 3004 },
  88. { "mo-name", required_argument, NULL, 3001 },
  89. { "mo-input", required_argument, NULL, 3002 },
  90. { "mo-route", required_argument, NULL, 3002 }, // Alias
  91. { "mo-lock", required_argument, NULL, 3003 },
  92. { "mo-unlock", required_argument, NULL, 3004 },
  93. { "ser-name", required_argument, NULL, 4001 },
  94. { "ser-input", required_argument, NULL, 4002 },
  95. { "ser-connect", required_argument, NULL, 4002 }, // Alias
  96. { "ser-route", required_argument, NULL, 4002 }, // Alias
  97. { "ser-lock", required_argument, NULL, 4003 },
  98. { "ser-unlock", required_argument, NULL, 4004 },
  99. { "ser-dir", required_argument, NULL, 4005 },
  100. { "ser-clear", required_argument, NULL, 4006 },
  101. { "se-name", required_argument, NULL, 4001 },
  102. { "se-input", required_argument, NULL, 4002 },
  103. { "se-connect", required_argument, NULL, 4002 }, // Alias
  104. { "se-route", required_argument, NULL, 4002 }, // Alias
  105. { "se-lock", required_argument, NULL, 4003 },
  106. { "se-unlock", required_argument, NULL, 4004 },
  107. { "se-dir", required_argument, NULL, 4005 },
  108. { "se-clear", required_argument, NULL, 4006 },
  109. { "pu-input", required_argument, NULL, 5001 },
  110. { "pu-connect", required_argument, NULL, 5001 }, // Alias
  111. { "pu-route", required_argument, NULL, 5001 }, // Alias
  112. { "pu-lock", required_argument, NULL, 5002 },
  113. { "pu-unlock", required_argument, NULL, 5003 },
  114. { "pu-clear", required_argument, NULL, 5004 },
  115. { "fr-name", required_argument, NULL, 6001 },
  116. { "fr-output", required_argument, NULL, 6002 },
  117. { "fr-connect", required_argument, NULL, 6002 }, // Alias
  118. { "fr-input", required_argument, NULL, 6002 }, // Alias
  119. { "fr-route", required_argument, NULL, 6002 }, // Alias
  120. { "fr-lock", required_argument, NULL, 6003 },
  121. { "fr-unlock", required_argument, NULL, 6004 },
  122. { "fr-clear", required_argument, NULL, 6006 },
  123. { 0, 0, 0, 0 }
  124. };
  125. static void show_help(struct videohub_data *data) {
  126. printf("%s\n", program_id);
  127. printf("\n");
  128. printf(" Usage: " PROGRAM_NAME " --host <host> [..commands..]\n");
  129. printf("\n");
  130. printf("Main options:\n");
  131. printf(" -h --host <host> | Set device host name.\n");
  132. printf(" -p --port <port_number> | Set device port (default: 9990).\n");
  133. printf("\n");
  134. printf("Commands:\n");
  135. printf(" -i --info | Show full device info (default command).\n");
  136. printf(" . This command is shows the equivalent of\n");
  137. printf(" . running all --list-XXX commands.\n");
  138. printf(" -m --monitor | Display real-time config changes monitor.\n");
  139. printf(" -b --backup | Show the command line that will restore\n");
  140. printf(" . the device to the current configuration.\n");
  141. printf("\n");
  142. printf(" --list-device | Display device info.\n");
  143. printf(" --list-inputs | List device input ports.\n");
  144. printf(" --list-outputs | List device output ports.\n");
  145. printf(" --list-monitor | List device monitoring outputs.\n");
  146. printf(" --list-serial | List device serial ports.\n");
  147. printf(" --list-proc-units | List device processing units.\n");
  148. printf(" --list-frames | List device frame buffers.\n");
  149. printf("\n");
  150. printf(" --set-name <name> | Set the device \"friendly name\".\n");
  151. printf("\n");
  152. printf("Inputs configuration:\n");
  153. printf(" --in-name <in_X> <name> | Set input port X name.\n");
  154. printf(" --in-output <in_X> <out_Y> | Route input X to output Y.\n");
  155. printf(" --in-monitor <in_X> <mout_Y> | Route input X to monitor port Y.\n");
  156. printf("\n");
  157. printf("Outputs configuration:\n");
  158. printf(" --out-name <out_X> <name> | Set output port X name.\n");
  159. printf(" --out-input <out_X> <in_Y> | Connect output X to input Y.\n");
  160. printf(" --out-lock <out_X> | Lock output port X.\n");
  161. printf(" --out-unlock <out_X> | Unlock output port X.\n");
  162. printf("\n");
  163. printf("Monitoring outputs configuration:\n");
  164. printf(" --mon-name <mout_X> <name> | Set monitoring port X name.\n");
  165. printf(" --mon-input <mout_X> <in_Y> | Connect monitoring X to input Y.\n");
  166. printf(" --mon-lock <mout_X> | Lock monitoring port X.\n");
  167. printf(" --mon-unlock <mout_X> | Unlock monitoring port X.\n");
  168. printf("\n");
  169. printf("Serial ports configuration:\n");
  170. printf(" --ser-name <ser_X> <name> | Set serial port X name.\n");
  171. printf(" --ser-connect <ser_X> <ser_Y> | Connect serial X to serial Y.\n");
  172. printf(" --ser-clear <ser_X> | Disconnect serial port X from serial Y.\n");
  173. printf(" --ser-lock <ser_X> | Lock serial port X.\n");
  174. printf(" --ser-unlock <ser_X> | Unlock serial port X.\n");
  175. printf(" --ser-dir <ser_X> <dir> | Set serial port X direction.\n");
  176. printf(" . <dir> can be 'auto', 'in' or 'out'.\n");
  177. printf("\n");
  178. printf("Processing units configuration:\n");
  179. printf(" --pu-input <pu_X> <in_Y> | Connect processing unit X to input Y.\n");
  180. printf(" --pu-clear <pu_X> | Disconnect unit X from input Y.\n");
  181. printf(" --pu-lock <pu_X> | Lock processing unit X.\n");
  182. printf(" --pu-unlock <pu_X> | Unlock processing unit X.\n");
  183. printf("\n");
  184. printf("Frames configuration:\n");
  185. printf(" --fr-name <fr_X> <name> | Set frame X name.\n");
  186. printf(" --fr-output <fr_X> <out_Y> | Output frame X to output Y.\n");
  187. printf(" --fr-clear <fr_X> | Stop outputing frame X to the output.\n");
  188. printf(" --fr-lock <fr_X> | Lock frame X.\n");
  189. printf(" --fr-unlock <rf_X> | Unlock frame X.\n");
  190. printf("\n");
  191. printf("Misc options:\n");
  192. printf(" -T --test-input <file> | Read commands from <file>.\n");
  193. printf(" -d --debug | Increase logging verbosity.\n");
  194. printf(" -q --quiet | Suppress warnings.\n");
  195. printf(" -H --help | Show help screen.\n");
  196. printf(" -V --version | Show program version.\n");
  197. printf("\n");
  198. }
  199. static int num_parsed_cmds = 0;
  200. static struct run_cmds {
  201. struct vcmd_entry entry[MAX_RUN_CMDS];
  202. } parsed_cmds;
  203. static void check_num_parsed_cmds(void) {
  204. if (num_parsed_cmds == ARRAY_SIZE(parsed_cmds.entry))
  205. die("No more than %u commands are supported.", num_parsed_cmds);
  206. }
  207. static void parse_cmd2(int argc, char **argv, enum vcmd vcmd) {
  208. check_num_parsed_cmds();
  209. struct vcmd_entry *c = &parsed_cmds.entry[num_parsed_cmds];
  210. if (optind == argc || argv[optind - 1][0] == '-' || argv[optind][0] == '-') {
  211. fprintf(stderr, "%s: option '%s' requires two arguments\n", argv[0], argv[optind - 2]);
  212. exit(EXIT_FAILURE);
  213. }
  214. c->cmd = &videohub_commands[vcmd];
  215. c->p1.param = argv[optind - 1];
  216. c->p2.param = argv[optind];
  217. if (vcmd == CMD_SERIAL_PORT_DIRECTIONS) {
  218. if (strcasecmp("in", c->p2.param) == 0) c->direction = DIR_CONTROL;
  219. else if (strcasecmp("out", c->p2.param) == 0) c->direction = DIR_SLAVE;
  220. else if (strcasecmp("auto", c->p2.param) == 0) c->direction = DIR_AUTO;
  221. else die("Invalid serial port direction '%s'. Allowed are: in, out, auto.", c->p2.param);
  222. }
  223. num_parsed_cmds++;
  224. }
  225. static void parse_cmd2s(int argc, char **argv, enum vcmd vcmd) {
  226. check_num_parsed_cmds();
  227. struct vcmd_entry *c = &parsed_cmds.entry[num_parsed_cmds];
  228. c->cmd = &videohub_commands[vcmd];
  229. c->p1.param = optarg;
  230. c->p2.param = "1"; // Fake
  231. c->clear_port = true;
  232. num_parsed_cmds++;
  233. }
  234. static void parse_cmd1(int argc, char **argv, enum vcmd vcmd, bool do_lock) {
  235. check_num_parsed_cmds();
  236. struct vcmd_entry *c = &parsed_cmds.entry[num_parsed_cmds];
  237. c->cmd = &videohub_commands[vcmd];
  238. c->p1.param = argv[optind - 1];
  239. c->do_lock = do_lock;
  240. num_parsed_cmds++;
  241. }
  242. static void set_device_option(char *setting, char *value) {
  243. check_num_parsed_cmds();
  244. struct vcmd_entry *c = &parsed_cmds.entry[num_parsed_cmds];
  245. c->cmd = &videohub_commands[CMD_VIDEOHUB_DEVICE];
  246. c->p1.param = setting;
  247. c->p2.param = value;
  248. num_parsed_cmds++;
  249. }
  250. static void switch_cmd_args(void) {
  251. char *p1, *p2;
  252. parsed_cmds.entry[num_parsed_cmds-1].reversed_args = 1;
  253. p1 = parsed_cmds.entry[num_parsed_cmds-1].p1.param;
  254. p2 = parsed_cmds.entry[num_parsed_cmds-1].p2.param;
  255. parsed_cmds.entry[num_parsed_cmds-1].p1.param = p2;
  256. parsed_cmds.entry[num_parsed_cmds-1].p2.param = p1;
  257. }
  258. static void parse_options(struct videohub_data *data, int argc, char **argv) {
  259. int j, err = 0;
  260. // Check environment
  261. data->dev_host = getenv("VIDEOHUB_HOST");
  262. data->dev_port = getenv("VIDEOHUB_PORT");
  263. // Set defaults
  264. if (!data->dev_port)
  265. data->dev_port = "9990";
  266. while ((j = getopt_long(argc, argv, short_options, long_options, NULL)) != -1) {
  267. if (j == '?') // Invalid parameter
  268. exit(EXIT_FAILURE);
  269. switch (j) {
  270. case 'h': // --host
  271. data->dev_host = optarg;
  272. break;
  273. case 'p': // --port
  274. data->dev_port = optarg;
  275. break;
  276. case 'T': { // --test-input
  277. struct stat st;
  278. FILE *f;
  279. if (stat(optarg, &st) != 0)
  280. die("Can't stat %s: %s", optarg, strerror(errno));
  281. f = fopen(optarg, "r");
  282. if (!f)
  283. die("Can't open %s: %s", optarg, strerror(errno));
  284. test_data = xzalloc(st.st_size + 1);
  285. if (fread(test_data, st.st_size, 1, f) < 1)
  286. die("Can't read from %s: %s", optarg, strerror(errno));
  287. fclose(f);
  288. data->dev_host = "sdi-matrix";
  289. break;
  290. }
  291. case 'd': // --debug
  292. debug++;
  293. if (debug)
  294. quiet = 0; // Disable quiet
  295. break;
  296. case 'q': // --quiet
  297. quiet = !quiet;
  298. break;
  299. case 'i': // --info
  300. show_info = 1;
  301. break;
  302. case 'm': // --monitor
  303. show_monitor = 1;
  304. break;
  305. case 'b': // --backup
  306. show_backup = 1;
  307. break;
  308. case 901: show_list |= action_list_device; break; // --list-device
  309. case 902: show_list |= action_list_vinputs; break; // --list-vinputs
  310. case 903: show_list |= action_list_voutputs; break; // --list-voutputs
  311. case 904: show_list |= action_list_moutputs; break; // --list-moutputs
  312. case 905: show_list |= action_list_serial; break; // --list-serial
  313. case 906: show_list |= action_list_proc_units; break; // --list-proc-units
  314. case 907: show_list |= action_list_frames; break; // --list-frames
  315. case 950: set_device_option("Friendly name", optarg); break; // --set-name
  316. case 1001: parse_cmd2(argc, argv, CMD_INPUT_LABELS); break; // --in-name
  317. case 1002: parse_cmd2(argc, argv, CMD_VIDEO_OUTPUT_ROUTING); switch_cmd_args(); break; // --in-output
  318. case 1003: parse_cmd2(argc, argv, CMD_MONITORING_OUTPUT_ROUTING); switch_cmd_args(); break; // --in-monitor
  319. case 2001: parse_cmd2(argc, argv, CMD_OUTPUT_LABELS); break; // --out-name
  320. case 2002: parse_cmd2(argc, argv, CMD_VIDEO_OUTPUT_ROUTING); break; // --out-input
  321. case 2003: parse_cmd1(argc, argv, CMD_VIDEO_OUTPUT_LOCKS, true); break; // --out-lock
  322. case 2004: parse_cmd1(argc, argv, CMD_VIDEO_OUTPUT_LOCKS, false); break; // --out-unlock
  323. case 3001: parse_cmd2(argc, argv, CMD_MONITORING_OUTPUT_LABELS); break; // --mon-name
  324. case 3002: parse_cmd2(argc, argv, CMD_MONITORING_OUTPUT_ROUTING); break; // --mon-input
  325. case 3003: parse_cmd1(argc, argv, CMD_MONITORING_OUTPUT_LOCKS, true); break; // --mon-lock
  326. case 3004: parse_cmd1(argc, argv, CMD_MONITORING_OUTPUT_LOCKS, false); break; // --mon-unlock
  327. case 4001: parse_cmd2(argc, argv, CMD_SERIAL_PORT_LABELS); break; // --ser-name
  328. case 4002: parse_cmd2(argc, argv, CMD_SERIAL_PORT_ROUTING); break; // --ser-input
  329. case 4003: parse_cmd1(argc, argv, CMD_SERIAL_PORT_LOCKS, true); break; // --ser-lock
  330. case 4004: parse_cmd1(argc, argv, CMD_SERIAL_PORT_LOCKS, false); break; // --ser-unlock
  331. case 4005: parse_cmd2(argc, argv, CMD_SERIAL_PORT_DIRECTIONS); break; // --ser-dir
  332. case 4006: parse_cmd2s(argc, argv, CMD_SERIAL_PORT_ROUTING); break; // --ser-clear
  333. case 5001: parse_cmd2(argc, argv, CMD_PROCESSING_UNIT_ROUTING); break; // --pu-input
  334. case 5002: parse_cmd1(argc, argv, CMD_PROCESSING_UNIT_LOCKS, true); break; // --pu-lock
  335. case 5003: parse_cmd1(argc, argv, CMD_PROCESSING_UNIT_LOCKS, false); break; // --pu-unlock
  336. case 5004: parse_cmd2s(argc, argv, CMD_PROCESSING_UNIT_ROUTING); break; // --pu-clear
  337. case 6001: parse_cmd2(argc, argv, CMD_FRAME_LABELS); break; // --fr-name
  338. case 6002: parse_cmd2(argc, argv, CMD_FRAME_BUFFER_ROUTING); break; // --fr-input
  339. case 6003: parse_cmd1(argc, argv, CMD_FRAME_BUFFER_LOCKS, true); break; // --fr-lock
  340. case 6004: parse_cmd1(argc, argv, CMD_FRAME_BUFFER_LOCKS, false); break; // --fr-unlock
  341. case 6005: parse_cmd2s(argc, argv, CMD_FRAME_BUFFER_ROUTING); break; // --fr-clear
  342. case 'H': // --help
  343. show_help(data);
  344. exit(EXIT_SUCCESS);
  345. case 'V': // --version
  346. printf("%s\n", program_id);
  347. exit(EXIT_SUCCESS);
  348. }
  349. }
  350. if (!data->dev_host || !strtoul(data->dev_port, NULL, 10))
  351. err = 1;
  352. if (err) {
  353. show_help(data);
  354. if (!data->dev_host)
  355. fprintf(stderr, "ERROR: host is not set. Use --host option.\n");
  356. exit(EXIT_FAILURE);
  357. }
  358. d("Device address: %s:%s\n", data->dev_host, data->dev_port);
  359. }
  360. static void check_number_of_ports(struct port_set *p) {
  361. if (p->num > ARRAY_SIZE(p->port))
  362. die("The device supports %d ports. Increase MAX_PORTS (%lu) and recompile the program.",
  363. p->num, ARRAY_SIZE(p->port));
  364. }
  365. static void reset_routed_to(struct port_set *p) {
  366. unsigned int i;
  367. for (i = 0; i < ARRAY_SIZE(p->port); i++)
  368. p->port[i].routed_to = NO_PORT;
  369. }
  370. static void print_device_full(struct videohub_data *d) {
  371. print_device_info(d);
  372. print_device_video_inputs(d);
  373. print_device_video_outputs(d);
  374. print_device_monitoring_outputs(d);
  375. print_device_serial_ports(d);
  376. print_device_processing_units(d);
  377. print_device_frame_buffers(d);
  378. fflush(stdout);
  379. }
  380. static int read_device_command_stream(struct videohub_data *d) {
  381. int ret, ncommands = 0;
  382. char buf[8192 + 1];
  383. if (test_data)
  384. return 0;
  385. memset(buf, 0, sizeof(buf));
  386. while ((ret = fdread_ex(d->dev_fd, buf, sizeof(buf) - 1, 5, 0, 0)) >= 0) {
  387. ncommands += parse_text_buffer(d, buf);
  388. memset(buf, 0, sizeof(buf));
  389. }
  390. return ncommands;
  391. }
  392. static void send_device_command(struct videohub_data *d, char *cmd_buffer) {
  393. if (!test_data)
  394. fdwrite(d->dev_fd, cmd_buffer, strlen(cmd_buffer));
  395. else
  396. parse_text_buffer(d, cmd_buffer);
  397. }
  398. int main(int argc, char **argv) {
  399. struct videohub_data *data = &maindata;
  400. parse_options(data, argc, argv);
  401. set_log_io_errors(0);
  402. if (!test_data) {
  403. data->dev_fd = connect_client(SOCK_STREAM, data->dev_host, data->dev_port);
  404. if (data->dev_fd < 0)
  405. exit(EXIT_FAILURE);
  406. }
  407. reset_routed_to(&data->inputs);
  408. reset_routed_to(&data->outputs);
  409. reset_routed_to(&data->serial);
  410. reset_routed_to(&data->proc_units);
  411. reset_routed_to(&data->frames);
  412. read_device_command_stream(data);
  413. if (test_data)
  414. parse_text_buffer(data, test_data);
  415. if (!strlen(data->device.protocol_ver) || !strlen(data->device.model_name))
  416. die("The device does not respond correctly. Is it Videohub?");
  417. if (strstr(data->device.protocol_ver, "2.") != data->device.protocol_ver)
  418. q("WARNING: Device protocol is %s but this program is tested with 2.x only.\n",
  419. data->device.protocol_ver);
  420. if (!data->device.dev_present) {
  421. if (data->device.needs_fw_update) {
  422. die("Device reports that it needs firmware update.");
  423. }
  424. die("Device reports that it is not present.");
  425. }
  426. check_number_of_ports(&data->inputs);
  427. check_number_of_ports(&data->outputs);
  428. check_number_of_ports(&data->mon_outputs);
  429. check_number_of_ports(&data->serial);
  430. check_number_of_ports(&data->proc_units);
  431. check_number_of_ports(&data->frames);
  432. if (num_parsed_cmds) {
  433. unsigned int i;
  434. for (i = 0; i < ARRAY_SIZE(parsed_cmds.entry); i++) {
  435. struct vcmd_entry *ve = &parsed_cmds.entry[i];
  436. if (!ve->p1.param)
  437. continue;
  438. prepare_cmd_entry(data, &parsed_cmds.entry[i]);
  439. }
  440. for (i = 0; i < ARRAY_SIZE(parsed_cmds.entry); i++) {
  441. char cmd_buffer[1024];
  442. struct vcmd_entry *ve = &parsed_cmds.entry[i];
  443. if (!ve->p1.param)
  444. continue;
  445. format_cmd_text(ve, cmd_buffer, sizeof(cmd_buffer));
  446. if (strlen(cmd_buffer)) {
  447. show_cmd(data, ve);
  448. send_device_command(data, cmd_buffer);
  449. read_device_command_stream(data);
  450. }
  451. }
  452. // Show the result after commands
  453. if (test_data)
  454. print_device_full(data);
  455. } else if (show_monitor) {
  456. while (1) {
  457. int sleeps = 0;
  458. printf("\e[2J\e[H"); // Clear screen
  459. time_t now = time(NULL);
  460. struct tm *tm = localtime(&now);
  461. printf("Last update: %s\n", asctime(tm));
  462. print_device_info(data);
  463. print_device_video_inputs(data);
  464. print_device_video_outputs(data);
  465. fflush(stdout);
  466. do {
  467. usleep(500000);
  468. if (++sleeps >= 20)
  469. send_device_command(data, "PING:\n\n");
  470. } while (read_device_command_stream(data) == 0);
  471. }
  472. } else if (show_list) {
  473. if (show_list & action_list_device) print_device_info(data);
  474. if (show_list & action_list_vinputs) print_device_video_inputs(data);
  475. if (show_list & action_list_voutputs) print_device_video_outputs(data);
  476. if (show_list & action_list_moutputs) print_device_monitoring_outputs(data);
  477. if (show_list & action_list_serial) print_device_serial_ports(data);
  478. if (show_list & action_list_proc_units) print_device_processing_units(data);
  479. if (show_list & action_list_frames) print_device_frame_buffers(data);
  480. fflush(stdout);
  481. } else if (show_backup) {
  482. print_device_backup(data);
  483. } else if (show_info) {
  484. print_device_full(data);
  485. }
  486. shutdown_fd(&data->dev_fd);
  487. free(test_data);
  488. return 0;
  489. }