~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 "rec-window.h"

#include "rec-manager.h"

#include "rec-manager-struct.h"

#include "log.h"

#include "dconf.h"

#include "utility.h"

#include "support.h"

#include "gst-recorder.h"

#include "dbus-player.h"

// Command queue

static GAsyncQueue *g_cmd_queue = NULL;

// Last used/saved command

static RecorderCommand *g_last_rec_cmd = NULL;

// Message thread

static guint g_thread_id = 0;

static void rec_manager_free_command(RecorderCommand *cmd);

static gboolean rec_manager_command_thread(gpointer user_data);

void rec_manager_init() {

    LOG_DEBUG("Init rec-manager.c.\n");

    // Create a message queue

    // Ref: https://www.gtk.org/api/2.6/glib/glib-Asynchronous-Queues.html

    g_cmd_queue = g_async_queue_new();

    // Message thread within GTK's main loop

    // Ref: https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html

    g_thread_id =  g_timeout_add_full(G_PRIORITY_DEFAULT, 200, rec_manager_command_thread, NULL, NULL);

    // Init recorder.c

    rec_module_init();

}

void rec_manager_exit() {

    LOG_DEBUG("Clean up rec-manager.c.\n");

    // Clean up recorder.c

    rec_module_exit();

    // Remove command thread

    g_source_remove(g_thread_id);

    g_thread_id = 0;

    // Unref message queue

    if (g_cmd_queue) {

        g_async_queue_unref(g_cmd_queue);

    }

    g_cmd_queue = NULL;

    // Free g_last_rec_cmd

    rec_manager_free_command(g_last_rec_cmd);

    g_last_rec_cmd = NULL;

}

void rec_manager_print_command(RecorderCommand *cmd) {

    if (!cmd) return;

    const gchar *type_str = NULL;

    switch (cmd->type) {

    case RECORDING_STOP:

        type_str = "RECORDING_STOP";

        break;

    case RECORDING_CONTINUE:

        type_str = "RECORDING_CONTINUE";

        break;

    case RECORDING_START:

        type_str = "RECORDING_START";

        break;

    case RECORDING_PAUSE:

        type_str = "RECORDING_PAUSE";

        break;

    case RECORDING_NOTIFY_MSG:

        type_str = "RECORDING_NOTIFY_MSG";

        break;

    case RECORDING_DEVICE_CHANGED:

        type_str = "RECORDING_DEVICE_CHANGED";

        break;

    case RECORDING_PROFILE_CHANGED:

        type_str = "RECORDING_PROFILE_CHANGED";

        break;

    case RECORDING_SHOW_WINDOW:

        type_str = "RECORDING_SHOW_WINDOW";

        break;

    case RECORDING_HIDE_WINDOW:

        type_str = "RECORDING_HIDE_WINDOW";

        break;

    case RECORDING_QUIT_LOOP:

        type_str = "RECORDING_QUIT_LOOP";

        break;

    case RECORDING_QUIT_APP:

        type_str = "RECORDING_QUIT_APP";

        break;

    default:

        type_str = "Unknown recording command";

    }

    // Suppress "not used" message

    if (type_str) {

        ;

    }

    if (cmd->type != RECORDING_NOTIFY_MSG) {

        LOG_DEBUG("%s: %s, %s, %s, time=%d/%d flags=%d\n", type_str, cmd->trackId, cmd->artist, cmd->album, cmd->trackPos, cmd->trackLength, cmd->flags);

    } else {

        LOG_DEBUG("%s: %s\n", type_str, cmd->trackId);

    }

}

gint64 rec_manager_get_stream_time() {

    // Get and return current recording time (stream time) in seconds.

    return rec_get_stream_time();

}

void rec_manager_update_gui() {

    // Update GUI to reflect the status of recording

    win_update_gui();

}

void rec_manager_update_level_bar(gdouble norm_rms, gdouble norm_peak) {

    // Update gtklevelbar

    win_update_level_bar(norm_rms, norm_peak);

}

const gchar *rec_manager_get_state_name(gint state) {

    // Return name of the recording state, state of pipeline.

    return rec_get_state_name(state);

}

void rec_manager_flip_recording() {

    // Start, continue or stop recording

    // Get recording status

    gint old_status = -1;

    gint pending = -1;

    rec_manager_get_state(&old_status, &pending);

    switch (old_status) {

    case GST_STATE_PAUSED:

        // Continue recording

        rec_manager_continue_recording();

        break;

    case GST_STATE_PLAYING:

        // Stop recording

        rec_manager_stop_recording();

        break;

    default:

        // Start recording

        rec_manager_start_recording();

    }

}

void rec_manager_set_filename_label(gchar *filename) {

    // Set filename label

    win_set_filename(filename);

}

void rec_manager_set_time_label(gchar *label_txt) {

    // Set time label

    win_set_time_label(label_txt);

}

void rec_manager_set_size_label(gchar *label_txt) {

    // Set file size label

    win_set_size_label(label_txt);

}

void rec_manager_set_error_text(gchar *error_txt) {

    // Set error label

    win_set_error_text(error_txt);

}

void rec_manager_get_state(gint *status, gint *pending) {

    // Return recording status

    rec_get_state(status, pending);

}

gchar *rec_manager_get_output_filename() {

    // Return output filename

    return rec_get_output_filename();

}

void rec_manager_show_window(gboolean show) {

    // Show or hide application window

    if (show)

        // Send RECORDING_SHOW_WINDOW message to the queue

        rec_manager_send_command_ex(RECORDING_SHOW_WINDOW, NULL, 0);

    else

        // Send RECORDING_HIDE_WINDOW message to the queue

        rec_manager_send_command_ex(RECORDING_HIDE_WINDOW, NULL, 0);

}

void rec_manager_quit_application() {

    //  Quit application

    // Send RECORDING_QUIT_APP message to the queue

    rec_manager_send_command_ex(RECORDING_QUIT_APP, NULL, 0);

}

void rec_manager_start_recording() {

    // Start recording

    // Send RECORDING_START message to the queue

    // The filename will be auto-generated because the track name is NULL.

    rec_manager_send_command_ex(RECORDING_START, NULL, 0);

}

void rec_manager_stop_recording() {

    // Stop recording

    // First we must reset the lastly recorded track data.

    // Otherwise next PLAY/CONTINUE message from media-player will be understood as duplicate and dropped. 

    // We could let the recorder do this work in its own stop routines, BUT IT WILL NOT work right. WHY? 

    // Because the message queue (g_cmd_queue) is asynchronous, AND IT TAKES TIME for the messages pass through.

    // During that time, media-player can have sent several new messages. We must be quicker !  

    // 

    // Also rec_manager_stop_recording() is acalled from many places, like the Gtk menu, start/stop Button, from media players.

    //

    gchar *audio_source = NULL;

    conf_get_string_value("audio-device-id", &audio_source);

    // Reset last track data (that we received from media player) 

    dbus_player_reset_values(audio_source);

    g_free(audio_source);

    // Send RECORDING_STOP message to the queue

    rec_manager_send_command_ex(RECORDING_STOP, NULL, 0);

}

void rec_manager_continue_recording() {

    // Send RECORDING_CONTINUE message to the queue (Continues paused recording. This does not start if recording is off)

    rec_manager_send_command_ex(RECORDING_CONTINUE, NULL, 0);

}

void rec_manager_pause_recording() {

    // Pause recording

    // Send RECORDING_PAUSE message to the queue

    rec_manager_send_command_ex(RECORDING_PAUSE, NULL, 0);

}

gboolean rec_manager_is_recording() {

    // Is recording?

    return rec_is_recording();

}

gboolean rec_manager_is_paused() {

    // Is paused?

    return rec_is_paused();

}

void rec_manager_send_gui_msg(gchar *msg) {

    // Display a message in the GUI (normally a red label in the GUI)

    // Send RECORDING_NOTIFY_MSG to the queue

    rec_manager_send_command_ex(RECORDING_NOTIFY_MSG, msg/*the msg*/, 0);

}

static void rec_manager_free_command(RecorderCommand *cmd) {

    // Free command

    if (!cmd) return;

    g_free(cmd->title);

    g_free(cmd->artist);

    g_free(cmd->album);

    g_free(cmd->genre);

    g_free(cmd->albumArtist);

    g_free(cmd->url);

    g_free(cmd->artUrl);

    g_free(cmd->trackId);

    g_free(cmd);

}

void rec_manager_send_command_ex(enum CommandType type, gchar *txt, guint flags) {

    // Build the command

    RecorderCommand *cmd = g_malloc0(sizeof(RecorderCommand));

    cmd->type = type;

    cmd->title = g_strdup(txt);  // Convey msg or txt in the "title" field.

    cmd->flags = flags;

    // Send the command. The queue will free the cmd after usage.

    rec_manager_send_command(cmd);

}

void rec_manager_send_command(RecorderCommand *cmd) {

    // Push command to the queue

    g_async_queue_push(g_cmd_queue, (gpointer)cmd);

}

gboolean rec_manager_command_thread(gpointer user_data) {

    // Read next command from the queue

    RecorderCommand *cmd = (RecorderCommand*)g_async_queue_try_pop(g_cmd_queue);

    if (!cmd) {

        // TRUE: Continue calling this function

        return TRUE;

    }

    // Debug print

#if defined(ACTIVE_DEBUGGING) || defined(DEBUG_ALL)

    rec_manager_print_command(cmd);

#endif

    if (cmd->type == RECORDING_START) {

        // Save the values in Gsettings so gst-recorder.c can grab 

        // Please see: data/org.gnome.audio-recorder.gschema.xml

        conf_save_string_value("track/track-title", check_null(cmd->title));

        conf_save_int_value("track/track-pos", cmd->trackPos);

        conf_save_int_value("track/track-len", cmd->trackLength);

        conf_save_string_value("track/artist-name", check_null(cmd->artist));

        conf_save_string_value("track/album-name", check_null(cmd->album));

        conf_save_string_value("track/url", check_null(cmd->url));

    }

    // Verify the delete flag and filename

    gboolean del_flag = FALSE;

    if (cmd->flags == RECORDING_DELETE_FILE) {

        gchar *filename = NULL;

        conf_get_string_value("track/last-file-name", &filename);

        // Remove path and file extension

        gchar *path=NULL;

        gchar *base = NULL;

        gchar *ext = NULL;

        split_filename3(filename, &path, &base, &ext);

        // Filenames do match?

        del_flag = (filename && !g_strcmp0(base, cmd->title));

        g_free(path);

        g_free(base);

        g_free(ext);

        g_free(filename);

    }

    switch (cmd->type) {

    case RECORDING_STOP:

        rec_stop_recording(del_flag/*delete file?*/);

        break;

    case RECORDING_START:

        rec_start_recording();

        break;

    case RECORDING_PAUSE:

        rec_pause_recording();

        break;

    case RECORDING_CONTINUE:

        rec_continue_recording();

        break;

    case RECORDING_NOTIFY_MSG:

        win_set_error_text(cmd->title);

        break;

    case RECORDING_DEVICE_CHANGED:

        win_refresh_device_list();

        break;

    case RECORDING_PROFILE_CHANGED:

        win_refresh_profile_list();

        break;

    case RECORDING_SHOW_WINDOW:

        win_show_window(TRUE);

        break;

    case RECORDING_HIDE_WINDOW:

        win_show_window(FALSE);

        break;

    case RECORDING_QUIT_LOOP:

        rec_stop_recording(FALSE);

        break;

    case RECORDING_QUIT_APP:

        rec_stop_recording(FALSE);

        // Quit application

        win_quit_application();

        break;

    } // switch ...

    // Free the lastly saved command

    rec_manager_free_command(g_last_rec_cmd);

    // Save this command

    g_last_rec_cmd = cmd;

    // TRUE: Continue calling this function

    return TRUE;

}