~audio-recorder/audio-recorder/trunk

/*

 * Copyright (c) Linux community.

 *

 * 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 2 of the License, or (at your option) 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 for more details.

 *

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

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

*/

#include <string.h>

#include <glib.h>

#include <math.h>

#include "timer.h"

#include "utility.h"

#include "support.h"

#include "dconf.h"

#include "log.h"

#include "gst-vad.h"

#include "audio-sources.h"

#include "rec-manager.h"

/*

  Sample commands:

  Clock time:

  start at 09:30 pm

  start at 21:30

  start at 21:30:00

  -- During runtime:

       * Compare clock time to given timer value (clock time hh:mm:ss).

       * Start recorder (pipeline) if condition is TRUE.

       * User must stop recording manually (or by other command).

  -----------------------------------------------------

  Clock time or duration of recording:

  stop at 11:30 am

  stop after 1h 20m

  stop after 1 hour 20 min

  pause after 20 min

  -- During runtime:

       * Compare clock time to the given timer value.

       * Compare duration to the given timer limit.

       * Stop or pause recorder (pipeline) if condition is TRUE.

  -----------------------------------------------------

  Managing "silence".

  stop if silence

  stop if silence 5s

  stop if silence 5s 0.4

  stop if silence 5s 40%

  -- During runtime:

       * Make sure VAD is running.

       * Send threshold signals to this module (timer.c)

       * Recorder will stop if threshold < limit.

  ------------------------------------------------------

  pause if silence 5s 0.3

  pause if silence 5s 30%

  pause if silence 5s -24dB

  pause if silence

  -- During runtime:

       * Make sure VAD is running.

       * Send threshold signals to this module (timer.c)

       * Recorder will PAUSE if threshold < limit, and PLAY if threshold >= limit.

  ---------------------------------------------------------

  Using "sound", "voice" and "audio" commands.

  start if sound

  start if sound 0.3

  start if voice 30%

  start if voice 0.3

  start if audio -20dB

  NOTICE: Unfortunately these commands cannot handle time delay very well!

  These commands fire immediately after the volume exceeds/or is beneath the given limit (default limit is 0.3, or 30%).

  -- During runtime:

       * Make sure VAD is running.

       * Send threshold signals to gst-recorder.c.

       * Recorder will START if threshold >= limit, and PAUSE if threshold < limit.

  ---------------------------------------------------------    

  File size:

  stop after 10MB

  pause if 2MB

  -- During runtime:

       * Take recorded file size and compare it to value in the timer command (in timer.c).

       * Start recorder (pipeline) if condition is TRUE.

  ---------------------------------------------------------    

  stop after 2 GB | 12 pm | silence 4s

  start at 10:20 pm | voice 

  Multiple conditions on one line, separated by "|" or "or".

  ---------------------------------------------------------    

  Notice: The words "voice", "audio" and "sound" have all *same meaning*. Ok!

  The word "silence" is relative to the given volume level/threshold. 

  Silence has both duration (in seconds) and volume limit.

  Volume limit can be given as:

  -Decimal value between [0, 1.0].

  -% value between [0%, 100%]. So 1.0 = 100%.

  -Or decibel value.

*/

// Timer function call frequency in seconds

#define TIMER_CALL_FREQ 1

// Default silence duration (in seconds)

#define DEF_SILENCE_DURATION 3

// Timer function id

static guint g_timer_func_id = 0;

// A GList of TimerRec nodes from the timer-parser.c

G_LOCK_DEFINE_STATIC(g_t_list);

static GList *g_t_list = NULL;

// Timer's start time

static struct tm g_timer_start_time;

void timer_func_stop();

gboolean timer_func_cb(gpointer user_data);

void timer_func_exit_cb(gpointer user_data);

void timer_func_exec_command(TimerRec *tr);

static void timer_set_start_time();

static struct tm timer_get_start_time();

static void timer_update_records_1();

static gchar timer_test_filesize(TimerRec *tr);

static gchar timer_test_clock_time(TimerRec *tr);

static gchar timer_test_time_duration(TimerRec *tr);

static void test_silence(TimerRec *tr, GstClockTimeDiff time_diff, gdouble rms);

static void test_sound(TimerRec *tr, GstClockTimeDiff time_diff, gdouble rms);

static void execute_action(TimerRec *tr, gchar action);

void timer_module_init() {

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

    // Init gst-vad.c

    vad_module_init();

    g_timer_func_id = 0;

    // Init parser module

    parser_module_init();

    // Start the timer function

    timer_func_start();

}

void timer_module_exit() {

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

    // Stop timer function

    timer_func_stop();

    // Clean up parser module

    parser_module_exit();

    // Clean up gst-vad.c

    vad_module_exit();

    g_t_list = NULL;

}

void timer_set_debug_flag(gboolean on_off) {

    // Set debug flag. Please see application options:

    // $ audio-recorder --help

    vad_set_debug_flag(on_off);

}

void timer_module_reset(gint for_state) {

    // Reset timer before we move to the given state

    switch (for_state) {

    case GST_STATE_PLAYING:

        timer_update_records_1();

        break;

    case GST_STATE_PAUSED:

    case GST_STATE_NULL:

        //timer_update_records_2();

        break;

    default:

        ;

    }

}

void timer_module_rec_start() {

    // Called when recording stops.

    // Reset timer

    timer_update_records_1();

}

// --------------------------------------------------

// The actual timer function

// --------------------------------------------------

void timer_func_start() {

    // Already running?

    if (g_timer_func_id > 0) {

        return;

    }

    // Start the timer function

    g_timer_func_id = g_timeout_add_seconds_full(G_PRIORITY_DEFAULT, TIMER_CALL_FREQ, (GSourceFunc)timer_func_cb, 

                                                 (gpointer)1/*!= 0*/, (GDestroyNotify)timer_func_exit_cb);

}

void timer_func_stop() {

    // Stop the timer funcion

    if (g_timer_func_id > 0) {

        g_source_remove(g_timer_func_id);

    }

    g_timer_func_id = 0;

}

void timer_func_exit_cb(gpointer user_data) {

    // Nothing to cleanup

    ;

}

void timer_settings_changed() {

    // Increment the counter so various modules know that the timer-settings have been altered

    gint count = 0;

    conf_get_int_value("timer-setting-counter", &count);

    conf_save_int_value("timer-setting-counter", count+1);

}

static void timer_update_records_1() {

    // Reset timer nodes

    G_LOCK(g_t_list);

    GList *item = g_list_first(g_t_list);

    while (item) {

        TimerRec *tr = (TimerRec*)item->data;

        // Start to count from 0

        tr->time_below = 0.0;

        tr->time_above = 0.0;

        // Next item

        item = g_list_next(item);

    }

    G_UNLOCK(g_t_list);

}

#if 0 

static void timer_update_records_2() {

    // Reset timer nodes

    G_LOCK(g_t_list);

    GList *item = g_list_first(g_t_list);

    while (item) {

        //TimerRec *tr = (TimerRec*)item->data;

        // Start to count from 0

        //tr->seconds = 0;

        //tr->seconds_x = 0;

        // Next item

        item = g_list_next(item);

    }

    G_UNLOCK(g_t_list);

}

#endif

static void timer_clear_list() {

    // Reset the timer list

    // Lock g_timer_list

    G_LOCK(g_t_list);

    parser_free_list();

    g_t_list = NULL;

    // Unlock

    G_UNLOCK(g_t_list);

}

static void timer_set_start_time() {

    // Set timer's start time

    time_t t = time(NULL);

    localtime_r(&t, &g_timer_start_time);

}

static struct tm timer_get_start_time() {

    return g_timer_start_time;

}

gdouble normalize_threshold(gdouble threshold, gchar *threshold_unit) {

    gdouble val = threshold;

    if (!threshold_unit) return val;

    // dB?

    if (threshold_unit[0] == 'd')  {

        // rms_dB:

        // RMS, http://en.wikipedia.org/wiki/Root_mean_square

        // From dB to a normalized 0 - 1.0 value.

        val = pow(10, threshold / 20);

    }

    // [0 - 100]% ?

    else if (threshold_unit[0] == '%')  {

        val = val / 100.0;

    // Already in [0 - 1.0]

    } else {

        // val = threshold;

    }

    return val;

}

gboolean check_need_VAD() {

    GList *item = g_list_first(g_t_list);

    while (item) {

        TimerRec *tr = (TimerRec*)item->data;

        if (!g_strcmp0(tr->label, "silence") ||

            !g_strcmp0(tr->label, "voice") ||

            !g_strcmp0(tr->label, "sound") ||

            !g_strcmp0(tr->label, "audio")) {

            return TRUE;

        }

        // Next item

        item = g_list_next(item);

    }

    return FALSE;

}

void normalize_values() {

    GList *item = g_list_first(g_t_list);

    while (item) {

        TimerRec *tr = (TimerRec*)item->data;

        // Convert hh:mm:ss to seconds

        tr->norm_secs = (gdouble)(tr->val[0]*3600 + tr->val[1]*60 + tr->val[2]);

        // Convert tr->threshold to [0 - 1.0] from tr->threshold_unit

        tr->norm_threshold = normalize_threshold(tr->threshold, tr->threshold_unit);

        // Next item

        item = g_list_next(item);

    }

}

gboolean timer_func_cb(gpointer user_data) {

    // The actual timer function

    // Timer is ON/OFF?

    static gboolean timer_active = FALSE;

    // Counter to detect if GConf settings have been altered

    static gint setting_counter = -1;

    // Do we need VAD-pipeline?

    static gboolean need_VAD = FALSE;

    // Timer (GConf) settings changed?

    gint val = 0;

    conf_get_int_value("timer-setting-counter", &val);

    if (val == setting_counter) {

        // No changes in parameters.

        // Evaluate timer values.

        goto EVAL_0;

    }

    // Save settings counter

    setting_counter = val;

    // Get new values from GConf and parse values

    conf_get_boolean_value("timer-active", &timer_active);

    LOG_TIMER("Timer settings changed:<%s>\n", (timer_active ? "timer ON" : "timer OFF"));

    // Timer is ON/OFF?

    if (!timer_active) {

        // It's OFF

        timer_clear_list();

        // Stop the listener

        vad_stop_VAD();

        goto LBL_1;

    }

    // Set timer's start time

    timer_set_start_time();

    // Free the old g_t_list

    timer_clear_list();

    // Set lock

    G_LOCK(g_t_list);

    // Get timer text

    gchar *timer_text = NULL;

    conf_get_string_value("timer-text", &timer_text);

    LOG_TIMER("----------------\nTimer text is:\n<%s>\n--------------\n", timer_text);

    // Parse timer conditions.

    // This will return pointer to the g_timer_list (GList) in timer-parser.c.

    g_t_list = parser_parse_actions(timer_text);

    g_free(timer_text);

    if (g_list_length(g_t_list) < 1) {

        LOG_TIMER("The timer has no conditions.\n");

    } else {

        LOG_TIMER("The timer conditions are:\n");

#if defined(DEBUG_TIMER)

        // Debug print the command list

        parser_print_list(g_t_list);

#endif

    }

    // Important: Start VAD-pipeline only when we needed.

    // Only "silence", "voice", "audio" and "sound" commands/conditions need VAD (Voice Activity Detection).

    need_VAD = check_need_VAD();

    // Check if recorder was started with --debug-signal (or -d) argument

    need_VAD = need_VAD || vad_get_debug_flag();

    // Normalize values

    normalize_values();

    G_UNLOCK(g_t_list);

  EVAL_0:

    // Timer is ON?

    if (!timer_active) {

        // No.

        // Make sure the VAD has stopped (do not waste CPU cycles)

        vad_stop_VAD();

        goto LBL_1;

    }

    // Yes. Timer is ON.

    // Do we need data from gst-vad.c?

    if (!need_VAD) {

        // No.

        // Make sure the VAD has stopped (do not waste CPU cycles)

        vad_stop_VAD();

    } else {

        // Yes.

        // Start VAD.

        vad_start_VAD();

    }

    // ------------------------

    // Evaluate timer commands

    // ------------------------

    // For all TimerRec structures in GList...

    GList *item = g_list_first(g_t_list);

    while (item) {

        TimerRec *tr = (TimerRec*)item->data;

        // Set lock

        G_LOCK(g_t_list);

        // Check the timer condition

        timer_func_exec_command(tr);

        // Unlock

        G_UNLOCK(g_t_list);

        // Next item

        item = g_list_next(item);

    }

LBL_1:

    // Continue calling this function

    return TRUE;

}

void timer_func_exec_command(TimerRec *tr) {

    // Actions: 'S'=start, 'T'=stop, 'P'=pause, 'p'=pause, 'c'=continue, 0=No action.

    gchar action = 0;

    // Test filesize?

    if (tr->data_type == 'f') {

        // stop/pause if ### bytes/KB/MB/GB/TB

        // Example:

        // stop/pause if 250 MB

        action = timer_test_filesize(tr);

        if (action) {

            LOG_TIMER("Filesize test = TRUE.\n");

        }

        // Test clock time ##:##:##?

    } else if (tr->data_type == 't') {

        // start/stop/pause at ##:##:## am/pm (where ##:##:## is a clock time in hh:mm:ss format)

        // Example:

        // start/stop/pause at 10:15:00 pm

        action = timer_test_clock_time(tr);

        if (action) {

            LOG_TIMER("Clock time test = TRUE.\n");

        }

        // Test time duration?

    } else if (tr->data_type == 'd') {

        // start/stop/pause after # hour # min # seconds

        // Example:

        // start/stop/pause after 1 h 25 min

        action = timer_test_time_duration(tr);

        if (action) {

            LOG_TIMER("Test for time period/duration = TRUE.\n");

        }

    }

    execute_action(tr, action);

}

static gchar timer_test_filesize(TimerRec *tr) {

    // Test filesize.

    // stop/pause if/after/on ### bytes/KB/MB/GB/TB

    // Examples:

    //  stop after 250 MB

    //  pause if 1.2 GB

    gchar action = 0;

    // Get output filename

    gchar *filename = rec_manager_get_output_filename();

    if (!filename) {

        return action;

    }

    // Get file size

    gdouble filesize = 1.0 * get_file_size(filename);

    LOG_TIMER("Testing filesize: filesize=%3.1f bytes, unit=%s, current filesize=%3.1f bytes, filename=<%s>\n",

              tr->val[0], tr->label, filesize, filename);

    g_free(filename);

    // Filesize limit exceeded?

    if (filesize >= tr->val[0]) {

        // Execute

        action = tr->action;

    }

    return action;

}

static gchar timer_test_clock_time(TimerRec *tr) {

    // Test clock time.

    // start/stop/pause at ##:##:## am/pm (where ##:##:## is a clock time in hh:mm:ss format)

    // Examples:

    //  start at 10:15:00 pm

    //  pause at 9:30 am

    //  stop at 23:00

    gchar action = 0;

    // Get current, local date & time

    time_t t = time(NULL);

    struct tm *tmp;

    tmp = localtime(&t);

    gint64 clock_secs = tmp->tm_hour*3600 + tmp->tm_min*60 + tmp->tm_sec;

    gint64 timer_secs = tr->val[0]*3600 +  tr->val[1]*60 +  tr->val[2];

    LOG_TIMER("Test clock time: current time is %02d:%02d:%02d  timer setting is %02.0f:%02.0f:%02.0f (day_of_year:%d/%d) diff in seconds:%ld\n", 

     tmp->tm_hour, tmp->tm_min, tmp->tm_sec, tr->val[0], tr->val[1], tr->val[2], tmp->tm_yday, 

     tr->day_of_year, (long)(timer_secs - clock_secs));

    // Note:

    // Do NOT fire if current clock time is 60 minutes or more over the trigger value.

    // Eg. Do not fire if clock time is 14:00:00, and timer setting is 12:10:00 pm. 

    // We will assume here that the user means 12:10pm tomorrow, not today.

    gint64 diff_secs = (clock_secs - timer_secs);

    gboolean do_action = (diff_secs > 0 && diff_secs < (60 * 60)/*1 HOUR HARD-CODED*/);

    if (do_action && tr->day_of_year != tmp->tm_yday) {

        action = tr->action;

        // Save day_of_year so we know when the clock turns around (to the next day).

        // This timer command will become valid and fire again.

        tr->day_of_year = tmp->tm_yday;

    }

    return action;

}

static gchar timer_test_time_duration(TimerRec *tr) {

    // Test time duration/time period.

    // start/stop/pause after # hour/h # minuntes/m/min # seconds/s/sec

    // Examples:

    //  start after 1 h 25 min

    //  stop after 30 minutes

    //  pause after 1 h 15 m 20 s

    gchar action = 0;

    // Action is 'T' (sTop) or 'P' (Pause) recording?

    if (tr->action == 'T'  || tr->action == 'P') {

        // Eg. stop/pause after 8 min 20 sec

        // Compare recording's stream time to the given timer value.

        // Get actual recording time in seconds

        gint64 recording_time_secs = rec_manager_get_stream_time();

        // This TimeRec's value in seconds

        gint64 timer_secs = tr->val[0]*3600.0 + tr->val[1]*60.0 +  tr->val[2];

#if defined(DEBUG_TIMER) || defined(DEBUG_ALL)

        guint hh = -1;

        guint mm = -1;

        guint ss = -1;

        // Split value to hours, minutes and seconds

        seconds_to_h_m_s(recording_time_secs, &hh, &mm, &ss);

        gint64 diff = timer_secs - recording_time_secs;

        LOG_TIMER("Test time period (for sTop and Pause): current rec.time:%02d:%02d:%02d  timer setting:%02.0f:%02.0f:%02.0f  diff:%ld secs.\n", 

                  hh, mm, ss, tr->val[0], tr->val[1], tr->val[2], (long)diff);

#endif

        if (recording_time_secs >= timer_secs) {

            // Execute

            action = tr->action;

        }

        // Action is 'S' (Start) recording?

        // Eg. start after 1 min 20 sec (execute "start after..." command only once during timer's life time)

    } else {

        // Execute only once pr. timer's life time!

        if (tr->done) goto LBL_1;

        // Get start time for this timer (when lines were parsed)

        struct tm start_time = timer_get_start_time();

        gint64 start_time_secs = start_time.tm_hour*3600.0 + start_time.tm_min*60.0 + start_time.tm_sec;

        // Get current, local date & time

        time_t t = time(NULL);

        struct tm *tmp;

        tmp = localtime(&t);

        gint64 curr_time_secs = tmp->tm_hour*3600.0 + tmp->tm_min*60.0 + tmp->tm_sec;

        // This TimerRec's value in seconds

        gint64 timer_secs = tr->val[0]*3600.0 + tr->val[1]*60.0 +  tr->val[2];

        gint64 diff = timer_secs - (curr_time_secs - start_time_secs);

        (void) diff; // Avoid unused var message

        LOG_TIMER("Test time period (for Start): clock time:%02d:%02d:%02d timer thread started:%02d:%02d:%02d setting:%02.0f:%02.0f:%02.0f  diff:%ld secs.\n",

          tmp->tm_hour, tmp->tm_min, tmp->tm_sec, start_time.tm_hour, start_time.tm_min, start_time.tm_sec,

          tr->val[0], tr->val[1], tr->val[2], (long)diff);

        if ((curr_time_secs - start_time_secs) >= timer_secs ) {

            // Execute command

            action = tr->action;

        }

LBL_1:

        ;

    }

    return action;

}

void timer_evaluate_triggers(GstClockTimeDiff time_diff, gdouble rms) {

    // This is called from gst-vad.c.

    // Evaluate VAD related timer commands.

    G_LOCK(g_t_list);

    GList *item = g_list_first(g_t_list);

    while (item) {

        TimerRec *tr = (TimerRec*)item->data;

        if (!g_strcmp0(tr->label, "silence")) {

            test_silence(tr, time_diff, rms);

        } else if (!g_strcmp0(tr->label, "voice") ||

                   !g_strcmp0(tr->label, "sound") ||

                   !g_strcmp0(tr->label, "audio")) {

            test_sound(tr, time_diff, rms);

        }

        // Next item

        item = g_list_next(item);

    }

    G_UNLOCK(g_t_list);

}

static void test_silence(TimerRec *tr, GstClockTimeDiff time_diff, gdouble rms) {

    // stop if silence

    // stop if silence 5s

    // stop if silence 5s 0.4

    // stop if silence 5s 40%

    // pause if silence

    // pause if silence 5s 0.3

    // pause if silence 5s 30%

    // pause if silence 5s -24dB

    gchar action = '\0';

    gdouble seconds = tr->norm_secs;

#if defined(DEBUG_TIMER) || defined(DEBUG_ALL)

    // Get recording state (for debugging)

    gint state = -1;

    gint pending = -1;

    rec_manager_get_state(&state, &pending);

    // Name of state

    const gchar *state_name = rec_manager_get_state_name(state);

    LOG_TIMER("Silence test. timer value:%3.1f sec, count seconds:%3.1f sec, *RMS:%3.2f, threshold:%3.1f%s (%3.2f), state:%s\n",

        seconds, tr->time_below, rms, tr->threshold, (tr->threshold_unit ? tr->threshold_unit : ""), tr->norm_threshold, state_name);

#endif

    // RMS > tr->threshold?

    if (rms > tr->norm_threshold + 0.001) { // 0.001=noise

        // Reset time teller

        tr->time_below = 0.0;

        if (tr->action == 'P') { // Pause

            // Resume (continue) recording after pause

            action = 'c'; 

            goto LBL_1;

        }

        return;

    }

    // Add time_diff to tr->time_below, convert to seconds

    tr->time_below += ((gdouble)time_diff / GST_SECOND);

    // tr->time_below < seconds?

    if (tr->time_below < seconds) {

        // Wait more

        return;

    }

    // Avoid overflow (no reason to keep this growing)

    if (tr->time_below > seconds + 140000) {

        tr->time_below = seconds + 140000;

    }

    // If here: RMS has been <= tr->threshold in seconds time.