Inheritance diagram for image_pattern_bars:

Collaboration diagram for image_pattern_bars:

Public Member Functions
	image_pattern_bars (string const &init)

Public Member Functions inherited from image_pattern
	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

Private Member Functions
enum generator_depth	fill (int width, int height, unsigned char *data) override

Private Attributes
string	annotate

Additional Inherited Members
Static Public Member Functions inherited from image_pattern
static unique_ptr< image_pattern >	create (string const &pattern, string const &params)

Detailed Description

Definition at line 161 of file video_pattern_generator.cpp.

Constructor & Destructor Documentation

◆ image_pattern_bars()

image_pattern_bars::image_pattern_bars ( string const & init )

inlineexplicit

Definition at line 163 of file video_pattern_generator.cpp.

                                                        {
                if (init == "help"s) {
                        col() << "Testcard bar usage:\n\t" << SBOLD(SRED("-t testcard:pattern=bars") << "[=text]") << " - optionally annotate with text" << "\n";
                        throw 1;
                }
                annotate = init;
        }

References annotate, image_pattern::init(), SBOLD, and SRED.

Here is the call graph for this function:

Member Function Documentation

◆ fill()

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

inlineoverrideprivatevirtual

Return values

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

Implements image_pattern.

Definition at line 171 of file video_pattern_generator.cpp.

                                                                                       {
                int col_num = 0;
                int rect_size = COL_NUM;
                struct testcard_rect r{};
                struct testcard_pixmap pixmap{};
                pixmap.w = width;
                pixmap.h = height;
                pixmap.data = data;
                rect_size = (width + rect_size - 1) / rect_size;
                for (int j = 0; j < height; j += rect_size) {
                        uint32_t grey = 0xFF010101U;
                        if (j == rect_size * 2) {
                                r.w = width;
                                r.h = rect_size / 4;
                                r.x = 0;
                                r.y = j;
                                testcard_fillRect(&pixmap, &r, 0xFFFFFFFFU);
                                r.h = rect_size - (rect_size * 3 / 4);
                                r.y = j + rect_size * 3 / 4;
                                testcard_fillRect(&pixmap, &r, 0xFF000000U);
                        }
                        for (int i = 0; i < width; i += rect_size) {
                                r.x = i;
                                r.y = j;
                                r.w = rect_size;
                                r.h = min<int>(rect_size, height - r.y);
                                LOG(LOG_LEVEL_DEBUG) << MOD_NAME << "Fill rect at " << r.x << "," << r.y << "\n";
                                if (j != rect_size * 2) {
                                        testcard_fillRect(&pixmap, &r,
                                                        rect_colors[col_num]);
                                        col_num = (col_num + 1) % COL_NUM;
                                } else {
                                        r.h = rect_size / 2;
                                        r.y += rect_size / 4;
                                        testcard_fillRect(&pixmap, &r, grey);
                                        grey += 0x00010101U * (255 / COL_NUM);
                                }
                        }
                }
                if (!annotate.empty()) {
                        draw_line((char *) data, width * 4, annotate.c_str(), 0xFFFFFFFF, true);
                }
                return generator_depth::bits8;
        }