Inheritance diagram for interlaced_video_pattern_generator:

Collaboration diagram for interlaced_video_pattern_generator:

Public Member Functions
	interlaced_video_pattern_generator (int w, int h, codec_t color_spec)

char *	get_next () override

Public Member Functions inherited from video_pattern_generator
virtual	~video_pattern_generator ()

Private Attributes
int	cur_idx = 0

vector< char >	data

int	height

size_t	linesize

int	width

Static Private Attributes
static constexpr int	step = 3

Detailed Description

Definition at line 770 of file video_pattern_generator.cpp.

Constructor & Destructor Documentation

◆ interlaced_video_pattern_generator()

interlaced_video_pattern_generator::interlaced_video_pattern_generator	(	int	w,
		int	h,
		codec_t	color_spec )

inline

Definition at line 771 of file video_pattern_generator.cpp.

                : width(w), height(h), linesize(vc_get_linesize(width, color_spec))
        {
                if (width % step != 0) {
                        throw ug_runtime_error(
                            string("[interlaced] width must be divisible by ") +
                            std::to_string(step) + "!");
                }
                size_t rgb_linesize = vc_get_linesize(width, RGB);
                vector<char> rgb(3 * h * rgb_linesize + 4 * (width / step) * rgb_linesize);
                memset(rgb.data(), 255, h * rgb_linesize);
                char *ptr = rgb.data() + h * rgb_linesize;
                auto fill = [&](int col1, int col2) {
                        for (int i = 0; i < width; i += step) {
                                size_t fill_len = rgb_linesize - i * 3;
                                memset(ptr, col1, fill_len);
                                memset(ptr + fill_len, col2, rgb_linesize - fill_len);
                                ptr += rgb_linesize;
                                fill_len = MAX(0, (int) rgb_linesize - (i + 2 * step) * 3);
                                memset(ptr, col1, fill_len);
                                memset(ptr + fill_len, col2, rgb_linesize - fill_len);
                                ptr += rgb_linesize;
                        }
                };
                fill(255, 0);
                memset(ptr, 0, h * rgb_linesize);
                ptr += h * rgb_linesize;
                fill(0, 255);
                memset(ptr, 255, h * rgb_linesize);
                vector<char> rgba(rgb.size() / 3 * 4);
                for (unsigned i = 0; i < rgb.size(); i += 3) {
                        rgba[i / 3 * 4] = rgb[i];
                        rgba[i / 3 * 4 + 1] = rgb[i + 1];
                        rgba[i / 3 * 4 + 2] = rgb[i + 2];
                        rgba[i / 3 * 4 + 3] = 0xff;
                }
                data.resize(3 * h * linesize + 4 * linesize * (w / step) +
                            MAX_PADDING);
                testcard_convert_buffer(RGBA, color_spec, (unsigned char *) data.data(), (unsigned char *) rgba.data(), width, 3 * height + 4 * (width / step));
        }

References data, height, linesize, MAX, MAX_PADDING, RGB, RGBA, step, testcard_convert_buffer(), vc_get_linesize(), and width.

Here is the call graph for this function:

Member Function Documentation

◆ get_next()

char * interlaced_video_pattern_generator::get_next ( )

inlineoverridevirtual

Implements video_pattern_generator.

Definition at line 811 of file video_pattern_generator.cpp.

                                  {
                auto *out = (char *) data.data() + cur_idx * linesize;
                cur_idx += 8;
                if (cur_idx >= 2 * height + 4 * width / step) {
                        cur_idx = 0;
                }
 
                return out;
        }