spout.cpp File Reference

#include <array>
#include <cctype>
#include <chrono>
#include <iostream>
#include <memory>
#include <SpoutLibrary.h>
#include <synchapi.h>
#include <string>
#include "debug.h"
#include "gl_context.h"
#include "host.h"
#include "lib_common.h"
#include "spout_sender.h"
#include "utils/color_out.h"
#include "utils/text.h"
#include "video.h"
#include "video_capture.h"

Include dependency graph for spout.cpp:

Go to the source code of this file.

Classes
struct	state_vidcap_spout

Macros
#define	DEFAULT_CODEC   RGB
#define	DEFAULT_FPS   60.0
#define	MOD_NAME   "[spout cap.] "

Functions
	REGISTER_MODULE (spout, &vidcap_spout_info, LIBRARY_CLASS_VIDEO_CAPTURE, VIDEO_CAPTURE_ABI_VERSION)
static void	usage ()
static void	vidcap_spout_done (void *state)
static struct video_frame *	vidcap_spout_grab (void *state, struct audio_frame **audio)
static int	vidcap_spout_init (struct vidcap_params *params, void **state)
static void	vidcap_spout_probe (device_info **available_cards, int *count, void(**deleter)(void *))

Variables
static const struct video_capture_info	vidcap_spout_info

Detailed Description

Author

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

Definition in file spout.cpp.

Macro Definition Documentation

DEFAULT_CODEC

#define DEFAULT_CODEC   RGB

Definition at line 59 of file spout.cpp.

Referenced by usage(), and vidcap_spout_init().

DEFAULT_FPS

#define DEFAULT_FPS   60.0

Definition at line 58 of file spout.cpp.

Referenced by usage(), and vidcap_spout_init().

MOD_NAME

#define MOD_NAME   "[spout cap.] "

Definition at line 61 of file spout.cpp.

Referenced by vidcap_spout_init(), and vidcap_spout_probe().

Function Documentation

REGISTER_MODULE()

REGISTER_MODULE	(	spout	,
		&	vidcap_spout_info,
		LIBRARY_CLASS_VIDEO_CAPTURE	,
		VIDEO_CAPTURE_ABI_VERSION	)

usage()

static void usage ( void )

static

Definition at line 84 of file spout.cpp.

{
        col() << "Usage:\n";
        col() << "\t" << TBOLD(TRED("-t spout") << "[:name=<server_name>][:fps=<fps>][:codec=<codec>]") << "\n";
        col() << "where\n";
        col() << "\t" << TBOLD("name") << "\n\t\tSpout server name\n";
        col() << "\t" << TBOLD("fps") << "\n\t\tFPS count (default: " << DEFAULT_FPS << ")\n";
        col() << "\t" << TBOLD("codec") << "\n\t\tvideo codec (default: " << get_codec_name(DEFAULT_CODEC) << ")\n";
        col() << "\nServers:\n";
        auto receiver = shared_ptr<SPOUTLIBRARY>(GetSpout(), [](auto s) {s->Release();});
        int count = receiver->GetSenderCount();
 
        for (int i = 0; i < count; ++i) {
                array<char, 256> name{};
                if (!receiver->GetSender(i, name.data(), name.size())) {
                        LOG(LOG_LEVEL_ERROR) << "Cannot get name for server #" << i << "\n";
                        continue;
                }
                unsigned int width = 0;
                unsigned int height = 0;
                HANDLE dxShareHandle = 0;
                DWORD dwFormat = 0;
                if (!receiver->GetSenderInfo(name.data(), width, height, dxShareHandle, dwFormat)) {
                        LOG(LOG_LEVEL_ERROR) << "Cannot get server " << name.data() << "details\n";
                }
                col() << "\t" << TBOLD(<< name.data() <<) << ") width: " << width << ", height: " << height << "\n";
        }
}

References count, DEFAULT_CODEC, DEFAULT_FPS, get_codec_name(), LOG, LOG_LEVEL_ERROR, name, TBOLD, and TRED.

Referenced by vidcap_spout_init().

Here is the call graph for this function:

vidcap_spout_done()

static void vidcap_spout_done ( void * state )

static

Definition at line 199 of file spout.cpp.

{
        state_vidcap_spout *s = (state_vidcap_spout *) state;
 
        gl_context_make_current(&s->glc);
        s->spout_state->ReleaseReceiver();
        destroy_gl_context(&s->glc);
 
        delete s;
}

References destroy_gl_context(), gl_context_make_current(), state_vidcap_spout::glc, state_vidcap_spout::spout_state, and state.

Here is the call graph for this function:

vidcap_spout_grab()

static struct video_frame * vidcap_spout_grab ( void * state, struct audio_frame ** audio )

static

Definition at line 210 of file spout.cpp.

{
        enum {
                MS100 = 100,
        };
        state_vidcap_spout *s = (state_vidcap_spout *) state;
 
        gl_context_make_current(&s->glc);
        struct video_frame *out = vf_alloc_desc_data(s->desc);
        out->callbacks.dispose = vf_free;
 
        bool ret = s->spout_state->ReceiveImage((unsigned char *) out->tiles[0].data, s->gl_format);
        if (!ret) {
                vf_free(out);
                gl_context_make_current(NULL);
                MSG(WARNING, "No signal detected...\n");
                Sleep(MS100);
                return NULL;
        }
        if (s->spout_state->IsUpdated()) {
                s->desc.width = s->spout_state->GetSenderWidth();
                s->desc.height = s->spout_state->GetSenderHeight();
                MSG(NOTICE,
                    "Server updated - name: %s, size: %dx%d, fps: "
                    "%g, codec: %s\n",
                    s->spout_state->GetSenderName(), s->desc.width,
                    s->desc.height, s->desc.fps,
                    get_codec_name(s->desc.color_spec));
                vf_free(out);
                gl_context_make_current(NULL);
                return NULL;
        }
        gl_context_make_current(NULL);
 
        // wait until this frame is due
        decltype(s->last_frame_captured) t;
        do {
                t = std::chrono::steady_clock::now();
        } while (std::chrono::duration_cast<std::chrono::duration<double>>(t - s->last_frame_captured).count() < 1 / out->fps);
        s->last_frame_captured = t;
 
        *audio = NULL;
        return out;
}

References audio, video_frame::callbacks, video_desc::color_spec, tile::data, state_vidcap_spout::desc, video_frame_callbacks::dispose, video_desc::fps, video_frame::fps, get_codec_name(), gl_context_make_current(), state_vidcap_spout::gl_format, state_vidcap_spout::glc, video_desc::height, state_vidcap_spout::last_frame_captured, MSG, state_vidcap_spout::spout_state, state, video_frame::tiles, vf_alloc_desc_data(), vf_free(), and video_desc::width.

Here is the call graph for this function:

vidcap_spout_init()

static int vidcap_spout_init ( struct vidcap_params * params, void ** state )

static

Definition at line 113 of file spout.cpp.

{
        if ((vidcap_params_get_flags(params) & VIDCAP_FLAG_AUDIO_ANY) != 0U) {
                return VIDCAP_INIT_AUDIO_NOT_SUPPORTED;
        }
 
        state_vidcap_spout *s = new state_vidcap_spout();
 
        double fps = DEFAULT_FPS;
        codec_t codec = DEFAULT_CODEC;
 
        char *opts = strdup(vidcap_params_get_fmt(params));
        char *item, *save_ptr;
        int ret = VIDCAP_INIT_OK;
 
        item = strtok_r(opts, ":", &save_ptr);
        while (item) {
                if (strcmp(item, "help") == 0) {
                        usage();
                        ret = VIDCAP_INIT_NOERR;
                        break;
                } else if (strstr(item, "name=") == item) {
                        char *name = item + strlen("name=");
                        if (strstr(name, "urlencoded=") == name) {
                                name += strlen("urlencoded=");
                                if (urldecode(s->server_name, sizeof s->server_name, name) == 0) {
                                        LOG(LOG_LEVEL_WARNING) << MOD_NAME << "Improperly formatted name: " << item + strlen("name=") << "\n";
                                        ret = VIDCAP_INIT_FAIL;
                                }
                        } else {
                                strncpy(s->server_name, item + strlen("name="), sizeof(s->server_name) - 1);
                        }
                } else if (strstr(item, "fps=") == item) {
                        fps = atof(item + strlen("fps="));
                } else if (strstr(item, "codec=") == item) {
                        codec = get_codec_from_name(item + strlen("codec="));
                } else {
                        LOG(LOG_LEVEL_ERROR) << MOD_NAME << "Unknown argument - " << item << "\n";
                        ret = VIDCAP_INIT_FAIL;
                        break;
                }
                item = strtok_r(NULL, ":", &save_ptr);
        }
 
        free(opts);
 
        if (ret != VIDCAP_INIT_OK) {
                delete s;
                return ret;
        }
 
        switch (codec) {
        case RGB:
                s->gl_format = GL_RGB;
                break;
        case RGBA:
                s->gl_format = GL_RGBA;
                break;
        default:
                LOG(LOG_LEVEL_ERROR) << MOD_NAME << "Unsupported codec: " <<  get_codec_name(codec) << "! Currently only RGB and RGBA are supported.\n";
                delete s;
                return VIDCAP_INIT_FAIL;
        }
 
 
        if (!init_gl_context(&s->glc, GL_CONTEXT_ANY)) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME << "Unable to initialize GL context!\n";
                delete s;
                return VIDCAP_INIT_FAIL;
        }
        gl_context_make_current(&s->glc);
 
        s->spout_state = shared_ptr<SPOUTLIBRARY>(GetSpout(), [](auto s) {s->Release();});
        spout_set_log_level(s->spout_state.get(), log_level);
        if (strlen(s->server_name) != 0) {
                s->spout_state->SetReceiverName(s->server_name);
        }
 
        gl_context_make_current(NULL);
        s->desc = video_desc{0, 0, codec, fps, PROGRESSIVE, 1};
 
        MSG(INFO, "initialized successfully, waiting for input...\n");
        *state = s;
        return VIDCAP_INIT_OK;
}

References DEFAULT_CODEC, DEFAULT_FPS, state_vidcap_spout::desc, get_codec_from_name(), get_codec_name(), GL_CONTEXT_ANY, gl_context_make_current(), state_vidcap_spout::gl_format, state_vidcap_spout::glc, init_gl_context(), LOG, log_level, LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, MOD_NAME, MSG, name, PROGRESSIVE, RGB, RGBA, state_vidcap_spout::server_name, spout_set_log_level(), state_vidcap_spout::spout_state, state, urldecode(), usage(), VIDCAP_FLAG_AUDIO_ANY, VIDCAP_INIT_AUDIO_NOT_SUPPORTED, VIDCAP_INIT_FAIL, VIDCAP_INIT_NOERR, VIDCAP_INIT_OK, vidcap_params_get_flags(), and vidcap_params_get_fmt().

Here is the call graph for this function:

vidcap_spout_probe()

static void vidcap_spout_probe ( device_info ** available_cards, int * count, void(** deleter )(void *) )

static

Definition at line 255 of file spout.cpp.

{
        *deleter = free;
        *count = 0;
 
        auto receiver = shared_ptr<SPOUTLIBRARY>(GetSpout(), [](auto s) {s->Release();});
 
        int sender_count = receiver->GetSenderCount();
 
        *available_cards = (struct device_info *) calloc(sender_count, sizeof(struct device_info));
        if (*available_cards == nullptr) {
                return;
        }
        *count = sender_count;
 
        for (int i = 0; i < *count; ++i) {
                array<char, 256> name{};
                auto& card = (*available_cards)[i];
                if (!receiver->GetSender(i, name.data(), name.size())) {
                        LOG(LOG_LEVEL_VERBOSE) << MOD_NAME << "Cannot get name for server #" << i << "\n";
                        snprintf(card.dev, sizeof card.dev, ":device=%d", i);
                        snprintf(card.name, sizeof card.name, "Spout #%d", i);
                } else {
                        snprintf(card.dev, sizeof card.dev, ":name=urlencoded=");
                        urlencode(card.dev + strlen(card.dev),
                                        sizeof card.dev - strlen(card.dev),
                                        name.data(), urlencode_rfc3986_eval, false);
                        snprintf(card.name, sizeof card.name, "Spout %s", name.data());
                }
                card.repeatable = true;
        }
}

References count, deleter, LOG, LOG_LEVEL_VERBOSE, MOD_NAME, name, urlencode(), and urlencode_rfc3986_eval().

Here is the call graph for this function:

Variable Documentation

vidcap_spout_info

const struct video_capture_info vidcap_spout_info

static

Initial value:

= {
        vidcap_spout_probe,
        vidcap_spout_init,
        vidcap_spout_done,
        vidcap_spout_grab,
        MOD_NAME,
}

Definition at line 288 of file spout.cpp.

                                                           {
        vidcap_spout_probe,
        vidcap_spout_init,
        vidcap_spout_done,
        vidcap_spout_grab,
        MOD_NAME,
};