#include "types.h"

Include dependency graph for video_pattern_generator.h:

This graph shows which files directly or indirectly include this file:

Typedefs
typedef struct video_pattern_generator *	video_pattern_generator_t

Functions
video_pattern_generator_t	video_pattern_generator_create (const char *config, int width, int height, codec_t color_spec, int offset)

void	video_pattern_generator_destroy (video_pattern_generator_t)

void	video_pattern_generator_fill_data (video_pattern_generator_t, const char *data)

char *	video_pattern_generator_next_frame (video_pattern_generator_t)

Detailed Description

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

Definition in file video_pattern_generator.h.

Typedef Documentation

◆ video_pattern_generator_t

typedef struct video_pattern_generator* video_pattern_generator_t

Definition at line 44 of file video_pattern_generator.h.

Function Documentation

◆ video_pattern_generator_create()

video_pattern_generator_t video_pattern_generator_create	(	const char *	config,
		int	width,
		int	height,
		codec_t	color_spec,
		int	offset )

Parameters

offset offset between still image frames (in bytes)

Definition at line 830 of file video_pattern_generator.cpp.

{
 
        if (string(config) == "help") {
                col() << "Pattern to use, one of: \n";
                for (const auto *p :
                     {
                        "bars",
                        BLANK_USAGE,
                        "diagonal*",
                        "ebu_bars",
                        "gradient[=0x<AABBGGRR>]",
                        "gradient2*",
                        "gray",
                        "interlaced",
                        "noise",
                        "raw=0xXX[YYZZ..]",
                        "smpte_bars",
                        "strips*",
                        "uv_plane[=<y_lvl>]",
                         }) {
                        col() << "\t- " << SBOLD(p) << "\n";
                }
 
                col() << "\nNotes:\n";
 
                col() << "\t- patterns " SBOLD("'gradient'") ", "
                        SBOLD("'gradient2'") ", " SBOLD("'noise'") " and "
                        SBOLD("'uv_plane'") " generate higher bit-depth "
                        "patterns with";
                for (codec_t c = VIDEO_CODEC_FIRST; c != VIDEO_CODEC_COUNT;
                     c = static_cast<codec_t>(static_cast<int>(c) + 1)) {
                        if (get_decoder_from_to(RG48, c) != NULL && get_bits_per_component(c) > 8) {
                                col() << " " << SBOLD(get_codec_name(c));
                        }
                }
                col() << "\n";
                col() << "\t- pattern "
                      << SBOLD("'raw'") " generates repeating sequence of given "
                                      "bytes without any color conversion\n";
                col() << "\t- patterns marked with "
                      << SBOLD("'*'") " provide help as its option\n";
                return nullptr;
        }
        assert(width > 0 && height > 0);
        try {
                string pattern = config;
                string params;
                if (string::size_type delim = pattern.find('='); delim != string::npos) {
                        params = pattern.substr(delim + 1);
                        pattern = pattern.substr(0, delim);
                }
                if (pattern == "gray" || pattern == "grey") {
                        return new gray_video_pattern_generator{width, height, color_spec, params};
                }
                if (pattern == "interlaced") {
                        return new interlaced_video_pattern_generator{width, height, color_spec};
                }
                return new still_image_video_pattern_generator{pattern, params, width, height, color_spec, offset};
        } catch (exception const &e) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME << e.what() << "\n";
                return nullptr;
        } catch (...) {
                return nullptr;
        }
}

References BLANK_USAGE, get_bits_per_component(), get_codec_name(), get_decoder_from_to(), LOG, LOG_LEVEL_ERROR, MOD_NAME, offset, params, RG48, SBOLD, VIDEO_CODEC_COUNT, and VIDEO_CODEC_FIRST.

Referenced by vidcap_testcard_init().

Here is the call graph for this function:

◆ video_pattern_generator_destroy()

void video_pattern_generator_destroy ( video_pattern_generator_t s )

Definition at line 909 of file video_pattern_generator.cpp.

{
        delete s;
}

Referenced by vidcap_testcard_done().

◆ video_pattern_generator_fill_data()

void video_pattern_generator_fill_data	(	video_pattern_generator_t	s,
		const char *	data )

Definition at line 902 of file video_pattern_generator.cpp.

{
        auto &state = dynamic_cast<still_image_video_pattern_generator &>(*s);
        memcpy(state.data.data(), data, state.data_len);
        memcpy(state.data.data() + state.data_len, data, state.data_len);
}

References state.

Referenced by vidcap_testcard_init().

◆ video_pattern_generator_next_frame()

char * video_pattern_generator_next_frame ( video_pattern_generator_t s )

Definition at line 897 of file video_pattern_generator.cpp.

{
        return s->get_next();
}

References video_pattern_generator::get_next().

Referenced by vidcap_testcard_grab().