resize.c File Reference

#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "capture_filter.h"
#include "capture_filter/resize_utils.h"
#include "debug.h"
#include "lib_common.h"
#include "utils/color_out.h"
#include "utils/macros.h"
#include "utils/parallel_conv.h"
#include "video.h"
#include "video_codec.h"
#include "vo_postprocess/capture_filter_wrapper.h"

Include dependency graph for resize.c:

Go to the source code of this file.

Classes
struct	state_resize

Macros
#define	MOD_NAME   "[resize filter] "

Functions
static void	cleanup_common (struct state_resize *s)
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)
static int	parse_fmt (char *cfg, struct resize_param *param)
static bool	reconfigure_if_needed (struct state_resize *s, const struct video_frame *in)
	REGISTER_MODULE (resize, &capture_filter_resize, LIBRARY_CLASS_CAPTURE_FILTER, CAPTURE_FILTER_ABI_VERSION)
static void	usage ()
static void	vo_pp_set_out_buffer (void *state, char *buffer)

Variables
static const struct capture_filter_info	capture_filter_resize

Detailed Description

Author

Gerard Castillo gerar.nosp@m.d.ca.nosp@m.still.nosp@m.o@i2.nosp@m.cat.n.nosp@m.et

Marc Palau marc..nosp@m.pala.nosp@m.u@i2c.nosp@m.at.n.nosp@m.et

Martin Pulec marti.nosp@m.n.pu.nosp@m.lec@c.nosp@m.esne.nosp@m.t.cz

Definition in file resize.c.

Macro Definition Documentation

MOD_NAME

#define MOD_NAME   "[resize filter] "

Definition at line 63 of file resize.c.

Function Documentation

cleanup_common()

static void cleanup_common ( struct state_resize * s )

static

Definition at line 172 of file resize.c.

{
    vf_free(s->dec_frame);
    s->dec_frame = NULL;
}

References state_resize::dec_frame, and vf_free().

Referenced by done(), and reconfigure_if_needed().

Here is the call graph for this function:

done()

static void done ( void * state )

static

Definition at line 179 of file resize.c.

{
    cleanup_common((struct state_resize *) state);
    free(state);
}

References cleanup_common(), and state.

Here is the call graph for this function:

filter()

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

static

Definition at line 231 of file resize.c.

{
    struct state_resize *s = state;
 
    if (!reconfigure_if_needed(s, in)) {
        VIDEO_FRAME_DISPOSE(in);
        return NULL;
    }
 
    struct video_frame *out_frame = vf_alloc_desc(s->out_desc);
    if (s->vo_pp_out_buffer) {
        out_frame->tiles[0].data = s->vo_pp_out_buffer;
    } else {
        out_frame->tiles[0].data = (char *) malloc(out_frame->tiles[0].data_len);
        out_frame->callbacks.data_deleter = vf_data_deleter;
    }
 
    for (unsigned int i = 0; i < out_frame->tile_count; i++) {
        if (s->decoder != vc_memcpy) {
            parallel_pix_conv(
                (int) in->tiles[i].height, s->dec_frame->tiles[i].data,
                vc_get_linesize(in->tiles[i].width, s->dec_frame->color_spec),
                in->tiles[i].data,
                vc_get_linesize(in->tiles[i].width, in->color_spec), s->decoder,
                0);
        }
        struct video_frame *const in_frame =
            s->decoder == vc_memcpy ? in : s->dec_frame;
 
        resize_frame(in_frame->tiles[i].data, in_frame->color_spec,
                     out_frame->tiles[i].data, (int) in_frame->tiles[i].width,
                     (int) in_frame->tiles[i].height, &s->param);
    }
 
    VIDEO_FRAME_DISPOSE(in);
 
    out_frame->callbacks.dispose = vf_free;
 
    return out_frame;
}

References video_frame::callbacks, video_frame::color_spec, tile::data, video_frame_callbacks::data_deleter, tile::data_len, state_resize::dec_frame, state_resize::decoder, video_frame_callbacks::dispose, tile::height, state_resize::out_desc, parallel_pix_conv(), state_resize::param, reconfigure_if_needed(), resize_frame(), state, video_frame::tile_count, video_frame::tiles, vc_get_linesize(), vc_memcpy, vf_alloc_desc(), vf_data_deleter(), vf_free(), VIDEO_FRAME_DISPOSE, state_resize::vo_pp_out_buffer, and tile::width.

Here is the call graph for this function:

init()

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

static

Definition at line 147 of file resize.c.

{
    UNUSED(parent);
    struct resize_param param = { .algo = RESIZE_ALGO_DFL };
 
    if(strcasecmp(cfg, "help") == 0) {
        usage();
        return 1;
    }
 
    char *fmt = strdup(cfg);
    const int rc = parse_fmt(fmt, &param);
    free(fmt);
    if (rc != 0) {
        return rc;
    }
 
    struct state_resize *s = calloc(1, sizeof(struct state_resize));
    s->param = param;
 
    *state = s;
    return 0;
}

References fmt, param, state_resize::param, parent, parse_fmt(), RESIZE_ALGO_DFL, state, UNUSED, and usage().

Here is the call graph for this function:

parse_fmt()

static int parse_fmt ( char * cfg, struct resize_param * param )

static

Definition at line 101 of file resize.c.

{
    char *save_ptr = NULL;
    char *item     = NULL;
    while ((item = strtok_r(cfg, ":", &save_ptr))) {
        cfg = NULL;
        if (IS_KEY_PREFIX(item, "algorithm")) {
            param->algo = resize_algo_from_string(strchr(item, '=') + 1);
            if (param->algo < 0) {
                    return param->algo == RESIZE_ALGO_HELP_SHOWN ? 1 : -1;
            }
            continue;
        }
        if (!isdigit(item[0]) && item[0] != '.') {
            log_msg(LOG_LEVEL_ERROR,
                    "[RESIZE ERROR] Unrecognized part of config "
                    "string: %s\n",
                    item);
            return -1;
        }
        if (strchr(item, 'x')) {
            param->mode          = USE_DIMENSIONS;
            param->target_width  = strtol(item, NULL, 10);
            param->target_height = strtol(strchr(item, 'x') + 1, NULL, 10);
        } else {
            param->mode   = USE_FRACTION;
            param->factor = strtod(item, NULL);
            if (strchr(item, '/')) {
                    const long den = strtol(strchr(item, '/') + 1, NULL, 10);
                    param->factor  = den <= 0 ? .0 : param->factor / den;
            }
        }
    }
 
    if (param->mode == USE_DIMENSIONS && param->target_width > 0 &&
        param->target_height > 0) {
        return 0;
    }
    if (param->mode == USE_FRACTION && param->factor > 0) {
        return 0;
    }
 
    MSG(ERROR, "No or incorrect resize size!\n");
    return -1;
}

References IS_KEY_PREFIX, LOG_LEVEL_ERROR, log_msg(), MSG, param, resize_algo_from_string(), and RESIZE_ALGO_HELP_SHOWN.

Referenced by init().

Here is the call graph for this function:

reconfigure_if_needed()

static bool reconfigure_if_needed ( struct state_resize * s, const struct video_frame * in )

static

Definition at line 186 of file resize.c.

{
    if (video_desc_eq(video_desc_from_frame(in), s->saved_desc)) {
        return true;
    }
    struct video_desc dec_desc         = video_desc_from_frame(in);
    s->out_desc                        = video_desc_from_frame(in);
    const codec_t supp_in_codecs[] = { RESIZE_SUPPORTED_PIXFMT_INIT,
                                           VIDEO_CODEC_NONE };
    if (codec_is_in_set(in->color_spec, supp_in_codecs)) {
        dec_desc.color_spec = in->color_spec;
        s->decoder = vc_memcpy;
    } else {
        s->decoder = get_best_decoder_from(in->color_spec, supp_in_codecs,
                                           &dec_desc.color_spec);
        if (s->decoder == NULL) {
            MSG(ERROR,
                "Cannot decode %s to neither of supported input formats!\n",
                get_codec_name(in->color_spec));
            return false;
        }
    }
    s->out_desc.color_spec =
        get_bits_per_component(dec_desc.color_spec) == DEPTH8 ? RGB : RG48;
    MSG(INFO, "Decoding through %s to output pixfmt %s.\n",
        get_codec_name(dec_desc.color_spec),
        get_codec_name(s->out_desc.color_spec));
 
    if (s->param.mode == USE_DIMENSIONS) {
        s->out_desc.width  = s->param.target_width;
        s->out_desc.height = s->param.target_height;
    } else {
        s->out_desc.width = in->tiles[0].width * s->param.factor;
        s->out_desc.height = in->tiles[0].height * s->param.factor;
    }
    s->saved_desc = video_desc_from_frame(in);
    cleanup_common(s);
    if (s->decoder != vc_memcpy) {
        s->dec_frame               = vf_alloc_desc_data(dec_desc);
    }
    MSG(NOTICE, "resizing from %dx%d to %dx%d\n", s->saved_desc.width,
        s->saved_desc.height, s->out_desc.width, s->out_desc.height);
    return true;
}

References cleanup_common(), codec_is_in_set(), video_desc::color_spec, video_frame::color_spec, state_resize::dec_frame, state_resize::decoder, DEPTH8, resize_param::factor, get_best_decoder_from(), get_bits_per_component(), get_codec_name(), tile::height, video_desc::height, resize_param::mode, MSG, state_resize::out_desc, state_resize::param, RESIZE_SUPPORTED_PIXFMT_INIT, RG48, RGB, state_resize::saved_desc, resize_param::target_height, resize_param::target_width, video_frame::tiles, vc_memcpy, vf_alloc_desc_data(), VIDEO_CODEC_NONE, video_desc_eq(), video_desc_from_frame(), tile::width, and video_desc::width.

Referenced by filter().

Here is the call graph for this function:

REGISTER_MODULE()

REGISTER_MODULE	(	resize	,
		&	capture_filter_resize,
		LIBRARY_CLASS_CAPTURE_FILTER	,
		CAPTURE_FILTER_ABI_VERSION	)

usage()

static void usage ( void )

static

Definition at line 80 of file resize.c.

                    {
    printf("Scaling by scale factor:\n\n");
    printf("resize usage:\n");
    color_printf("\t" TBOLD(TRED("resize") ":numerator[/denominator][algo=<a>]") "\n");
    printf("or\n");
    printf("\t" TBOLD(TRED("resize") ":<width>x<height>[algo=<a>]") "\n\n");
    color_printf("Scaling examples:\n"
                 "\t" TBOLD("resize:1/2") " | " TBOLD("resize:0.5")
                 " - downscale input frame size by scale factor of 2\n"
                 "\t" TBOLD("resize:1280x720")
                 " - scales input to 1280x720\n"
                 "\t" TBOLD("resize:720x576")
                 " - scales input to PAL\n");
    color_printf(
        "\nOptions:\n"
        "\t" TBOLD(
            "algo") " - scaling algorithm to use (list with `algo:help`)\n");
    color_printf("\n");
}

References color_printf(), TBOLD, and TRED.

Referenced by init().

Here is the call graph for this function:

vo_pp_set_out_buffer()

static void vo_pp_set_out_buffer ( void * state, char * buffer )

static

Definition at line 272 of file resize.c.

{
        struct state_resize *s = state;
        s->vo_pp_out_buffer = buffer;
}

References state, and state_resize::vo_pp_out_buffer.

Variable Documentation

capture_filter_resize

const struct capture_filter_info capture_filter_resize

static

Initial value:

= {
    init,
    done,
    filter,
}

Definition at line 278 of file resize.c.

                                                                {
    init,
    done,
    filter,
};