2 * jackwsmeter - jack meter over websockets
4 * Copyright (C) 2014 Frederic Peters <fpeters@0d.be>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation; either version 2 of the
9 * License, or (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public
17 * License along with this program; if not, see
18 * <http://www.gnu.org/licenses/>.
23 * from the libwebsockets test server: LGPL 2.1
24 * Copyright (C) 2010-2011 Andy Green <andy@warmcat.com>
25 * from jackmeter, GPL 2+
26 * Copyright (C) 2005 Nicholas J. Humfrey
41 #include <libwebsockets.h>
43 #include <jack/jack.h>
45 int max_poll_elements
;
47 struct pollfd
*pollfds
;
57 float peaks
[MAX_METERS
];
58 float sent_peaks
[MAX_METERS
];
60 jack_port_t
*input_ports
[MAX_METERS
];
61 jack_client_t
*client
= NULL
;
64 /* Read and reset the recent peak sample */
65 static void read_peaks()
67 memcpy(sent_peaks
, peaks
, sizeof(peaks
));
68 memset(peaks
, 0, sizeof(peaks
));
72 /* this protocol server (always the first one) just knows how to do HTTP */
74 static int callback_http(struct libwebsocket_context
*context
,
75 struct libwebsocket
*wsi
,
76 enum libwebsocket_callback_reasons reason
, void *user
,
80 int fd
= (int)(long)user
;
83 case LWS_CALLBACK_HTTP
:
84 if (libwebsockets_serve_http_file(context
, wsi
, "jackwsmeter.html", "text/html"))
85 return 1; /* through completion or error, close the socket */
89 case LWS_CALLBACK_HTTP_FILE_COMPLETION
:
92 case LWS_CALLBACK_ADD_POLL_FD
:
94 if (count_pollfds
>= max_poll_elements
) {
95 lwsl_err("LWS_CALLBACK_ADD_POLL_FD: too many sockets to track\n");
99 fd_lookup
[fd
] = count_pollfds
;
100 pollfds
[count_pollfds
].fd
= fd
;
101 pollfds
[count_pollfds
].events
= (int)(long)len
;
102 pollfds
[count_pollfds
++].revents
= 0;
105 case LWS_CALLBACK_DEL_POLL_FD
:
106 if (!--count_pollfds
)
109 /* have the last guy take up the vacant slot */
110 pollfds
[m
] = pollfds
[count_pollfds
];
111 fd_lookup
[pollfds
[count_pollfds
].fd
] = m
;
114 case LWS_CALLBACK_SET_MODE_POLL_FD
:
115 pollfds
[fd_lookup
[fd
]].events
|= (int)(long)len
;
118 case LWS_CALLBACK_CLEAR_MODE_POLL_FD
:
119 pollfds
[fd_lookup
[fd
]].events
&= ~(int)(long)len
;
130 callback_meter(struct libwebsocket_context
*context
,
131 struct libwebsocket
*wsi
,
132 enum libwebsocket_callback_reasons reason
,
133 void *user
, void *in
, size_t len
)
139 char buf
[LWS_SEND_BUFFER_PRE_PADDING
+ 512 + LWS_SEND_BUFFER_POST_PADDING
];
140 char *p
= &buf
[LWS_SEND_BUFFER_PRE_PADDING
];
144 case LWS_CALLBACK_ESTABLISHED
:
147 case LWS_CALLBACK_SERVER_WRITEABLE
:
149 for (i
=0; i
<num_meters
; i
++) {
150 db
= 20.0f
* log10f(sent_peaks
[i
] * bias
);
151 snprintf(one_peak
, 100, "%f ", db
);
152 strcat((char*)p
, one_peak
);
155 n
= libwebsocket_write(wsi
, (unsigned char*)p
, n
, LWS_WRITE_TEXT
);
157 lwsl_err("ERROR %d writing to socket\n", n
);
169 /* list of supported protocols and callbacks */
171 static struct libwebsocket_protocols protocols
[] = {
172 /* first protocol must always be HTTP handler */
175 "http-only", /* name */
176 callback_http
, /* callback */
177 0, /* per_session_data_size */
178 0, /* max frame size / rx buffer */
181 "jack-wsmeter-protocol",
186 { NULL
, NULL
, 0, 0 } /* terminator */
189 void sighandler(int sig
)
194 static struct option options
[] = {
195 { "help", no_argument
, NULL
, 'h' },
196 { "debug", required_argument
, NULL
, 'd' },
197 { "port", required_argument
, NULL
, 'p' },
198 { "ssl", no_argument
, NULL
, 's' },
199 { "interface", required_argument
, NULL
, 'i' },
200 { "closetest", no_argument
, NULL
, 'c' },
201 #ifndef LWS_NO_DAEMONIZE
202 { "daemonize", no_argument
, NULL
, 'D' },
204 { "name", required_argument
, NULL
, 'n' },
209 /* Callback called by JACK when audio is available.
210 Stores value of peak sample */
211 static int process_peak(jack_nframes_t nframes
, void *arg
)
213 unsigned int i
, port
;
215 for (port
= 0; port
< num_meters
; port
++) {
216 jack_default_audio_sample_t
*in
;
218 /* just incase the port isn't registered yet */
219 if (input_ports
[port
] == 0) {
223 in
= (jack_default_audio_sample_t
*) jack_port_get_buffer(input_ports
[port
], nframes
);
225 for (i
= 0; i
< nframes
; i
++) {
226 const float s
= fabs(in
[i
]);
227 if (s
> peaks
[port
]) {
237 /* Close down JACK when exiting */
238 static void cleanup()
240 const char **all_ports
;
243 lwsl_debug("cleanup()\n");
245 for (i
=0; i
<num_meters
; i
++) {
246 all_ports
= jack_port_get_all_connections(client
, input_ports
[i
]);
248 for (j
=0; all_ports
&& all_ports
[j
]; j
++) {
249 jack_disconnect(client
, all_ports
[j
], jack_port_name(input_ports
[i
]));
253 /* Leave the jack graph */
254 jack_client_close(client
);
260 int main(int argc
, char **argv
)
264 struct libwebsocket_context
*context
;
266 char interface_name
[128] = "";
267 char jack_name
[128] = "wsmeter";
268 const char *iface
= NULL
;
269 int syslog_options
= LOG_PID
| LOG_PERROR
;
270 unsigned int oldus
= 0;
271 struct lws_context_creation_info info
;
274 #ifndef LWS_NO_DAEMONIZE
278 jack_status_t status
;
280 memset(&info
, 0, sizeof info
);
284 n
= getopt_long(argc
, argv
, "ci:hsp:d:Dn:", options
, NULL
);
288 #ifndef LWS_NO_DAEMONIZE
291 syslog_options
&= ~LOG_PERROR
;
295 debug_level
= atoi(optarg
);
301 info
.port
= atoi(optarg
);
304 strncpy(interface_name
, optarg
, sizeof interface_name
);
305 interface_name
[(sizeof interface_name
) - 1] = '\0';
306 iface
= interface_name
;
309 strncpy(jack_name
, optarg
, sizeof jack_name
);
310 jack_name
[(sizeof jack_name
) - 1] = '\0';
313 fprintf(stderr
, "Usage: jackwsserver "
314 "[--port=<p>] [--ssl] "
315 "[-d <log bitfield>] <port>+\n");
320 #if !defined(LWS_NO_DAEMONIZE)
322 * normally lock path would be /var/lock/jwsm or similar, to
323 * simplify getting started without having to take care about
324 * permissions or running as root, set to /tmp/.jwsm-lock
326 if (daemonize
&& lws_daemonize("/tmp/.jwsm-lock")) {
327 fprintf(stderr
, "Failed to daemonize\n");
332 signal(SIGINT
, sighandler
);
334 /* we will only try to log things according to our debug_level */
335 setlogmask(LOG_UPTO (LOG_DEBUG
));
336 openlog("jackwsmeter", syslog_options
, LOG_DAEMON
);
338 /* tell the library what debug level to emit and to send it to syslog */
339 lws_set_log_level(debug_level
, lwsl_emit_syslog
);
341 max_poll_elements
= getdtablesize();
342 pollfds
= malloc(max_poll_elements
* sizeof (struct pollfd
));
343 fd_lookup
= malloc(max_poll_elements
* sizeof (int));
344 if (pollfds
== NULL
|| fd_lookup
== NULL
) {
345 lwsl_err("Out of memory pollfds=%d\n", max_poll_elements
);
350 info
.protocols
= protocols
;
351 #ifndef LWS_NO_EXTENSIONS
352 info
.extensions
= libwebsocket_get_internal_extensions();
355 info
.ssl_cert_filepath
= NULL
;
356 info
.ssl_private_key_filepath
= NULL
;
359 info.ssl_cert_filepath = LOCAL_RESOURCE_PATH"/libwebsockets-test-server.pem";
360 info.ssl_private_key_filepath = LOCAL_RESOURCE_PATH"/libwebsockets-test-server.key.pem";
367 // Register with Jack
368 if ((client
= jack_client_open(jack_name
, JackNullOption
, &status
)) == 0) {
369 lwsl_err("Failed to start jack client: %d\n", status
);
372 lwsl_debug("Registering as '%s'.\n", jack_get_client_name(client
));
374 // Register the cleanup function to be called when program exits
377 // Register the peak signal callback
378 jack_set_process_callback(client
, process_peak
, 0);
381 if (jack_activate(client
)) {
382 lwsl_err("Cannot activate client.\n");
391 // Create our input port
392 snprintf(in_name
, 255, "in_%d", num_meters
);
393 if (!(input_ports
[num_meters
] = jack_port_register(client
, in_name
,
394 JACK_DEFAULT_AUDIO_TYPE
, JackPortIsInput
, 0))) {
395 lwsl_err("Cannot register input port '%s'.\n", in_name
);
399 port
= jack_port_by_name(client
, argv
[opts
]);
401 lwsl_err("Can't find port '%s'\n", argv
[opts
]);
403 if (jack_connect(client
, jack_port_name(port
), jack_port_name(input_ports
[num_meters
]))) {
404 lwsl_err("failed to connect to port '%s'\n", argv
[opts
]);
409 if (num_meters
== MAX_METERS
) {
410 lwsl_err("maximum number of meters (%d) reached.\n", MAX_METERS
);
416 if (num_meters
== 0) {
417 lwsl_err("You must specify at least one port, aborting.");
421 context
= libwebsocket_create_context(&info
);
422 if (context
== NULL
) {
423 lwsl_err("libwebsocket init failed\n");
428 while (n
>= 0 && !force_exit
) {
431 gettimeofday(&tv
, NULL
);
436 * This provokes the LWS_CALLBACK_SERVER_WRITEABLE for every
437 * live websocket connection as soon as it can take more packets
438 * (usually immediately)
441 if (((unsigned int)tv
.tv_usec
- oldus
) > 100000) {
442 libwebsocket_callback_on_writable_all_protocol(&protocols
[1]);
446 n
= poll(pollfds
, count_pollfds
, 25);
452 for (n
= 0; n
< count_pollfds
; n
++)
453 if (pollfds
[n
].revents
)
454 if (libwebsocket_service_fd(context
,
459 n
= libwebsocket_service(context
, 25);
463 libwebsocket_context_destroy(context
);
465 lwsl_notice("jackwsserver exited cleanly\n");