delay.c File Reference

#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "debug.h"
#include "lib_common.h"
#include "types.h"
#include "utils/color_out.h"
#include "utils/list.h"
#include "utils/macros.h"
#include "video_codec.h"
#include "video_display.h"
#include "video_frame.h"
#include "vo_postprocess.h"

Include dependency graph for delay.c:

Go to the source code of this file.

Classes
struct	state_delay

Macros
#define	MOD_NAME   "[vpp/delay] "

Functions
static void	delay_done (void *state)
static void	delay_get_out_desc (void *state, struct video_desc *out, int *in_display_mode, int *out_frames)
static bool	delay_get_property (void *state, int property, void *val, size_t *len)
static struct video_frame *	delay_getf (void *state)
static void *	delay_init (const char *config)
static bool	delay_postprocess (void *state, struct video_frame *in, struct video_frame *out, int req_pitch)
static bool	delay_reconfigure (void *state, struct video_desc desc)
	REGISTER_MODULE (delay, &vo_pp_delay_info, LIBRARY_CLASS_VIDEO_POSTPROCESS, VO_PP_ABI_VERSION)
static void	usage ()

Variables
static const struct vo_postprocess_info	vo_pp_delay_info

Detailed Description

Author

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

Definition in file delay.c.

Macro Definition Documentation

MOD_NAME

#define MOD_NAME   "[vpp/delay] "

Definition at line 54 of file delay.c.

Function Documentation

delay_done()

static void delay_done ( void * state )

static

Definition at line 183 of file delay.c.

{
        struct state_delay *s = state;
 
        struct video_frame *f = NULL;
        while ((f = simple_linked_list_pop(s->cached_frames)) != NULL) {
                vf_free(f);
        }
        simple_linked_list_destroy(s->cached_frames);
        free(s);
}

References state_delay::cached_frames, simple_linked_list_destroy(), simple_linked_list_pop(), state, and vf_free().

Here is the call graph for this function:

delay_get_out_desc()

static void delay_get_out_desc ( void * state, struct video_desc * out, int * in_display_mode, int * out_frames )

static

Definition at line 196 of file delay.c.

{
        struct state_delay *s = state;
 
        *out             = s->desc;
        *in_display_mode = DISPLAY_PROPERTY_VIDEO_MERGED;
        *out_frames      = 1;
}

References state_delay::desc, DISPLAY_PROPERTY_VIDEO_MERGED, and state.

delay_get_property()

static bool delay_get_property ( void * state, int property, void * val, size_t * len )

static

Definition at line 64 of file delay.c.

{
        (void) state;
        if (property != VO_PP_PROPERTY_CODECS) {
                return false;
        }
        const size_t codecs_len = (VC_END - VC_FIRST) * sizeof(codec_t);
        assert(codecs_len <= *len);
        *len            = codecs_len;
        codec_t *codecs = val;
        for (int i = VC_FIRST; i < VC_END; ++i) {
                codecs[i] = i;
        }
        return true;
}

References codecs, len, property, state, val, VC_END, VC_FIRST, and VO_PP_PROPERTY_CODECS.

delay_getf()

static struct video_frame * delay_getf ( void * state )

static

Definition at line 146 of file delay.c.

{
        struct state_delay *s = state;
 
        return vf_alloc_desc_data(s->desc);
}

References state_delay::desc, state, and vf_alloc_desc_data().

Here is the call graph for this function:

delay_init()

static void * delay_init ( const char * config )

static

Definition at line 92 of file delay.c.

{
        enum {
                MAX_VAL_FRM = 2000,
                MAX_VAL_SEC = 60,
        };
        if (!IS_KEY_PREFIX(config, "seconds") &&
            !IS_KEY_PREFIX(config, "frames")) {
                usage();
                return NULL;
        }
 
        const char *val_s = strchr(config, '=') + 1;
        double      val   = strtod(val_s, NULL);
        if (val <= 0 || val > MAX_VAL_FRM ||
            (IS_KEY_PREFIX(config, "seconds") && val > MAX_VAL_SEC)) {
                MSG(ERROR, "Wrong delay value: %s\n", val_s);
                return NULL;
        }
        if (IS_KEY_PREFIX(config, "frames") && fabs(round(val) - val) > 0.0) {
                MSG(ERROR, "Number of frames should be an integer, given: %s\n",
                    val_s);
                return NULL;
        }
 
        struct state_delay *s = calloc(1, sizeof(struct state_delay));
        assert(s != NULL);
        if (IS_KEY_PREFIX(config, "seconds")) {
                s->delay_sec = val;
        } else {
                s->delay_frames = (int) val;
        }
        MSG(INFO, "Delay set to %g %s.\n", val,
            s->delay_sec ? "seconds" : "frames");
        s->cached_frames = simple_linked_list_init();
 
        return s;
}

References state_delay::cached_frames, state_delay::delay_frames, state_delay::delay_sec, IS_KEY_PREFIX, MSG, round(), simple_linked_list_init(), usage(), and val.

Here is the call graph for this function:

delay_postprocess()

static bool delay_postprocess ( void * state, struct video_frame * in, struct video_frame * out, int req_pitch )

static

Definition at line 154 of file delay.c.

{
        struct state_delay *s = state;
 
        simple_linked_list_append(s->cached_frames, in);
 
        const int list_size = simple_linked_list_size(s->cached_frames);
        if (s->delay_frames >= 0 && list_size < s->delay_frames) {
                return false;
        }
 
        if (list_size / s->desc.fps < s->delay_sec) {
                return false;
        }
 
        struct video_frame *f = simple_linked_list_pop(s->cached_frames);
        const size_t        linesize =
            vc_get_linesize(f->tiles[0].width, f->color_spec);
        for (size_t i = 0; i < s->desc.height; ++i) {
                memcpy(out->tiles[0].data + i * req_pitch,
                       f->tiles[0].data + i * linesize, linesize);
        }
        vf_free(f);
 
        return true;
}

References state_delay::cached_frames, video_frame::color_spec, tile::data, state_delay::delay_frames, state_delay::delay_sec, state_delay::desc, video_desc::fps, video_desc::height, simple_linked_list_append(), simple_linked_list_pop(), simple_linked_list_size(), state, video_frame::tiles, vc_get_linesize(), vf_free(), and tile::width.

Here is the call graph for this function:

delay_reconfigure()

static bool delay_reconfigure ( void * state, struct video_desc desc )

static

Definition at line 132 of file delay.c.

{
        struct state_delay *s = (struct state_delay *) state;
        s->desc               = desc;
 
        struct video_frame *f = NULL;
        while ((f = simple_linked_list_pop(s->cached_frames)) != NULL) {
                vf_free(f);
        }
 
        return true;
}

References state_delay::cached_frames, desc, state_delay::desc, simple_linked_list_pop(), state, and vf_free().

Here is the call graph for this function:

REGISTER_MODULE()

REGISTER_MODULE	(	delay	,
		&	vo_pp_delay_info,
		LIBRARY_CLASS_VIDEO_POSTPROCESS	,
		VO_PP_ABI_VERSION	)

usage()

static void usage ( void )

static

Definition at line 81 of file delay.c.

{
        color_printf(TBOLD("delay") " postprocessor settings:\n");
        color_printf(
            TBOLD(TRED("\t-p delay:[seconds=<s>|frames=<f>]")) " | " TBOLD(
                "-p delay:help") "\n");
        color_printf("\nSeconds can be given as a decimal number.\n");
        color_printf("\n");
}

References color_printf(), TBOLD, and TRED.

Referenced by delay_init().

Here is the call graph for this function:

Variable Documentation

vo_pp_delay_info

const struct vo_postprocess_info vo_pp_delay_info

static

Initial value:

= {
        delay_init,         delay_reconfigure, delay_getf, delay_get_out_desc,
        delay_get_property, delay_postprocess, delay_done,
}

Definition at line 206 of file delay.c.

                                                           {
        delay_init,         delay_reconfigure, delay_getf, delay_get_out_desc,
        delay_get_property, delay_postprocess, delay_done,
};