~audio-recorder/audio-recorder/trunk

/*

 * Copyright (c) 2011- Osmo Antero.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 3 of the License (GPL3), or any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 * See the GNU Library General Public License 3 for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License 3 along with this program; if not, see /usr/share/common-licenses/GPL file

 * or <http://www.gnu.org/licenses/>.

*/

#include "timer.h"

#include "log.h"

#include "support.h"

#include "utility.h"

#include <stdlib.h>

/* Parsing of timer commands:

 Syntax:

 action := comment | ("start" | "stop" | "pause") command

 comment := '#'...\n

 command := action_prep data

 action_prep := "after" | "at" | "if" | "on"

 data := time_notation | filesize | word

 time_notation := (##:##:## | #hour #min #sec) time_suffix

 time_suffix := "am" | "pm" | ""

 filesize := # ("bytes" | "kb"|"kib" | "mb"|"mib" | "gb"|"gib" | "tb"|"tib")

 word := ("silence" | "voice" | "sound" | "audio") time_notation signal_threshold

 signal_threshold := #dB | #[1.1, 100]% | #[0, 1.0]

 Note: # means an integer or floating point number.

 Comments begin with '#' and ends at newline \n.

 In simplified form:

 start | stop | pause (at|after|if|on) ##:##:## (am|pm|) | ### (bytes|kb|mb|gb|tb) | (silence|voice|sound|audio) ## seconds (##dB | ##% | ##)

 The words "voice", "sound" and "audio" has exactly same meaning!

 The file size units:

 https://wiki.ubuntu.com/UnitsPolicy

 Some examples:

 start at 10:10 pm

 stop after 20.5 min

 start if voice

 start if sound 5s 10%

 # this is a comment

 stop at 08:00:30 am

 stop after 6 min 20 sec

 stop after 5 MB

 stop if silence 7 s -20 db   # duration is 7 seconds, threshold is -20dB

 stop if silence 7 s 30%  # duration is 7 seconds, threshold is 30 (=0.3)

 stop if silence 7 s 0.3  # duration is 7 seconds, threshold is 0.3 (=30%)

 stop after silence | 5GB | 35 min

 pause if silence 10s 7%

 start if audio -19dB

 stop if silence 10 sec -18 db | 20 GB | 10 pm

 stop if silence 10 16

 Usage:

 Call parser_parse_actions(txt), where txt is the command text.

 GList *parser_parse_actions(gchar *txt);

 It will return a pointer to g_timer_list. This is a GList of TimerRec records.

*/

#define MAX_TOKEN_LEN 128

typedef enum {TOK_NONE, TOK_NUMERIC, TOK_TIME, TOK_TEXT} TokenType;

typedef struct {

    TokenType type;

    gchar tok[MAX_TOKEN_LEN+1];

} TokenRec;

typedef struct {

    gchar *buf;

    gchar *pos;

    gint len;

    gchar back_ch;

    guint line_no;

} ParserRec;

typedef struct {

    gchar *label;

    gchar *translation;

} LangRec;

LangRec g_transtable[] =  {

    // Example: start at 10:30 pm

    {"start",   NULL},

    // Example: stop after 200 kb

    {"stop",    NULL},

    // Start/stop/pause at, after, if, on

    // Example: start at 10:30 pm

    {"at",      NULL},

    // Example: stop after 1 hour 20 min

    {"after",   NULL},

    // Example: stop if 2GB

    {"if",      NULL},

    // Example: start on voice | 14:00 pm

    {"on",      NULL},

    // Start/pause on "voice".

    // Example: start on voice | 14:00 pm

    {"voice",   NULL},

    // Start/pause on "audio"

    // Example: start on audio | 14:00 pm

    {"audio",   NULL},

    // Start/pause on "sound"

    // Example: start on sound | 14:00 pm

    {"sound",   NULL},

    // Time: hour

    // Example: stop after 1 hour | 1 h

    {"hour",    NULL},

    // Time: hour

    // Example: stop after 1 hour | 1 h

    {"h",       NULL},

    // Time: minutes

    // Example: stop after 20 minutes | 20 min | 20 m

    {"minutes", NULL},

    // Time: minutes

    // Example: stop after 20 minutes | 20 min | 20 m

    {"min",     NULL},

    // Time: minutes

    // Example: stop after 20 minutes | 20 min | 20 m

    {"m",       NULL},

    // Time: seconds

    // Example: pause after 60 seconds | 60 sec | 60 s

    {"seconds", NULL},

    // Time: seconds

    // Example: pause after 60 seconds | 60 sec | 60 s

    {"sec",     NULL},

    // Time: seconds

    // Example: pause after 60 seconds | 60 sec | 60 s

    {"s",       NULL},

    // Example: pause if 2000 bytes | 2000 byte

    {"bytes",   NULL},

    // Example: pause if 2000 bytes | 2000 byte

    {"bytes",   NULL},

    // "|" or "or"

    // Example: pause if silence -20 dB | 2 GB or 10:20 pm

    {"or",      NULL},

    // Clock time; ante meridiem, before midday

    // Example: start at 09:00 am

    {"am",      NULL},

    // Clock time; post meridiem, after midday

    // Example: stop at 09:00 pm

    {"pm",      NULL},

};

// Global variables to this module

static ParserRec g_parser;

static TokenRec g_curtoken;

static TokenRec g_backtoken;

static GList *g_timer_list = NULL;

static void parser_init(gchar *txt);

static void parser_clear();

static void parser_free_node(TimerRec *tr);

static void parser_parse_action();

static void parser_parse_data();

static gboolean match_lang(gchar *tok, gchar *text);

static gboolean match_word(gchar *l_word, gchar *word, ...);

static LangRec *get_translated_str(gchar *label);

static gchar parser_get_ch();

static gchar parser_get_ch_ex();

static void parser_put_back_ch(gchar ch);

static void parser_get_token();

static TimerRec *parser_get_last();

static TimerRec *parser_add_action(gchar action);

static void parser_fix_list();

static void parser_print_error(gchar *msg);

static gchar *parser_type_to_str(gint type) __attribute__((unused));

void parser_module_init() {

    LOG_DEBUG("Init timer-parser.c.\n");

    g_timer_list = NULL;

    parser_init(NULL);

}

void parser_module_exit() {

    LOG_DEBUG("Clean up timer-parser.c.\n");

    parser_clear();

    // Free list

    parser_free_list();

}

GList *parser_parse_actions(gchar *txt) {

    parser_clear();

    parser_init(txt);

    // 'S'tart... | S'T'op..., 'P'ause...

    parser_parse_action();

    parser_fix_list();

    // Return the list head

    return g_timer_list;

}

static void parser_init(gchar *txt) {

    // Init parser record

    if (txt) {

        g_parser.buf = g_utf8_strdown(txt, -1);

        g_parser.len = g_utf8_strlen(g_parser.buf, -1);

    } else {

        g_parser.buf = NULL;

        g_parser.len = 0;

    }

    g_parser.pos = g_parser.buf;

    g_parser.back_ch = '\0';

    g_parser.line_no = 1;

    *g_curtoken.tok = '\0';

    *g_backtoken.tok = '\0';

    // Free the existing TimerRec list

    parser_free_list();

}

static void parser_clear() {

    // Clear parser record

    if (g_parser.buf)

        g_free(g_parser.buf);

    parser_init(NULL);

}

static void parser_print_error(gchar *msg) {

    LOG_ERROR("Timer command, line %d: %s.\n", g_parser.line_no, msg);

}

static gboolean match_lang(gchar *tok, gchar *text) {

    // Check if the given token (tok) matches the text (in plain english or translated language)

    gboolean ret = !g_strcmp0(tok, text);

    if (ret) return TRUE;

    LangRec *lang_rec = get_translated_str(text);

    ret = FALSE;

    if (lang_rec) {

        ret = !g_strcmp0(tok, lang_rec->label);

        if (!ret)

            ret = !g_strcmp0(tok, lang_rec->translation);

    }

    return ret;

}

static gboolean match_word(gchar *l_word, gchar *word, ...) {

    // Check if l_word matches one of the given words (in plain english or translated language).

    va_list args;

    va_start(args, word);

    gboolean found = FALSE;

    gchar *text = word;

    while (text) {

        if (match_lang(l_word, text)) {

            found = TRUE;

            break;

        }

        text = va_arg(args, gchar *);

    }

    va_end(args);

    return found;

}

static void parser_put_back_ch(gchar ch) {

    // Put back a character

    ParserRec *p = &g_parser;

    p->back_ch = ch;

}

static gchar parser_get_ch() {

    // Get next character

    ParserRec *p = &g_parser;

    if (!p->buf) return '\0';

    // Check back buf

    gchar ch = '\0';

    if (p->back_ch != '\0') {

        ch = p->back_ch;

        p->back_ch = '\0';

        return ch;

    }

    gchar *end = g_utf8_offset_to_pointer(p->buf, p->len - 1);

    if (p->pos > end) return '\0';

    if (*p->pos == '\0') return '\0';

    if (*p->pos == '\n') {

        // Count lines

        p->line_no++;

    }

    // The char

    ch = *p->pos;

    // Advance head

    p->pos++;

    return ch;

}

static void parser_remove_space() {

    // Remove white spaces from the text

    gchar ch = parser_get_ch();

    while (g_unichar_isspace(ch) && ch != '\0') {

        ch = parser_get_ch();

    }

    parser_put_back_ch(ch);

}

static void parser_remove_comment() {

    // Remove characters until \n

    gchar ch = parser_get_ch();

    while (ch != '\0' && ch != '\n') {

        ch = parser_get_ch();

    }

}

static gchar parser_get_ch_ex() {

    // Get next char, remove spaces and comments

    // Remove spaces

    parser_remove_space();

    gchar ch = '\0';

LBL_1:

    ch = parser_get_ch();

    if (ch == '\0') return ch;

    if (g_unichar_isspace(ch)) {

        // Remove spaces

        parser_remove_space();

        goto LBL_1;

    } else if (ch == '#') {

        // Remove EOL comment

        parser_remove_comment();

        goto LBL_1;

    }

    return ch;

}

static TokenRec parser_get_token_ex() {

    // Get next token from the text.

    // Return token.

    TokenRec t;

    *t.tok = '\0';

    t.type = TOK_NONE;

    gchar ch = parser_get_ch_ex();

    if (ch == '\0') return t;

    // An integer or decimal number: +-0-9, 0-9.0-9

    // Ot time value of format ##:##:##

    gint i = 0;

    while ((g_unichar_isdigit(ch) || g_utf8_strchr(".:+-", 4, ch)) && ch != '\0') {

        if (i >= MAX_TOKEN_LEN) break;

        t.tok[i++] = ch;

        ch = parser_get_ch();

    }

    // Got a numeric token?

    if (i > 0) {

        // Put last ch back

        parser_put_back_ch(ch);

        // 0-terminate

        t.tok[i] = '\0';

        // Time notation hh:mm:ss?

        if (g_utf8_strchr(t.tok, g_utf8_strlen(t.tok, -1), ':'))

            t.type = TOK_TIME;

        else

            // Got numeric value

            t.type = TOK_NUMERIC;

        return t;

    }

    // Is it a "|"  (OR token)?

    if (ch == '|') {

        g_utf8_strncpy(t.tok, "|", 1);

        t.type = TOK_TEXT;

        return t;

    }

    // Is it a "%" token?

    else if (ch == '%') {

        g_utf8_strncpy(t.tok, "%", 1);

        t.type = TOK_TEXT;

        return t;

    }

    // Is it a letter, a character?

    // Read a string.

    i = 0;

    // Note: we do NOT use ">", "<", ">=", "<=", "=", "==" tokens here. We merely get rid of them.

    // Just in case user writes "stop if filezize >= 100 MB". This is illegal syntax but we make our best to interpret it like "stop if 100 MB".

    while ((g_unichar_isalpha(ch) || g_utf8_strchr("><=", -1, ch)) && ch != '\0') {

        if (i >= MAX_TOKEN_LEN) break;

        t.tok[i++] = ch;

        ch = parser_get_ch();

    }

    if (i > 0) {

        // Put last ch back

        parser_put_back_ch(ch);

        // 0-terminate

        t.tok[i] = '\0';

        t.type = TOK_TEXT;

        return t;

    }

    return t;

}

static void parser_put_token_back() {

    // Put token back

    g_backtoken = g_curtoken;

}

static void parser_get_token() {

    // Get next token. Check back buffer.

    if (*g_backtoken.tok) {

        g_curtoken = g_backtoken;

        *g_backtoken.tok = '\0';

        return;

    }

    // Set the current token

    g_curtoken = parser_get_token_ex();

    // puts(g_curtoken.tok);

}

static LangRec *get_translated_str(gchar *label) {

    // Get LangRec for the given text label

    guint siz = sizeof(g_transtable) / sizeof(g_transtable[0]);

    guint i = 0;

    for (i=0; i< siz; i++) {

        if (!g_strcmp0(label, g_transtable[i].label))

            return &g_transtable[i];

        if (!g_strcmp0(label, g_transtable[i].translation))

            return &g_transtable[i];

    }

    return NULL;

}

static gboolean starts_with(gchar *s, gchar *what) {

    // Test if string s starts with "what" (has that prefix)

    if (!(s && what)) return FALSE;

    const gchar *p = g_strstr_len(s, -1, what);

    // The "s" starts with "what", at 1.st byte.

    return (p == s);

}

static double tok_to_num(gchar *tok) {

    // Convert tok to double

    return atof(tok);

}

static void normalize_time(TimerRec *tr) {

    // Normalize decimal values to real hours/minutes/seconds

    // Eg. 2.5h means 2h 30minutes 0seconds

    // Convert to 24 hours clock

    if (!g_strcmp0(tr->label, "pm") && tr->val[0] <= 12) {

        tr->val[0] += 12.0;

    }

    if (tr->val[0] > 24.0) tr->val[0] = 24.0;

    gdouble secs = tr->val[0]*3600.0 + tr->val[1]*60.0 + tr->val[2];

    // Convert back to hour/min/sec

    tr->val[0] = (guint)(secs / 3600);

    secs = secs - (tr->val[0]*3600);

    tr->val[1] = (guint)(secs / 60);

    tr->val[2] = secs - (tr->val[1]*60);

}

static void parser_parse_data() {

    // Get the actual TimerRec record (last one)

    TimerRec *tr = parser_get_last();

    // Safety counter

    guint loop_count = 0;

    // State for some intricat values

    guint state = 0;

    gboolean seconds_set = FALSE;

    gboolean threshold_set = FALSE;

    while (1) {

        if (loop_count++ > 500) {

            // Insane loop

            break;

        }

        if (g_curtoken.type == TOK_NONE) {

            break;

        }

        gdouble val = 0.0;

        gint tok_type = -1;

        // Numeric values for clock time/duration, file size or threshold (in dB, % or plain value [0, 1.0])

        if (g_curtoken.type == TOK_NUMERIC) {

            // Default data type

            // tr->data_type = 't';

            tok_type = g_curtoken.type;

            val = tok_to_num(g_curtoken.tok);

            // Next token

            parser_get_token();

        }

        // Clock time of format hh:mm:ss

        else if (g_curtoken.type == TOK_TIME) {

            // hh

            // hh:mm

            // hh:mm:ss

            tr->data_type = 't';

            tok_type = g_curtoken.type;

            // Split the time string on ":"

            // eg. 10:20:30 (=10 hours, 20 minutes, 30 seconds)

            gchar **args = g_strsplit_set(g_curtoken.tok, ":", -1);

            guint i =0;

            for (i=0; args[i]; i++) {

                if (i < 3) {

                    tr->val[i] = tok_to_num(args[i]);

                }

            }

            // Free the string list

            g_strfreev(args);

            // Next token

            parser_get_token();

            state = 3;

        }

        // Token is string/text

        // am | pm

        // 11 am

        // 07 pm

        if (match_word(g_curtoken.tok, "am", NULL) ||

                match_word(g_curtoken.tok, "pm", NULL)) {

            g_utf8_strncpy(tr->label, g_curtoken.tok ,-1);

            if (tok_type == TOK_NUMERIC) {

                tr->val[0] = val;

            }

            tr->data_type = 't';

            state = 3;

        }

        // filesize: bytes | kb | mb | gb | tb

        // 123 mb

        // 14.5 gb

        else if (match_word(g_curtoken.tok, "bytes", "byte", NULL)) {

            tr->data_type = 'f';

            tr->val[0] = val;

            g_utf8_strncpy(tr->label, "bytes" , -1);

        } else if (starts_with(g_curtoken.tok, "kb") || starts_with(g_curtoken.tok, "kib")) {

            tr->data_type = 'f';

            tr->val[0] = val * 1E3;

            g_utf8_strncpy(tr->label, "kb" , -1);

        } else if (starts_with(g_curtoken.tok, "mb") || starts_with(g_curtoken.tok, "mib")) {

            tr->data_type = 'f';

            tr->val[0] = val * 1E6;

            g_utf8_strncpy(tr->label, "mb" , -1);

        } else if (starts_with(g_curtoken.tok, "gb") || starts_with(g_curtoken.tok, "gib")) {

            tr->data_type = 'f';

            tr->val[0] = val * 1E9;

            g_utf8_strncpy(tr->label, "gb" , -1);

        } else if (starts_with(g_curtoken.tok, "tb") || starts_with(g_curtoken.tok, "tib")) {

            tr->data_type = 'f';

            tr->val[0] = val * 1E12;

            g_utf8_strncpy(tr->label, "tb" , -1);

        }

        // hours, minutes, seconds

        else if (match_word(g_curtoken.tok, "h", NULL) || starts_with(g_curtoken.tok, "ho")) { // h, hour, hours, horas

            // 'd' = time duration

            tr->data_type = 'd';

            tr->val[0] = val;

            state = 3;

        } else if (match_word(g_curtoken.tok, "m", NULL) || starts_with(g_curtoken.tok, "mi")) { // m, min, minute, minutes

            // 'd' = time duration

            tr->data_type = 'd';

            tr->val[1] = val;

            state = 3;

        } else if (match_word(g_curtoken.tok, "s", NULL) || starts_with(g_curtoken.tok, "se")) { // s, sec, second, seconds

            if (str_length0(tr->threshold_unit) < 1) { /* == '\0'*/

                // Save threshold value (eg. 0.4)

                // "stop if silence 0.4 5s" => "stop if silence 5s 0.4"

                tr->threshold = tr->val[2];

            }

            // 'd' = time duration

            tr->data_type = 'd';

            tr->val[2] = val;

            state = 3;

        }

        // "silence"

        else if (match_word(g_curtoken.tok, "silence", NULL)) {

            tr->data_type = 'x';

            g_utf8_strncpy(tr->label, "silence" , -1);

            state = 2;

        }

        // "voice" | "audio" | "sound"

        else if (match_word(g_curtoken.tok, "voice", NULL)) {

            tr->data_type = 'x';

            g_utf8_strncpy(tr->label, "voice" , -1);

            state = 2;

        } else if (match_word(g_curtoken.tok, "audio", NULL)) {

            tr->data_type = 'x';

            g_utf8_strncpy(tr->label, "audio" , -1);

            state = 2;

        } else if (match_word(g_curtoken.tok, "sound", NULL)) {

            tr->data_type = 'x';

            g_utf8_strncpy(tr->label, "sound" , -1);

            state = 2;

        }

        // threshold dB (-100dB - -5dB)

        else if (match_word(g_curtoken.tok, "db", "decibel", NULL) || starts_with(g_curtoken.tok, "decib")) {

            // TODO: Check if "silence", "voice" | "audio" | "sound" token detected

            g_utf8_strncpy(tr->threshold_unit, "db", -1);

            tr->threshold = val;

        }

        // Threshold % (0 - 100%)

        else if (match_word(g_curtoken.tok, "%", NULL)) {

            g_utf8_strncpy(tr->threshold_unit, "%", -1);

            tr->threshold = val;

        }

        // "start", "stop", "pause"

        else if (match_word(g_curtoken.tok, "start", "stop", "pause", "|", NULL)) {

            // Put token back

            parser_put_token_back();