export.c File Reference

#include <dirent.h>
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>
#include "export.h"
#include "audio/export.h"
#include "compat/misc.h"
#include "compat/time.h"
#include "debug.h"
#include "host.h"
#include "messaging.h"
#include "module.h"
#include "utils/color_out.h"
#include "utils/fs.h"
#include "utils/misc.h"
#include "video_export.h"

Include dependency graph for export.c:

Go to the source code of this file.

Classes
struct	exporter

Macros
#define	HANDLE_ERROR   export_destroy(s); return NULL;
#define	MOD_NAME   "[export] "
#define	WANT_MKDIR

Functions
static bool	create_dir (struct exporter *s)
static char *	create_implicit_dir (const char *prefix)
static bool	dir_is_empty (const char *dir)
static void	disable_export (struct exporter *s)
static bool	enable_export (struct exporter *s)
void	export_audio (struct exporter *s, struct audio_frame *frame)
void	export_destroy (struct exporter *s)
struct exporter *	export_init (struct module *parent, const char *cfg, bool should_export)
void	export_video (struct exporter *s, struct video_frame *frame)
static void	new_msg (struct module *mod)
static bool	parse_options (struct exporter *s, const char *ccfg, bool *should_export)
static void	process_messages (struct exporter *s)
static void	usage ()

Detailed Description

Author

Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

Definition in file export.c.

Macro Definition Documentation

HANDLE_ERROR

#define HANDLE_ERROR   export_destroy(s); return NULL;

Definition at line 147 of file export.c.

Referenced by export_init().

MOD_NAME

#define MOD_NAME   "[export] "

Definition at line 62 of file export.c.

Referenced by create_dir(), create_implicit_dir(), export_video(), and parse_options().

WANT_MKDIR

#define WANT_MKDIR

Definition at line 50 of file export.c.

Function Documentation

create_dir()

static bool create_dir ( struct exporter * s )

static

Definition at line 260 of file export.c.

{
        if (!s->dir) {
                s->dir = create_implicit_dir(".");
        } else {
                int ret = mkdir(s->dir, S_IRWXU | S_IRWXG | S_IRWXO);
                if(ret == -1) {
                        if(errno != EEXIST) {
                                perror("[Export] Directory creation failed");
                                return false;
                        }
                        if (dir_is_empty(s->dir)) {
                                log_msg(LOG_LEVEL_NOTICE, "[Export] Warning: directory %s exists but is an empty directory - using for export.\n", s->dir);
                        } else if (s->override) {
                                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Warning: directory %s exists and is not an empty directory but using as requested.\n", s->dir);
                        } else {
                                MSG(ERROR,
                                    "Warning: directory %s exists and is not "
                                    "an empty directory! Trying to create "
                                    "subdir.\n",
                                    s->dir);
                                char *prefix = s->dir;
                                s->dir = create_implicit_dir(prefix);
                                free(prefix);
                        }
                }
        }
 
        if (s->dir) {
                color_printf(TERM_BOLD TERM_FG_YELLOW "Using export directory: %s\n" TERM_RESET, s->dir);
                return true;
        } else {
                return false;
        }
}

References color_printf(), create_implicit_dir(), exporter::dir, dir_is_empty(), LOG_LEVEL_NOTICE, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, MSG, exporter::override, TERM_BOLD, TERM_FG_YELLOW, and TERM_RESET.

Referenced by enable_export().

Here is the call graph for this function:

create_implicit_dir()

static char * create_implicit_dir ( const char * prefix )

static

Tries to create directories export.<date>[-????] inside directory prefix. If succesful, returns its name.

Definition at line 215 of file export.c.

{
        enum {
                MAX_EXPORTS = 9999,
        };
        for (int i = 1; i <= MAX_EXPORTS; i++) {
                char       name[MAX_PATH_SIZE];
                time_t     t      = time(NULL);
                struct tm  tm_buf = { 0 };
                localtime_s(&t, &tm_buf);
                snprintf(name, sizeof name, "%s/", prefix);
                strftime(name + strlen(name), sizeof name - strlen(name),
                         "export.%Y%m%d", &tm_buf);
                if (i > 1) {
                        snprintf(name + strlen(name),
                                 sizeof name - strlen(name), "-%d", i);
                }
                int ret = mkdir(name, S_IRWXU | S_IRWXG | S_IRWXO);
                if(ret == -1) {
                        if(errno == EEXIST) { // record exists, try next directory
                                continue;
                        }
                        log_msg(LOG_LEVEL_ERROR,
                                MOD_NAME "Directory creation failed: %s\n",
                                ug_strerror(errno));
                        return false;
                }
                return strdup(name);
        }
        return NULL;
}

References localtime_s, LOG_LEVEL_ERROR, log_msg(), MAX_PATH_SIZE, MOD_NAME, name, and ug_strerror().

Referenced by create_dir().

Here is the call graph for this function:

dir_is_empty()

static bool dir_is_empty ( const char * dir )

static

Definition at line 247 of file export.c.

                                          {
        DIR *d = opendir(dir);
        if (!d) {
                return false;
        }
        readdir(d); // skip . and ..
        readdir(d);
        bool ret = readdir(d) == NULL;
        closedir(d);
 
        return ret;
}

Referenced by create_dir().

disable_export()

static void disable_export ( struct exporter * s )

static

Definition at line 296 of file export.c.

                                               {
        audio_export_destroy(s->audio_export);
        video_export_destroy(s->video_export);
        s->audio_export = NULL;
        s->video_export = NULL;
        if (s->dir_auto) {
                free(s->dir);
                s->dir = NULL;
        }
        s->exporting = false;
}

References exporter::audio_export, audio_export_destroy(), exporter::dir, exporter::dir_auto, exporter::exporting, exporter::video_export, and video_export_destroy().

Referenced by export_destroy(), export_video(), and process_messages().

Here is the call graph for this function:

enable_export()

static bool enable_export ( struct exporter * s )

static

Definition at line 177 of file export.c.

{
        if (!create_dir(s)) {
                goto error;
        }
 
        if (!s->novideo) {
                s->video_export = video_export_init(s->dir);
                if (!s->video_export) {
                        goto error;
                }
        }
 
        if (!s->noaudio) {
                char name[MAX_PATH_SIZE];
                snprintf(name, sizeof name, "%s/sound.wav", s->dir);
                s->audio_export = audio_export_init(name);
                if (!s->audio_export) {
                        goto error;
                }
        }
 
        s->exporting = true;
 
        return true;
 
error:
        video_export_destroy(s->video_export);
        s->video_export = NULL;
        return false;
}

References exporter::audio_export, audio_export_init(), create_dir(), exporter::dir, exporter::exporting, MAX_PATH_SIZE, name, exporter::noaudio, exporter::novideo, exporter::video_export, video_export_destroy(), and video_export_init().

Referenced by export_init(), and process_messages().

Here is the call graph for this function:

export_audio()

void export_audio	(	struct exporter *	s,
		struct audio_frame *	frame )

Definition at line 341 of file export.c.

{
        if(!s){
                return;
        }
 
        process_messages(s);
 
        pthread_mutex_lock(&s->lock);
        if (s->exporting) {
                audio_export(s->audio_export, frame);
        }
        pthread_mutex_unlock(&s->lock);
}

References audio_export(), exporter::audio_export, exporter::exporting, frame, exporter::lock, and process_messages().

Referenced by audio_sender_thread().

Here is the call graph for this function:

export_destroy()

void export_destroy

(

struct exporter *

s

)

Definition at line 308 of file export.c.

                                        {
        disable_export(s);
 
        pthread_mutex_destroy(&s->lock);
        module_done(&s->mod);
        free(s->dir);
        free(s);
}

References exporter::dir, disable_export(), exporter::lock, exporter::mod, and module_done().

Referenced by display_dump_done(), and main().

Here is the call graph for this function:

export_init()

struct exporter * export_init	(	struct module *	parent,
		const char *	cfg,
		bool	should_export )

Definition at line 149 of file export.c.

{
        struct exporter *s = calloc(1, sizeof(struct exporter));
        pthread_mutex_init(&s->lock, NULL);
        s->limit = -1;
 
        if (!parse_options(s, cfg, &should_export)) {
                HANDLE_ERROR
        }
        if (s->dir == NULL) {
                s->dir_auto = true;
        }
 
        if (should_export) {
                if (!enable_export(s)) {
                        HANDLE_ERROR
                }
        }
 
        module_init_default(&s->mod);
        s->mod.cls = MODULE_CLASS_EXPORTER;
        s->mod.new_message = new_msg;
        s->mod.priv_data = s;
        module_register(&s->mod, parent);
 
        return s;
}

References module::cls, exporter::dir, exporter::dir_auto, enable_export(), HANDLE_ERROR, exporter::limit, exporter::lock, exporter::mod, MODULE_CLASS_EXPORTER, module_init_default(), module_register(), module::new_message, new_msg(), parent, parse_options(), and module::priv_data.

Referenced by display_dump_init(), and main().

Here is the call graph for this function:

export_video()

void export_video	(	struct exporter *	s,
		struct video_frame *	frame )

Definition at line 356 of file export.c.

{
        if(!s){
                return;
        }
 
        process_messages(s);
 
        pthread_mutex_lock(&s->lock);
        if (s->exporting) {
                video_export(s->video_export, frame);
        }
        if (s->limit > 0) {
                if (--s->limit == 0) {
                        log_msg(LOG_LEVEL_NOTICE, MOD_NAME "Stopping export - limit reached.\n");
                        disable_export(s);
                        if (s->exit_on_limit) {
                                exit_uv(0);
                        }
                }
        }
        pthread_mutex_unlock(&s->lock);
}

References disable_export(), exporter::exit_on_limit, exit_uv(), exporter::exporting, frame, exporter::limit, exporter::lock, LOG_LEVEL_NOTICE, log_msg(), MOD_NAME, process_messages(), exporter::video_export, and video_export().

Referenced by display_dump_putf(), and video_rxtx::sender_loop().

Here is the call graph for this function:

new_msg()

static void new_msg ( struct module * mod )

static

Definition at line 85 of file export.c.

                                        {
        process_messages(mod->priv_data);
}

References module::priv_data, and process_messages().

Referenced by export_init(), and process_msg().

Here is the call graph for this function:

parse_options()

static bool parse_options ( struct exporter * s, const char * ccfg, bool * should_export )

static

Definition at line 106 of file export.c.

{
        if (ccfg == NULL) {
                return true;
        }
        char buf[STR_LEN];
        snprintf(buf, sizeof buf, "%s", ccfg);
        char *cfg = buf;
        char *save_ptr = NULL;
        char *item = NULL;
        while ((item = strtok_r(cfg, ":", &save_ptr)) != NULL) {
                if (strstr(item, "help") == item) {
                        usage();
                        return false;
                } else if (strstr(item, "noaudio") == item) {
                        s->noaudio = true;
                } else if (strstr(item, "novideo") == item) {
                        s->novideo = true;
                } else if (strstr(item, "override") == item) {
                        s->override = true;
                } else if (strstr(item, "paused") == item) {
                        *should_export = false; // start paused
                } else if (strstr(item, "limit=") == item) {
                        s->limit = strtoll(item + strlen("limit="), NULL, 0);
                        if (s->limit < 0) {
                                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Wrong limit: %s!\n", item + strlen("limit="));
                                return false;
                        }
                } else if (strcmp(item, "exit_on_limit") == 0) {
                        s->exit_on_limit = true;
                } else if (s->dir == NULL && cfg != NULL) {
                        s->dir = strdup(item);
                } else {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Wrong option: %s!\n", item);
                        return false;
                }
                cfg = NULL;
        }
        return true;
}

References exporter::dir, exporter::exit_on_limit, exporter::limit, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, exporter::noaudio, exporter::novideo, exporter::override, STR_LEN, and usage().

Referenced by export_init().

Here is the call graph for this function:

process_messages()

static void process_messages ( struct exporter * s )

static

Definition at line 317 of file export.c.

                                                 {
        struct message *m;
        while ((m = check_message(&s->mod))) {
                struct response *r;
                pthread_mutex_lock(&s->lock);
                struct msg_universal *msg = (struct msg_universal *) m;
                if (strcmp(msg->text, "toggle") == 0) {
                        if (s->exporting) {
                                disable_export(s);
                        } else {
                                enable_export(s);
                        }
                        log_msg(LOG_LEVEL_NOTICE, "Exporting: %s\n", s->exporting ? "ON" : "OFF");
                        r = new_response(RESPONSE_OK, NULL);
                } else if (strcmp(msg->text, "status") == 0) {
                        r = new_response(RESPONSE_OK, s->exporting ? "true" : "false");
                } else {
                        r = new_response(RESPONSE_NOT_FOUND, NULL);
                }
                pthread_mutex_unlock(&s->lock);
                free_message(m, r);
        }
}

References check_message(), disable_export(), enable_export(), exporter::exporting, free_message(), exporter::lock, LOG_LEVEL_NOTICE, log_msg(), msg_universal::m, exporter::mod, new_response(), RESPONSE_NOT_FOUND, and RESPONSE_OK.

Referenced by export_audio(), export_video(), and new_msg().

Here is the call graph for this function:

usage()

static void usage ( void )

static

Definition at line 89 of file export.c.

                    {
        color_printf("Usage:\n");
        color_printf("\t" TBOLD(
            TRED("--record") "[=<dir>[:limit=<n>[:exit_on_limit]][:noaudio]"
            "[:novideo][:override][:paused]] ") "\n" "\t" TBOLD(TRED("-E")
            "[<dir>[:<opts>]]") "\n\t" TBOLD("--record=help | -Ehelp") "\n");
        color_printf("where\n");
        color_printf(TERM_BOLD "\tlimit=<n>" TERM_RESET "         - write at "
                     " most <n> video frames (with optional exit)\n");
        color_printf(TERM_BOLD "\toverride" TERM_RESET
                               "          - export even if it would override "
                               "existing files in the given directory\n");
        color_printf(TERM_BOLD "\tnoaudio | novideo" TERM_RESET " - do not export audio/video\n");
        color_printf(TERM_BOLD "\tpaused" TERM_RESET "            - use specified directory but do not export immediately (can be started with a key or through control socket)\n");
}

References color_printf(), TBOLD, TERM_BOLD, TERM_RESET, and TRED.

Referenced by parse_options().

Here is the call graph for this function: