display.c File Reference

#include "capture_filter.h"
#include "compat/strings.h"
#include "debug.h"
#include "lib_common.h"
#include "utils/color_out.h"
#include "utils/list.h"
#include "utils/text.h"
#include "video.h"
#include "video_codec.h"
#include "video_display.h"
#include "video_frame.h"

Include dependency graph for display.c:

Go to the source code of this file.

Classes
struct	capture_filter_display

Macros
#define	MAX_QUEUE_LEN   3
#define	MOD_NAME   "[display cap. f.] "

Functions
static void	done (void *state)
static struct video_frame *	filter (void *state, struct video_frame *in)
static int	init (struct module *parent, const char *cfg, void **state)
	REGISTER_HIDDEN_MODULE (display, &capture_filter_display, LIBRARY_CLASS_CAPTURE_FILTER, CAPTURE_FILTER_ABI_VERSION)
static codec_t	select_display_codec (codec_t *display_codecs, codec_t recv_codec)
static void *	worker (void *arg)

Variables
static const struct capture_filter_info	capture_filter_display

Detailed Description

Author

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

Definition in file display.c.

Macro Definition Documentation

MAX_QUEUE_LEN

#define MAX_QUEUE_LEN   3

Todo

• the data is 2x copied

Definition at line 60 of file display.c.

Referenced by filter().

MOD_NAME

#define MOD_NAME   "[display cap. f.] "

Definition at line 61 of file display.c.

Referenced by filter(), init(), and worker().

Function Documentation

done()

static void done ( void * state )

static

Definition at line 204 of file display.c.

{
        struct capture_filter_display *s = state;
        filter(s, NULL);
        pthread_join(s->thread_id, NULL);
        display_join(s->d);
        display_done(s->d);
        pthread_mutex_destroy(&s->lock);
        pthread_cond_destroy(&s->cv);
        simple_linked_list_destroy(s->frame_queue);
        free(s);
}

References capture_filter_display::cv, capture_filter_display::d, display_done(), display_join(), filter(), capture_filter_display::frame_queue, capture_filter_display::lock, simple_linked_list_destroy(), state, and capture_filter_display::thread_id.

Here is the call graph for this function:

filter()

static struct video_frame * filter ( void * state, struct video_frame * in )

static

Definition at line 186 of file display.c.

{
        struct capture_filter_display *s = state;
        struct video_frame *f = in ? vf_get_copy(in) : NULL;
        pthread_mutex_lock(&s->lock);
        if (simple_linked_list_size(s->frame_queue) == MAX_QUEUE_LEN) {
                pthread_mutex_unlock(&s->lock);
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Queue full, frame not displayed.\n");
                vf_free(f);
                return in;
        }
        simple_linked_list_append(s->frame_queue, f);
        pthread_mutex_unlock(&s->lock);
        pthread_cond_signal(&s->cv);
 
        return in;
}

References capture_filter_display::cv, capture_filter_display::frame_queue, capture_filter_display::lock, LOG_LEVEL_WARNING, log_msg(), MAX_QUEUE_LEN, MOD_NAME, simple_linked_list_append(), simple_linked_list_size(), state, vf_free(), and vf_get_copy().

Referenced by done().

Here is the call graph for this function:

init()

static int init ( struct module * parent, const char * cfg, void ** state )

static

Definition at line 145 of file display.c.

{
        char warn[] = MOD_NAME "Capture filter \"display\" is experimental and may not "
                "always work as expected, especially if the same SW display "
                "type (eg. GL) is given as both preview display and a regular one.";
        log_msg(LOG_LEVEL_WARNING, "%s\n", wrap_paragraph(warn));
 
        if (strlen(cfg) == 0 || strcmp(cfg, "help") == 0) {
                color_printf("Previews captured frame with specified dispay.\n"
                          "Usage:\n"
                          "\t" TBOLD("--capture-filter display:<display_cfg>") "\n");
                return 1;
        }
 
        char *requested_display = strdupa(cfg);
        char *delim = strchr(requested_display, ':');
        const char *fmt = "";
        if (delim) {
                *delim = '\0';
                fmt = delim + 1;
        }
        struct display *d;
        int ret = initialize_video_display(parent, requested_display,
                fmt, 0, NULL, &d);
        if (ret != 0) {
                return ret;
        }
 
        struct capture_filter_display *s = calloc(1, sizeof *s);
        s->d = d;
        s->frame_queue = simple_linked_list_init();
        pthread_mutex_init(&s->lock, NULL);
        pthread_cond_init(&s->cv, NULL);
 
        display_run_new_thread(s->d);
        pthread_create(&s->thread_id, NULL, worker, s);
 
        *state = s;
        return 0;
}

References color_printf(), capture_filter_display::cv, capture_filter_display::d, display_run_new_thread(), fmt, capture_filter_display::frame_queue, initialize_video_display(), capture_filter_display::lock, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, parent, simple_linked_list_init(), state, strdupa, TBOLD, capture_filter_display::thread_id, worker(), and wrap_paragraph().

Here is the call graph for this function:

REGISTER_HIDDEN_MODULE()

REGISTER_HIDDEN_MODULE	(	display	,
		&	capture_filter_display,
		LIBRARY_CLASS_CAPTURE_FILTER	,
		CAPTURE_FILTER_ABI_VERSION	)

select_display_codec()

static codec_t select_display_codec ( codec_t * display_codecs, codec_t recv_codec )

static

Definition at line 79 of file display.c.

                                                                                 {
        if (codec_is_in_set(recv_codec, display_codecs)) {
                return recv_codec;
        }
        codec_t out = VIDEO_CODEC_NONE;
        get_best_decoder_from(recv_codec, display_codecs, &out);
        return out;
}

References codec_is_in_set(), get_best_decoder_from(), and VIDEO_CODEC_NONE.

Referenced by worker().

Here is the call graph for this function:

worker()

static void * worker ( void * arg )

static

Definition at line 88 of file display.c.

                               {
        struct capture_filter_display *s = arg;
        struct video_desc configured_desc = { 0 };
        codec_t display_codecs[VIDEO_CODEC_COUNT + 1];
        size_t len = sizeof display_codecs;
        if (!display_ctl_property(s->d, DISPLAY_PROPERTY_CODECS, display_codecs, &len)) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Cannot query display supported codecs!\n");
                exit_uv(1);
                return NULL;
        }
        display_codecs[len / sizeof display_codecs[0]] = VIDEO_CODEC_NONE;
        int rgb_shift[] = { DEFAULT_R_SHIFT, DEFAULT_G_SHIFT, DEFAULT_B_SHIFT };
        len = sizeof rgb_shift;
        if (!display_ctl_property(s->d, DISPLAY_PROPERTY_RGB_SHIFT, rgb_shift, &len)) {
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Cannot query display RGB shift!\n");
        }
        decoder_t dec = NULL;
        int src_linesize = 0;
        int dst_linesize = 0;
 
        while (1) {
                pthread_mutex_lock(&s->lock);
                while (simple_linked_list_size(s->frame_queue) == 0) {
                        pthread_cond_wait(&s->cv, &s->lock);
                }
                struct video_frame *f = simple_linked_list_pop(s->frame_queue);
                pthread_mutex_unlock(&s->lock);
                if (!f) {
                        display_put_frame(s->d, NULL, PUTF_BLOCKING); // pass poison pill
                        break;
                }
 
                struct video_desc new_desc = video_desc_from_frame(f);
                if (!video_desc_eq(configured_desc, new_desc)) {
                        struct video_desc display_desc = new_desc;
                        display_desc.color_spec = select_display_codec(display_codecs, new_desc.color_spec);
                        if (!display_desc.color_spec || !display_reconfigure(s->d, display_desc, VIDEO_NORMAL)) {
                                log_msg(LOG_LEVEL_ERROR, "Unable to reconfigure to %s!\n", video_desc_to_string(display_desc));
                                continue;
                        }
                        log_msg(LOG_LEVEL_NOTICE, MOD_NAME "Reconfigured display to %s\n", video_desc_to_string(display_desc));
                        dec = get_decoder_from_to(new_desc.color_spec, display_desc.color_spec);
                        src_linesize = vc_get_linesize(f->tiles[0].width, f->color_spec);
                        dst_linesize = vc_get_linesize(f->tiles[0].width, display_desc.color_spec);
                        configured_desc = new_desc;
                }
                struct video_frame *df = display_get_frame(s->d);
                for (size_t i = 0; i < f->tiles[0].height; ++i) {
                        dec((unsigned char *) df->tiles[0].data + i * dst_linesize, (unsigned char *) f->tiles[0].data + i * src_linesize, dst_linesize, rgb_shift[0], rgb_shift[1], rgb_shift[2]);
                }
                display_put_frame(s->d, df, PUTF_BLOCKING);
                vf_free(f);
        }
 
        return NULL;
}

References video_desc::color_spec, video_frame::color_spec, capture_filter_display::cv, capture_filter_display::d, tile::data, DEFAULT_B_SHIFT, DEFAULT_G_SHIFT, DEFAULT_R_SHIFT, display_ctl_property(), display_get_frame(), DISPLAY_PROPERTY_CODECS, DISPLAY_PROPERTY_RGB_SHIFT, display_put_frame(), display_reconfigure(), exit_uv(), capture_filter_display::frame_queue, get_decoder_from_to(), tile::height, len, capture_filter_display::lock, LOG_LEVEL_ERROR, LOG_LEVEL_NOTICE, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, PUTF_BLOCKING, select_display_codec(), simple_linked_list_pop(), simple_linked_list_size(), video_frame::tiles, vc_get_linesize(), vf_free(), VIDEO_CODEC_COUNT, VIDEO_CODEC_NONE, video_desc_eq(), video_desc_from_frame(), video_desc_to_string(), VIDEO_NORMAL, and tile::width.

Referenced by init().

Here is the call graph for this function:

Variable Documentation

capture_filter_display

const struct capture_filter_info capture_filter_display

static

Initial value:

= {
        .init = init,
        .done = done,
        .filter = filter,
}

Definition at line 217 of file display.c.

                                                                 {
        .init = init,
        .done = done,
        .filter = filter,
};