void *kr_audioport_process_thread (void *arg) {
kr_audioport_t *kr_audioport = (kr_audioport_t *)arg;
int ret;
char buf[1];
krad_system_set_thread_name ("krc_audioport");
while (kr_audioport->active == 1) {
// wait for socket to have a byte
ret = read (kr_audioport->sd, buf, 1);
if (ret != 1) {
printke ("krad mixer client: unexpected read return value %d in kr_audioport_process_thread", ret);
}
//kr_audioport->callback (kr_audioport->kr_shm->buffer, kr_audioport->pointer);
kr_audioport->callback (1600, kr_audioport->pointer);
// write a byte to socket
ret = write (kr_audioport->sd, buf, 1);
if (ret != 1) {
printke ("krad mixer client: unexpected write return value %d in kr_audioport_process_thread", ret);
}
}
return NULL;
}
static void *krad_mixer_ticker_thread (void *arg) {
krad_mixer_t *krad_mixer = (krad_mixer_t *)arg;
krad_system_set_thread_name ("kr_mixer");
pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, NULL);
krad_mixer->krad_ticker = krad_ticker_create (krad_mixer->sample_rate, krad_mixer->ticker_period);
pthread_cleanup_push (krad_mixer_ticker_thread_cleanup, krad_mixer);
pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL);
krad_ticker_start_at (krad_mixer->krad_ticker, krad_mixer->start_time);
while (krad_mixer->ticker_running == 1) {
pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, NULL);
krad_mixer_process (krad_mixer->ticker_period, krad_mixer);
pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL);
krad_ticker_wait (krad_mixer->krad_ticker);
}
pthread_cleanup_pop (1);
return NULL;
}
void *krad_transmitter_listening_thread (void *arg) {
krad_transmitter_t *krad_transmitter = (krad_transmitter_t *)arg;
krad_system_set_thread_name ("kr_tx_listen");
krad_transmission_receiver_t *krad_transmission_receiver;
int e;
int ret;
int eret;
int cret;
int addr_size;
int client_fd;
struct sockaddr_in remote_address;
char hbuf[NI_MAXHOST];
char sbuf[NI_MAXSERV];
printk ("Krad Transmitter: Listening thread starting");
addr_size = 0;
e = 0;
ret = 0;
eret = 0;
cret = 0;
krad_transmission_receiver = NULL;
memset (&remote_address, 0, sizeof(remote_address));
addr_size = sizeof (remote_address);
while (krad_transmitter->stop_listening == 0) {
ret = epoll_wait (krad_transmitter->incoming_connections_efd, krad_transmitter->incoming_connection_events, KRAD_TRANSMITTER_MAXEVENTS, 50);
if (ret < 0) {
if ((ret < 0) && (errno == EINTR)) {
continue;
}
printke ("Krad Transmitter: Failed on epoll wait %s", strerror(errno));
krad_transmitter->stop_listening = 1;
break;
}
if (ret > 0) {
for (e = 0; e < ret; e++) {
if ((krad_transmitter->incoming_connection_events[e].events & EPOLLERR) ||
(krad_transmitter->incoming_connection_events[e].events & EPOLLHUP))
{
if (krad_transmitter->incoming_connections_sd == krad_transmitter->incoming_connection_events[e].data.fd) {
failfast ("Krad Transmitter: error on listen socket");
} else {
if (krad_transmitter->incoming_connection_events[e].events & EPOLLHUP) {
printke ("Krad Transmitter: incoming transmitter connection hangup");
}
if (krad_transmitter->incoming_connection_events[e].events & EPOLLERR) {
printke ("Krad Transmitter: incoming transmitter connection error");
}
krad_transmitter_receiver_destroy (krad_transmitter->incoming_connection_events[e].data.ptr);
continue;
}
}
if (krad_transmitter->incoming_connections_sd == krad_transmitter->incoming_connection_events[e].data.fd) {
while (1) {
client_fd = accept (krad_transmitter->incoming_connections_sd, (struct sockaddr *)&remote_address, (socklen_t *)&addr_size);
if (client_fd == -1) {
if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
// We have processed all incoming connections.
break;
} else {
failfast ("Krad Transmitter: error on listen socket accept");
}
}
if (getnameinfo ((struct sockaddr *)&remote_address, addr_size, hbuf, sizeof hbuf, sbuf, sizeof sbuf, NI_NUMERICHOST | NI_NUMERICSERV) == 0) {
printk ("Krad Transmitter: Accepted transmitter connection on descriptor %d (host=%s, port=%s)", client_fd, hbuf, sbuf);
} else {
printke ("Krad Transmitter: Accepted transmitter connection on descriptor %d ... but could not getnameinfo()?", client_fd, hbuf, sbuf);
}
krad_system_set_socket_nonblocking (client_fd);
krad_transmission_receiver = krad_transmitter_receiver_create (krad_transmitter, client_fd);
if (krad_transmission_receiver == NULL) {
failfast ("Krad Transmitter: ran out of connections!");
}
eret = epoll_ctl (krad_transmitter->incoming_connections_efd, EPOLL_CTL_ADD, client_fd, &krad_transmission_receiver->event);
if (eret != 0) {
failfast ("Krad Transmitter: incoming transmitter connection epoll error eret is %d errno is %i", eret, errno);
}
}
continue;
}
if (krad_transmitter->incoming_connection_events[e].events & EPOLLIN) {
while (1) {
krad_transmission_receiver = (krad_transmission_receiver_t *)krad_transmitter->incoming_connection_events[e].data.ptr;
cret = read (krad_transmission_receiver->fd,
krad_transmission_receiver->buffer + krad_transmission_receiver->position,
sizeof (krad_transmission_receiver->buffer) - krad_transmission_receiver->position);
if (cret == -1) {
if (errno != EAGAIN) {
printke ("Krad Transmitter: error reading from a new incoming connection socket");
krad_transmitter_receiver_destroy (krad_transmitter->incoming_connection_events[e].data.ptr);
}
break;
}
if (cret == 0) {
printk ("Krad Transmitter: Client EOF Closed connection");
krad_transmitter_receiver_destroy (krad_transmitter->incoming_connection_events[e].data.ptr);
break;
}
if (cret > 0) {
krad_transmission_receiver->position += cret;
krad_transmitter_handle_incoming_connection (krad_transmitter, krad_transmission_receiver);
break;
}
}
}
}
}
if (ret == 0) {
//printk ("Krad Transmitter: Listening thread... nothing happened");
}
}
close (krad_transmitter->incoming_connections_efd);
close (krad_transmitter->incoming_connections_sd);
free (krad_transmitter->incoming_connection_events);
krad_transmitter->port = 0;
krad_transmitter->listening = 0;
printk ("Krad Transmitter: Listening thread exiting");
return NULL;
}
static void *krad_transmitter_transmission_thread (void *arg) {
krad_transmission_t *krad_transmission = (krad_transmission_t *)arg;
krad_system_set_thread_name ("kr_tx_txmtr");
int r;
int e;
int ret;
int wait_time;
uint64_t last_position;
uint32_t new_bytes_avail;
uint32_t space_avail;
uint32_t drop_count;
krad_transmission_receiver_t *krad_transmission_receiver;
r = 0;
e = 0;
ret = 0;
wait_time = 2;
last_position = 0;
new_bytes_avail = 0;
space_avail = 0;
drop_count = 0;
krad_transmission_receiver = NULL;
printk ("Krad Transmitter: transmission thread starting for %s", krad_transmission->sysname);
while (krad_transmission->active == 1) {
if (krad_transmission->new_data == 1) {
if (krad_transmission->new_sync_point == 1) {
krad_transmission->sync_point = krad_transmission->position;
krad_transmission->new_sync_point = 0;
}
space_avail = krad_ringbuffer_write_space (krad_transmission->transmission_ringbuffer);
new_bytes_avail = krad_ringbuffer_read_space (krad_transmission->ringbuffer);
if (space_avail < new_bytes_avail) {
drop_count = new_bytes_avail - space_avail;
krad_ringbuffer_read_advance (krad_transmission->transmission_ringbuffer, drop_count);
}
krad_ringbuffer_read (krad_transmission->ringbuffer,
(char *)krad_transmission->transmission_buffer,
new_bytes_avail);
krad_ringbuffer_write (krad_transmission->transmission_ringbuffer,
(char *)krad_transmission->transmission_buffer,
new_bytes_avail);
krad_transmission->position += new_bytes_avail;
if (krad_transmission->position > DEFAULT_RING_SIZE) {
krad_transmission->horizon = krad_transmission->position - DEFAULT_RING_SIZE;
}
krad_ringbuffer_get_read_vector (krad_transmission->transmission_ringbuffer,
&krad_transmission->tx_vec[0]);
krad_transmission->new_data = 0;
}
ret = epoll_wait (krad_transmission->connections_efd, krad_transmission->transmission_events,
KRAD_TRANSMITTER_MAXEVENTS, wait_time);
if (ret < 0) {
if ((ret < 0) && (errno == EINTR)) {
continue;
}
printke ("Krad Transmitter: Failed on epoll wait %s", strerror(errno));
krad_transmission->active = 2;
break;
}
if (ret > 0) {
for (e = 0; e < ret; e++) {
krad_transmission_receiver =
(krad_transmission_receiver_t *)krad_transmission->transmission_events[e].data.ptr;
if (krad_transmission_receiver->noob == 1) {
krad_transmission_receiver->noob = 0;
krad_transmission->receivers++;
}
if ((krad_transmission->transmission_events[e].events & EPOLLERR) ||
(krad_transmission->transmission_events[e].events & EPOLLHUP) ||
(krad_transmission->transmission_events[e].events & EPOLLHUP)) {
if (krad_transmission->transmission_events[e].events & EPOLLHUP) {
printke ("Krad Transmitter: transmitter transmission receiver connection hangup");
}
if (krad_transmission->transmission_events[e].events & EPOLLERR) {
printke ("Krad Transmitter: transmitter transmission receiver connection error");
}
if (krad_transmission->transmission_events[e].events & EPOLLHUP) {
printk ("Krad Transmitter: client disconnected %d", krad_transmission_receiver->fd);
}
krad_transmitter_receiver_destroy (krad_transmission_receiver);
continue;
}
if (krad_transmission->transmission_events[e].events & EPOLLOUT) {
krad_transmitter_transmission_transmit (krad_transmission, krad_transmission_receiver);
}
}
}
if ((last_position != krad_transmission->position) && (krad_transmission->ready_receiver_count > 0)) {
last_position = krad_transmission->position;
for (r = 0; r < TOTAL_RECEIVERS; r++) {
if ((krad_transmission->krad_transmitter->krad_transmission_receivers[r].krad_transmission == krad_transmission) && (krad_transmission->krad_transmitter->krad_transmission_receivers[r].active == 1) && (krad_transmission->krad_transmitter->krad_transmission_receivers[r].ready == 1)) {
krad_transmission_receiver = &krad_transmission->krad_transmitter->krad_transmission_receivers[r];
krad_transmitter_transmission_transmit (krad_transmission, krad_transmission_receiver);
}
}
}
}
krad_transmission->active = 3;
printk ("Krad Transmitter: transmission thread exiting for %s", krad_transmission->sysname);
return NULL;
}
void *krad_ipc_server_run_thread (void *arg) {
krad_ipc_server_t *krad_ipc_server = (krad_ipc_server_t *)arg;
krad_ipc_server_client_t *client;
int ret, s;
krad_system_set_thread_name ("kr_ipc_server");
krad_ipc_server->shutdown = KRAD_IPC_RUNNING;
krad_ipc_server_update_pollfds (krad_ipc_server);
while (!krad_ipc_server->shutdown) {
ret = poll (krad_ipc_server->sockets, krad_ipc_server->socket_count, KRAD_IPC_SERVER_TIMEOUT_MS);
if (ret > 0) {
if (krad_ipc_server->shutdown) {
break;
}
s = 0;
if (krad_ipc_server->sockets[s].revents & POLLIN) {
krad_ipc_server_accept_client (krad_ipc_server, krad_ipc_server->sd);
ret--;
}
s++;
if ((krad_ipc_server->tcp_sd != 0) && (krad_ipc_server->sockets[s].revents & POLLIN)) {
krad_ipc_server_accept_client (krad_ipc_server, krad_ipc_server->tcp_sd);
ret--;
}
if (krad_ipc_server->tcp_sd != 0) {
s++;
}
for (; ret > 0; s++) {
if (krad_ipc_server->sockets[s].revents) {
ret--;
client = krad_ipc_server->sockets_clients[s];
if (krad_ipc_server->sockets[s].revents & POLLIN) {
client->input_buffer_pos += recv(krad_ipc_server->sockets[s].fd, client->input_buffer + client->input_buffer_pos, (sizeof (client->input_buffer) - client->input_buffer_pos), 0);
//printk ("Krad IPC Server: Got %d bytes\n", client->input_buffer_pos);
if (client->input_buffer_pos == 0) {
//printk ("Krad IPC Server: Client EOF\n");
krad_ipc_disconnect_client (client);
continue;
}
if (client->input_buffer_pos == -1) {
printke ("Krad IPC Server: Client Socket Error");
krad_ipc_disconnect_client (client);
continue;
}
// big enough to read element id and data size
if ((client->input_buffer_pos > 7) && (client->confirmed == 0)) {
krad_ebml_io_buffer_push(&client->krad_ebml->io_adapter, client->input_buffer, client->input_buffer_pos);
client->input_buffer_pos = 0;
krad_ebml_read_ebml_header (client->krad_ebml, client->krad_ebml->header);
krad_ebml_check_ebml_header (client->krad_ebml->header);
//krad_ebml_print_ebml_header (client->krad_ebml->header);
if (krad_ebml_check_doctype_header (client->krad_ebml->header, KRAD_IPC_CLIENT_DOCTYPE, KRAD_IPC_DOCTYPE_VERSION, KRAD_IPC_DOCTYPE_READ_VERSION)) {
//printk ("Matched %s Version: %d Read Version: %d\n", KRAD_IPC_CLIENT_DOCTYPE, KRAD_IPC_DOCTYPE_VERSION, KRAD_IPC_DOCTYPE_READ_VERSION);
client->confirmed = 1;
} else {
printke ("Did Not Match %s Version: %d Read Version: %d\n", KRAD_IPC_CLIENT_DOCTYPE, KRAD_IPC_DOCTYPE_VERSION, KRAD_IPC_DOCTYPE_READ_VERSION);
krad_ipc_disconnect_client (client);
continue;
}
client->krad_ebml2 = krad_ebml_open_active_socket (client->sd, KRAD_EBML_IO_READWRITE);
krad_ebml_header_advanced (client->krad_ebml2, KRAD_IPC_SERVER_DOCTYPE, KRAD_IPC_DOCTYPE_VERSION, KRAD_IPC_DOCTYPE_READ_VERSION);
krad_ebml_write_sync (client->krad_ebml2);
} else {
if ((client->input_buffer_pos > 3) && (client->confirmed == 1)) {
krad_ebml_io_buffer_push(&client->krad_ebml->io_adapter, client->input_buffer, client->input_buffer_pos);
client->input_buffer_pos = 0;
}
while (krad_ebml_io_buffer_read_space (&client->krad_ebml->io_adapter)) {
client->krad_ipc_server->current_client = client; /* single thread has a few perks */
if (krad_ipc_aquire_client (client)) {
//resp = client->krad_ipc_server->handler (client->output_buffer, &client->command_response_len, client->krad_ipc_server->pointer);
client->krad_ipc_server->handler (client->output_buffer, &client->command_response_len, client->krad_ipc_server->pointer);
//printk ("Krad IPC Server: CMD Response %d %d bytes\n", resp, client->command_response_len);
krad_ebml_write_sync (krad_ipc_server->current_client->krad_ebml2);
krad_ipc_release_client (client);
}
}
}
}
if (krad_ipc_server->sockets[s].revents & POLLOUT) {
//printk ("I could write\n");
}
if (krad_ipc_server->sockets[s].revents & POLLHUP) {
//printk ("Krad IPC Server: POLLHUP\n");
krad_ipc_disconnect_client (client);
continue;
}
if (krad_ipc_server->sockets[s].revents & POLLERR) {
printke ("Krad IPC Server: POLLERR\n");
krad_ipc_disconnect_client (client);
continue;
}
if (krad_ipc_server->sockets[s].revents & POLLNVAL) {
printke ("Krad IPC Server: POLLNVAL\n");
krad_ipc_disconnect_client (client);
continue;
}
}
}
}
}
krad_ipc_server->shutdown = KRAD_IPC_SHUTINGDOWN;
return NULL;
}
void *krad_system_monitor_cpu_thread (void *arg) {
krad_system_cpu_monitor_t *kcm;
krad_system_set_thread_name ("kr_system_mon");
printk ("Krad System CPU Monitor On");
kcm = &krad_system.kcm;
kcm->fd = open ( "/proc/stat", O_RDONLY );
if (kcm->fd < 1) {
kcm->on = 0;
return NULL;
}
while (1) {
kcm->ret = lseek (kcm->fd, 0, SEEK_SET);
if (kcm->ret != 0) {
break;
}
kcm->ret = read (kcm->fd, kcm->buffer, KRAD_BUFLEN_CPUSTAT);
if (kcm->ret != KRAD_BUFLEN_CPUSTAT) {
break;
}
sscanf (kcm->buffer + 3, "%d %d %d %d", &kcm->user, &kcm->nice, &kcm->system, &kcm->idle );
kcm->total = kcm->user + kcm->nice + kcm->system + kcm->idle;
if (kcm->total != kcm->last_total) {
kcm->diff_idle = kcm->idle - kcm->last_idle;
kcm->diff_total = kcm->total - kcm->last_total;
kcm->usage = (1000 * (kcm->diff_total - kcm->diff_idle) / kcm->diff_total + 5) / 10;
if (kcm->usage < 0) {
kcm->usage = 0;
} else {
if (kcm->usage > 100) {
kcm->usage = 100;
}
}
krad_system.system_cpu_usage = kcm->usage;
//printk ("user %d nice %d system %d idle %d usage %d\n",
// kcm->user, kcm->nice, kcm->system, kcm->idle, kcm->usage);
kcm->last_idle = kcm->idle;
kcm->last_total = kcm->total;
if (kcm->unset_cpu_monitor_callback == 1) {
kcm->callback_pointer = NULL;
kcm->cpu_monitor_callback = NULL;
kcm->unset_cpu_monitor_callback = 0;
}
if (kcm->cpu_monitor_callback) {
kcm->cpu_monitor_callback (kcm->callback_pointer, krad_system.system_cpu_usage);
}
}
if (krad_controller_client_wait (&kcm->control, kcm->interval)) {
break;
}
}
close (kcm->fd);
kcm->fd = 0;
krad_controller_client_close (&kcm->control);
krad_system.kcm.on = 0;
printk ("Krad System CPU Monitor Off");
return NULL;
}
