astat.cpp File Reference

#include "config_unix.h"
#include "config_win32.h"
#include "compat/platform_pipe.h"
#include <stdlib.h>
#include <stdio.h>
#include <thread>
#include <mutex>
#include <algorithm>
#include <string_view>
#include "astat.h"

Include dependency graph for astat.cpp:

Go to the source code of this file.

Classes
struct	ug_connection

Macros
#define	MSG_DONTWAIT   0
#define	MSG_NOSIGNAL   0

Functions
bool	astat_parse_line (const char *str, double volpeak[CH_COUNT], double volrms[CH_COUNT])
static void	parse_and_store (ug_connection &c, const char *str)
void	ug_control_cleanup ()
void	ug_control_connection_done (struct ug_connection *c)
struct ug_connection *	ug_control_connection_init (int local_port)
bool	ug_control_get_volumes (struct ug_connection *c, double peak[], double rms[], int *count)
void	ug_control_init ()
static void	worker (ug_connection &)
static ssize_t	write_all (fd_t fd, const void *buf, size_t count)

Macro Definition Documentation

MSG_DONTWAIT

#define MSG_DONTWAIT   0

Definition at line 22 of file astat.cpp.

Referenced by ug_control_connection_done().

MSG_NOSIGNAL

#define MSG_NOSIGNAL   0

Definition at line 18 of file astat.cpp.

Referenced by write_all().

Function Documentation

astat_parse_line()

bool astat_parse_line	(	const char *	str,
		double	volpeak[CH_COUNT],
		double	volrms[CH_COUNT] )

Definition at line 62 of file astat.cpp.

                                                                                         {
        std::string_view prefix = "stats ARECV ";
        if(strncmp(prefix.data(), str, prefix.size()) != 0)
                return false;
 
        const char *c = str + prefix.size();
 
        int i = 0;
        while(*c != '\0' && i < CH_COUNT){
                int read_chars;
                int ret = sscanf(c, "volrms%*d %lf volpeak%*d %lf %n",
                                &volrms[i], &volpeak[i], &read_chars);
                c += read_chars;
                i++;
 
                if(ret != 2)
                        return false;
        }
 
        return true;
}

References CH_COUNT.

Referenced by parse_and_store().

parse_and_store()

static void parse_and_store ( ug_connection & c, const char * str )

static

Definition at line 86 of file astat.cpp.

{
        double volpeak[CH_COUNT];
        double volrms[CH_COUNT];
        if (!astat_parse_line(str, volpeak, volrms)) {
#ifdef ASTAT_DEBUG
                fprintf(stderr, "Wrong line format!");
#endif
                return;
        }
 
        lock_guard<mutex> lk(c.lock);
        for (int i = 0; i < CH_COUNT; i++) {
                c.volpeak[i] = std::max(c.volpeak[i], volpeak[i]);
                c.volrms[i] = (volrms[i] * c.sample_count + volrms[i]) / (c.sample_count + 1);
        }
        c.sample_count += 1;
}

References astat_parse_line(), CH_COUNT, ug_connection::lock, ug_connection::sample_count, ug_connection::volpeak, and ug_connection::volrms.

Referenced by worker().

Here is the call graph for this function:

ug_control_cleanup()

void ug_control_cleanup

(

)

Definition at line 255 of file astat.cpp.

                         {
#ifdef _WIN32
        WSACleanup();
#endif
}

ug_control_connection_done()

void ug_control_connection_done

(

struct ug_connection *

c

)

Definition at line 205 of file astat.cpp.

                                                         {
        if(!c){
                return;
        }
        c->should_exit = true;
        char ch = 0;
        int ret = send(c->should_exit_fd[1], &ch, 1, MSG_DONTWAIT);
        if (ret == -1) {
                perror("ug_control_connection_done send");
        }
        c->t.join();
        platform_pipe_close(c->should_exit_fd[0]);
        platform_pipe_close(c->should_exit_fd[1]);
        CLOSESOCKET(c->fd);
        delete c;
}

References CLOSESOCKET, ug_connection::fd, MSG_DONTWAIT, platform_pipe_close(), ug_connection::should_exit, ug_connection::should_exit_fd, and ug_connection::t.

Here is the call graph for this function:

ug_control_connection_init()

struct ug_connection * ug_control_connection_init

(

int

local_port

)

Parameters

local_port

UltraGrid control port to connect to

Definition at line 177 of file astat.cpp.

                                                                 {
        int fd = socket(AF_INET6, SOCK_STREAM, 0);
        if (fd == -1) {
                return nullptr;
        }
        fd_t should_exit_fd[2];
        struct sockaddr_in6 sin;
        memset(&sin, 0, sizeof sin);
        sin.sin6_family = AF_INET6;
        sin.sin6_port = htons(local_port);
        sin.sin6_addr = in6addr_loopback;
 
        if (connect(fd, (const sockaddr*) &sin, sizeof sin) == -1) {
                CLOSESOCKET(fd);
                return NULL;
        }
 
        char stats_on[] = "stats on\r\n";
        if (write_all(fd, stats_on, sizeof stats_on) != sizeof stats_on) {
                CLOSESOCKET(fd);
                return NULL;
        }
 
        platform_pipe_init(should_exit_fd);
 
        return new ug_connection{fd, should_exit_fd};
}

References CLOSESOCKET, ug_connection::fd, platform_pipe_init(), ug_connection::should_exit_fd, and write_all().

Here is the call graph for this function:

ug_control_get_volumes()

bool ug_control_get_volumes	(	struct ug_connection *	c,
		double	peak[],
		double	rms[],
		int *	count )

Parameters

peak	Returns peak volume for 2 channels. Must be array of 2 doubles.
rms	Returns RMS volume for 2 channels. Must be array of 2 doubles.

Return values

false

if connection was closed

Definition at line 227 of file astat.cpp.

                                                                                              {
        if (!c)
                return false;
 
        lock_guard<mutex> lk(c->lock);
 
        if (c->connection_lost) {
                return false;
        }
 
        memcpy(peak, c->volpeak, sizeof c->volpeak);
        memcpy(rms, c->volrms, sizeof c->volrms);
        *count = c->sample_count;
 
        std::fill_n(c->volpeak, sizeof(c->volpeak)/sizeof(*c->volpeak), -INFINITY);
        memset(c->volrms, 0, sizeof c->volrms);
        c->sample_count = 0;
 
        return true;
}

References ug_connection::connection_lost, count, ug_connection::lock, ug_connection::sample_count, ug_connection::volpeak, and ug_connection::volrms.

ug_control_init()

void ug_control_init

(

)

Definition at line 248 of file astat.cpp.

                      {
#ifdef _WIN32   
        WSADATA wsa;
        WSAStartup(MAKEWORD(2,2), &wsa);
#endif
}

worker()

static void worker ( ug_connection & c )

static

Definition at line 105 of file astat.cpp.

{
        char line[10000] = "";
        while (!c.should_exit) {
                char buf[9000] = "";
 
                fd_set fds;
                FD_ZERO(&fds);
                FD_SET(c.fd, &fds);
                FD_SET(c.should_exit_fd[0], &fds);
                fd_t nfds = std::max<fd_t>(c.fd, c.should_exit_fd[0]) + 1;
 
                int rc = select(nfds, &fds, NULL, NULL, NULL);
                if (rc <= 0) {
                        continue;
                }
 
                if (FD_ISSET(c.should_exit_fd[0], &fds)) {
                        break;
                }
 
                ssize_t ret = recv(c.fd, buf, sizeof buf, 0);
                if (ret == 0) { // connection was closed
                        lock_guard<mutex> lk(c.lock);
                        c.connection_lost = true;
#ifdef ASTAT_DEBUG
                        fprintf(stderr, "Connection lost!\n");
#endif
                        break;
                }
 
                if (ret < 0) {
#ifdef _WIN32
                        int err = WSAGetLastError();
                        if(err == WSAECONNRESET){
                                lock_guard<mutex> lk(c.lock);
                                c.connection_lost = true;
#ifdef ASTAT_DEBUG
                                fprintf(stderr, "Connection lost!\n");
#endif
                                break;
                        }
                        printf("recv: %d \n", WSAGetLastError());
#else
                        perror("recv");
#endif
                        continue;
                }
 
                assert(ret + strlen(line) < sizeof line - 1); // TODO...
                memcpy(line + strlen(line), buf, ret);
                // process individual lines
                while (strchr(line, '\n')) {
                        char *next = strchr(line, '\n') + 1;
                        *strchr(line, '\n') = '\0';
 
                        // process one line
                        if (strstr(line, "stats ARECV") == line) { // only process those lines that belong to us
                                parse_and_store(c, line);
                        }
                        
                        // move the rest
                        size_t rest_len = strlen(next);
                        memmove(line, next, rest_len);
                        memset(line + rest_len, 0, sizeof line - rest_len);
                }
        }
}

References ug_connection::connection_lost, ug_connection::fd, ug_connection::lock, parse_and_store(), ug_connection::should_exit, and ug_connection::should_exit_fd.

Here is the call graph for this function:

write_all()

static ssize_t write_all ( fd_t fd, const void * buf, size_t count )

static

Definition at line 30 of file astat.cpp.

{
    char *p = (char *) buf;
    size_t rest = count;
    ssize_t w = 0;
 
    while (rest > 0 && (w = send(fd, p, rest, MSG_NOSIGNAL)) >= 0) {
        p += w;
        rest -= w;
    }
 
    if (rest > 0)
        return w;
    else
        return count;
}

References count, and MSG_NOSIGNAL.

Referenced by ug_control_connection_init().