image_pattern Class Reference

Inheritance diagram for image_pattern:

Collaboration diagram for image_pattern:

Public Member Functions
	image_pattern ()=default
	image_pattern (const image_pattern &)=delete
	image_pattern (image_pattern &&)=delete
virtual	~image_pattern ()=default
auto	init (int width, int height, enum generator_depth depth) noexcept
image_pattern &	operator= (const image_pattern &)=delete
image_pattern &&	operator= (image_pattern &&)=delete

Static Public Member Functions
static unique_ptr< image_pattern >	create (string const &pattern, string const &params)

Private Member Functions
virtual void	convert_rg48_to_rgba (int width, int height, unsigned char *data)
virtual void	convert_rgba_to_rg48 (int width, int height, unsigned char *data)
virtual enum generator_depth	fill (int width, int height, unsigned char *data)=0

Detailed Description

Definition at line 103 of file video_pattern_generator.cpp.

Constructor & Destructor Documentation

~image_pattern()

virtual image_pattern::~image_pattern ( )

virtualdefault

image_pattern() [1/3]

image_pattern::image_pattern ( )

default

image_pattern() [2/3]

image_pattern::image_pattern ( const image_pattern & )

delete

image_pattern() [3/3]

image_pattern::image_pattern ( image_pattern && )

delete

Member Function Documentation

convert_rg48_to_rgba()

virtual void image_pattern::convert_rg48_to_rgba ( int width, int height, unsigned char * data )

inlineprivatevirtual

Note

in-place

Definition at line 147 of file video_pattern_generator.cpp.

                                                                                              {
                        for (int y = 0; y < height; ++y) {
                                for (int x = 0; x < width; ++x) {
                                        unsigned char *in_pix = data + 6 * (y * width + x);
                                        unsigned char *out_pix = data + 4 * (y * width + x);
                                        *out_pix++ = in_pix[1];
                                        *out_pix++ = in_pix[3];
                                        *out_pix++ = in_pix[5];
                                        *out_pix++ = 0xFFU;
                                }
                        }
                }

Referenced by init().

convert_rgba_to_rg48()

virtual void image_pattern::convert_rgba_to_rg48 ( int width, int height, unsigned char * data )

inlineprivatevirtual

Note

in-place

Definition at line 129 of file video_pattern_generator.cpp.

                                                                                              {
                        for (int y = height - 1; y >= 0; --y) {
                                for (int x = width - 1; x >= 0; --x) {
                                        unsigned char *in_pix = data + 4 * (y * width + x);
                                        unsigned char *out_pix = data + 6 * (y * width + x);
                                        unsigned char r = *in_pix++;
                                        unsigned char g = *in_pix++;
                                        unsigned char b = *in_pix++;
                                        *out_pix++ = 0;
                                        *out_pix++ = r;
                                        *out_pix++ = 0;
                                        *out_pix++ = g;
                                        *out_pix++ = 0;
                                        *out_pix++ = b;
                                }
                        }
                }

Referenced by init().

create()

unique_ptr< image_pattern > image_pattern::create ( string const & pattern, string const & params )

static

Definition at line 621 of file video_pattern_generator.cpp.

                                                                                           {
        if (pattern == "bars") {
                return make_unique<image_pattern_bars>(params);
        }
        if (pattern == "blank") {
                return make_unique<image_pattern_blank>(params);
        }
        if (pattern == "ebu_bars") {
                return make_unique<image_pattern_ebu_smpte_bars<0xFFU, 8>>();
        }
        if (pattern == "gradient") {
                return make_unique<image_pattern_gradient>(params);
        }
        if (pattern == "gradient2") {
                return make_unique<image_pattern_gradient2>(params);
        }
        if (pattern == "noise") {
                return make_unique<image_pattern_noise>();
        }
        if (pattern == "raw") {
                return make_unique<image_pattern_raw>(params);
        }
        if (pattern == "smpte_bars") {
                return make_unique<image_pattern_smpte_bars>();
        }
        if (pattern == "strips") {
                return make_unique<image_pattern_strips>(params);
        }
        if (pattern == "text") {
                return make_unique<image_pattern_text>(params);
        }
        if (pattern == "uv_plane") {
                return make_unique<image_pattern_uv_plane>(params);
        }
        if (pattern == "diagonal") {
                return make_unique<image_pattern_diagonal>(params);
        }
        throw ug_runtime_error("Unknown pattern: "s +  pattern + "!"s);
}

Referenced by still_image_video_pattern_generator::still_image_video_pattern_generator().

fill()

virtual enum generator_depth image_pattern::fill ( int width, int height, unsigned char * data )

privatepure virtual

Return values

bit	depth used by the generator (either 8 or 16)

Implemented in image_pattern_bars, image_pattern_blank, image_pattern_diagonal, image_pattern_ebu_smpte_bars< f, columns >, image_pattern_ebu_smpte_bars< 0xBFU, 7 >, image_pattern_gradient2, image_pattern_gradient, image_pattern_noise, image_pattern_raw, image_pattern_smpte_bars, image_pattern_strips, image_pattern_text, and image_pattern_uv_plane.

Referenced by init().

init()

auto image_pattern::init ( int width, int height, enum generator_depth depth )

inlinenoexcept

Definition at line 106 of file video_pattern_generator.cpp.

                                                                                      {
                        size_t data_len = width * height * rg48_bpp + headroom;
                        vector<unsigned char> out(data_len);
                        auto actual_bit_depth = fill(width, height, out.data());
                        if (depth == generator_depth::bits8 && actual_bit_depth == generator_depth::bits16) {
                                convert_rg48_to_rgba(width, height, out.data());
                        }
                        if (depth == generator_depth::bits16 && actual_bit_depth == generator_depth::bits8) {
                                convert_rgba_to_rg48(width, height, out.data());
                        }
                        return out;
                }

References bits16, bits8, convert_rg48_to_rgba(), convert_rgba_to_rg48(), fill(), headroom, and rg48_bpp.

Referenced by image_pattern_bars::image_pattern_bars(), and image_pattern_blank::image_pattern_blank().

Here is the call graph for this function:

operator=() [1/2]

image_pattern & image_pattern::operator= ( const image_pattern & )

delete

operator=() [2/2]

image_pattern && image_pattern::operator= ( image_pattern && )

delete

---

The documentation for this class was generated from the following file:

• src/utils/video_pattern_generator.cpp