[mirror_ubuntu-bionic-kernel.git] / drivers / media / platform / vivid / vivid-tpg.h

/*
 * vivid-tpg.h - Test Pattern Generator
 *
 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
 *
 * This program is free software; you may redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef _VIVID_TPG_H_
#define _VIVID_TPG_H_

#include <linux/types.h>
#include <linux/errno.h>
#include <linux/random.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/videodev2.h>

#include "vivid-tpg-colors.h"

enum tpg_pattern {
	TPG_PAT_75_COLORBAR,
	TPG_PAT_100_COLORBAR,
	TPG_PAT_CSC_COLORBAR,
	TPG_PAT_100_HCOLORBAR,
	TPG_PAT_100_COLORSQUARES,
	TPG_PAT_BLACK,
	TPG_PAT_WHITE,
	TPG_PAT_RED,
	TPG_PAT_GREEN,
	TPG_PAT_BLUE,
	TPG_PAT_CHECKERS_16X16,
	TPG_PAT_CHECKERS_2X2,
	TPG_PAT_CHECKERS_1X1,
	TPG_PAT_COLOR_CHECKERS_2X2,
	TPG_PAT_COLOR_CHECKERS_1X1,
	TPG_PAT_ALTERNATING_HLINES,
	TPG_PAT_ALTERNATING_VLINES,
	TPG_PAT_CROSS_1_PIXEL,
	TPG_PAT_CROSS_2_PIXELS,
	TPG_PAT_CROSS_10_PIXELS,
	TPG_PAT_GRAY_RAMP,

	/* Must be the last pattern */
	TPG_PAT_NOISE,
};

extern const char * const tpg_pattern_strings[];

enum tpg_quality {
	TPG_QUAL_COLOR,
	TPG_QUAL_GRAY,
	TPG_QUAL_NOISE
};

enum tpg_video_aspect {
	TPG_VIDEO_ASPECT_IMAGE,
	TPG_VIDEO_ASPECT_4X3,
	TPG_VIDEO_ASPECT_14X9_CENTRE,
	TPG_VIDEO_ASPECT_16X9_CENTRE,
	TPG_VIDEO_ASPECT_16X9_ANAMORPHIC,
};

enum tpg_pixel_aspect {
	TPG_PIXEL_ASPECT_SQUARE,
	TPG_PIXEL_ASPECT_NTSC,
	TPG_PIXEL_ASPECT_PAL,
};

enum tpg_move_mode {
	TPG_MOVE_NEG_FAST,
	TPG_MOVE_NEG,
	TPG_MOVE_NEG_SLOW,
	TPG_MOVE_NONE,
	TPG_MOVE_POS_SLOW,
	TPG_MOVE_POS,
	TPG_MOVE_POS_FAST,
};

extern const char * const tpg_aspect_strings[];

#define TPG_MAX_PLANES 2
#define TPG_MAX_PAT_LINES 8

struct tpg_data {
	/* Source frame size */
	unsigned			src_width, src_height;
	/* Buffer height */
	unsigned			buf_height;
	/* Scaled output frame size */
	unsigned			scaled_width;
	u32				field;
	bool				field_alternate;
	/* crop coordinates are frame-based */
	struct v4l2_rect		crop;
	/* compose coordinates are format-based */
	struct v4l2_rect		compose;
	/* border and square coordinates are frame-based */
	struct v4l2_rect		border;
	struct v4l2_rect		square;

	/* Color-related fields */
	enum tpg_quality		qual;
	unsigned			qual_offset;
	u8				alpha_component;
	bool				alpha_red_only;
	u8				brightness;
	u8				contrast;
	u8				saturation;
	s16				hue;
	u32				fourcc;
	bool				is_yuv;
	u32				colorspace;
	u32				ycbcr_enc;
	/*
	 * Stores the actual Y'CbCr encoding, i.e. will never be
	 * V4L2_YCBCR_ENC_DEFAULT.
	 */
	u32				real_ycbcr_enc;
	u32				quantization;
	/*
	 * Stores the actual quantization, i.e. will never be
	 * V4L2_QUANTIZATION_DEFAULT.
	 */
	u32				real_quantization;
	enum tpg_video_aspect		vid_aspect;
	enum tpg_pixel_aspect		pix_aspect;
	unsigned			rgb_range;
	unsigned			real_rgb_range;
	unsigned			planes;
	/* Used to store the colors in native format, either RGB or YUV */
	u8				colors[TPG_COLOR_MAX][3];
	u8				textfg[TPG_MAX_PLANES][8], textbg[TPG_MAX_PLANES][8];
	/* size in bytes for two pixels in each plane */
	unsigned			twopixelsize[TPG_MAX_PLANES];
	unsigned			bytesperline[TPG_MAX_PLANES];

	/* Configuration */
	enum tpg_pattern		pattern;
	bool				hflip;
	bool				vflip;
	unsigned			perc_fill;
	bool				perc_fill_blank;
	bool				show_border;
	bool				show_square;
	bool				insert_sav;
	bool				insert_eav;

	/* Test pattern movement */
	enum tpg_move_mode		mv_hor_mode;
	int				mv_hor_count;
	int				mv_hor_step;
	enum tpg_move_mode		mv_vert_mode;
	int				mv_vert_count;
	int				mv_vert_step;

	bool				recalc_colors;
	bool				recalc_lines;
	bool				recalc_square_border;

	/* Used to store TPG_MAX_PAT_LINES lines, each with up to two planes */
	unsigned			max_line_width;
	u8				*lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
	u8				*random_line[TPG_MAX_PLANES];
	u8				*contrast_line[TPG_MAX_PLANES];
	u8				*black_line[TPG_MAX_PLANES];
};

void tpg_init(struct tpg_data *tpg, unsigned w, unsigned h);
int tpg_alloc(struct tpg_data *tpg, unsigned max_w);
void tpg_free(struct tpg_data *tpg);
void tpg_reset_source(struct tpg_data *tpg, unsigned width, unsigned height,
		       u32 field);

void tpg_set_font(const u8 *f);
void tpg_gen_text(struct tpg_data *tpg,
		u8 *basep[TPG_MAX_PLANES][2], int y, int x, char *text);
void tpg_calc_text_basep(struct tpg_data *tpg,
		u8 *basep[TPG_MAX_PLANES][2], unsigned p, u8 *vbuf);
void tpg_fillbuffer(struct tpg_data *tpg, v4l2_std_id std, unsigned p, u8 *vbuf);
bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc);
void tpg_s_crop_compose(struct tpg_data *tpg, const struct v4l2_rect *crop,
		const struct v4l2_rect *compose);

static inline void tpg_s_pattern(struct tpg_data *tpg, enum tpg_pattern pattern)
{
	if (tpg->pattern == pattern)
		return;
	tpg->pattern = pattern;
	tpg->recalc_colors = true;
}

static inline void tpg_s_quality(struct tpg_data *tpg,
				    enum tpg_quality qual, unsigned qual_offset)
{
	if (tpg->qual == qual && tpg->qual_offset == qual_offset)
		return;
	tpg->qual = qual;
	tpg->qual_offset = qual_offset;
	tpg->recalc_colors = true;
}

static inline enum tpg_quality tpg_g_quality(const struct tpg_data *tpg)
{
	return tpg->qual;
}

static inline void tpg_s_alpha_component(struct tpg_data *tpg,
					    u8 alpha_component)
{
	if (tpg->alpha_component == alpha_component)
		return;
	tpg->alpha_component = alpha_component;
	tpg->recalc_colors = true;
}

static inline void tpg_s_alpha_mode(struct tpg_data *tpg,
					    bool red_only)
{
	if (tpg->alpha_red_only == red_only)
		return;
	tpg->alpha_red_only = red_only;
	tpg->recalc_colors = true;
}

static inline void tpg_s_brightness(struct tpg_data *tpg,
					u8 brightness)
{
	if (tpg->brightness == brightness)
		return;
	tpg->brightness = brightness;
	tpg->recalc_colors = true;
}

static inline void tpg_s_contrast(struct tpg_data *tpg,
					u8 contrast)
{
	if (tpg->contrast == contrast)
		return;
	tpg->contrast = contrast;
	tpg->recalc_colors = true;
}

static inline void tpg_s_saturation(struct tpg_data *tpg,
					u8 saturation)
{
	if (tpg->saturation == saturation)
		return;
	tpg->saturation = saturation;
	tpg->recalc_colors = true;
}

static inline void tpg_s_hue(struct tpg_data *tpg,
					s16 hue)
{
	if (tpg->hue == hue)
		return;
	tpg->hue = hue;
	tpg->recalc_colors = true;
}

static inline void tpg_s_rgb_range(struct tpg_data *tpg,
					unsigned rgb_range)
{
	if (tpg->rgb_range == rgb_range)
		return;
	tpg->rgb_range = rgb_range;
	tpg->recalc_colors = true;
}

static inline void tpg_s_real_rgb_range(struct tpg_data *tpg,
					unsigned rgb_range)
{
	if (tpg->real_rgb_range == rgb_range)
		return;
	tpg->real_rgb_range = rgb_range;
	tpg->recalc_colors = true;
}

static inline void tpg_s_colorspace(struct tpg_data *tpg, u32 colorspace)
{
	if (tpg->colorspace == colorspace)
		return;
	tpg->colorspace = colorspace;
	tpg->recalc_colors = true;
}

static inline u32 tpg_g_colorspace(const struct tpg_data *tpg)
{
	return tpg->colorspace;
}

static inline void tpg_s_ycbcr_enc(struct tpg_data *tpg, u32 ycbcr_enc)
{
	if (tpg->ycbcr_enc == ycbcr_enc)
		return;
	tpg->ycbcr_enc = ycbcr_enc;
	tpg->recalc_colors = true;
}

static inline u32 tpg_g_ycbcr_enc(const struct tpg_data *tpg)
{
	return tpg->ycbcr_enc;
}

static inline void tpg_s_quantization(struct tpg_data *tpg, u32 quantization)
{
	if (tpg->quantization == quantization)
		return;
	tpg->quantization = quantization;
	tpg->recalc_colors = true;
}

static inline u32 tpg_g_quantization(const struct tpg_data *tpg)
{
	return tpg->quantization;
}

static inline unsigned tpg_g_planes(const struct tpg_data *tpg)
{
	return tpg->planes;
}

static inline unsigned tpg_g_twopixelsize(const struct tpg_data *tpg, unsigned plane)
{
	return tpg->twopixelsize[plane];
}

static inline unsigned tpg_g_bytesperline(const struct tpg_data *tpg, unsigned plane)
{
	return tpg->bytesperline[plane];
}

static inline void tpg_s_bytesperline(struct tpg_data *tpg, unsigned plane, unsigned bpl)
{
	tpg->bytesperline[plane] = bpl;
}

static inline void tpg_s_buf_height(struct tpg_data *tpg, unsigned h)
{
	tpg->buf_height = h;
}

static inline void tpg_s_field(struct tpg_data *tpg, unsigned field, bool alternate)
{
	tpg->field = field;
	tpg->field_alternate = alternate;
}

static inline void tpg_s_perc_fill(struct tpg_data *tpg,
				      unsigned perc_fill)
{
	tpg->perc_fill = perc_fill;
}

static inline unsigned tpg_g_perc_fill(const struct tpg_data *tpg)
{
	return tpg->perc_fill;
}

static inline void tpg_s_perc_fill_blank(struct tpg_data *tpg,
					 bool perc_fill_blank)
{
	tpg->perc_fill_blank = perc_fill_blank;
}

static inline void tpg_s_video_aspect(struct tpg_data *tpg,
					enum tpg_video_aspect vid_aspect)
{
	if (tpg->vid_aspect == vid_aspect)
		return;
	tpg->vid_aspect = vid_aspect;
	tpg->recalc_square_border = true;
}

static inline enum tpg_video_aspect tpg_g_video_aspect(const struct tpg_data *tpg)
{
	return tpg->vid_aspect;
}

static inline void tpg_s_pixel_aspect(struct tpg_data *tpg,
					enum tpg_pixel_aspect pix_aspect)
{
	if (tpg->pix_aspect == pix_aspect)
		return;
	tpg->pix_aspect = pix_aspect;
	tpg->recalc_square_border = true;
}

static inline void tpg_s_show_border(struct tpg_data *tpg,
					bool show_border)
{
	tpg->show_border = show_border;
}

static inline void tpg_s_show_square(struct tpg_data *tpg,
					bool show_square)
{
	tpg->show_square = show_square;
}

static inline void tpg_s_insert_sav(struct tpg_data *tpg, bool insert_sav)
{
	tpg->insert_sav = insert_sav;
}

static inline void tpg_s_insert_eav(struct tpg_data *tpg, bool insert_eav)
{
	tpg->insert_eav = insert_eav;
}

void tpg_update_mv_step(struct tpg_data *tpg);

static inline void tpg_s_mv_hor_mode(struct tpg_data *tpg,
				enum tpg_move_mode mv_hor_mode)
{
	tpg->mv_hor_mode = mv_hor_mode;
	tpg_update_mv_step(tpg);
}

static inline void tpg_s_mv_vert_mode(struct tpg_data *tpg,
				enum tpg_move_mode mv_vert_mode)
{
	tpg->mv_vert_mode = mv_vert_mode;
	tpg_update_mv_step(tpg);
}

static inline void tpg_init_mv_count(struct tpg_data *tpg)
{
	tpg->mv_hor_count = tpg->mv_vert_count = 0;
}

static inline void tpg_update_mv_count(struct tpg_data *tpg, bool frame_is_field)
{
	tpg->mv_hor_count += tpg->mv_hor_step * (frame_is_field ? 1 : 2);
	tpg->mv_vert_count += tpg->mv_vert_step * (frame_is_field ? 1 : 2);
}

static inline void tpg_s_hflip(struct tpg_data *tpg, bool hflip)
{
	if (tpg->hflip == hflip)
		return;
	tpg->hflip = hflip;
	tpg_update_mv_step(tpg);
	tpg->recalc_lines = true;
}

static inline bool tpg_g_hflip(const struct tpg_data *tpg)
{
	return tpg->hflip;
}

static inline void tpg_s_vflip(struct tpg_data *tpg, bool vflip)
{
	tpg->vflip = vflip;
}

static inline bool tpg_g_vflip(const struct tpg_data *tpg)
{
	return tpg->vflip;
}

static inline bool tpg_pattern_is_static(const struct tpg_data *tpg)
{
	return tpg->pattern != TPG_PAT_NOISE &&
	       tpg->mv_hor_mode == TPG_MOVE_NONE &&
	       tpg->mv_vert_mode == TPG_MOVE_NONE;
}

#endif
Commit	Line	Data
63881df9 HV	1	/*
	2	* vivid-tpg.h - Test Pattern Generator
	3	*
	4	* Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
	5	*
	6	* This program is free software; you may redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; version 2 of the License.
	9	*
	10	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	11	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	12	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	13	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	14	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	15	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	16	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	17	* SOFTWARE.
	18	*/
	19
	20	#ifndef _VIVID_TPG_H_
	21	#define _VIVID_TPG_H_
	22
63881df9 HV	23	#include <linux/types.h>
	24	#include <linux/errno.h>
	25	#include <linux/random.h>
	26	#include <linux/slab.h>
5754d0d5	27	#include <linux/vmalloc.h>
63881df9 HV	28	#include <linux/videodev2.h>
	29
	30	#include "vivid-tpg-colors.h"
	31
	32	enum tpg_pattern {
	33	TPG_PAT_75_COLORBAR,
	34	TPG_PAT_100_COLORBAR,
	35	TPG_PAT_CSC_COLORBAR,
	36	TPG_PAT_100_HCOLORBAR,
	37	TPG_PAT_100_COLORSQUARES,
	38	TPG_PAT_BLACK,
	39	TPG_PAT_WHITE,
	40	TPG_PAT_RED,
	41	TPG_PAT_GREEN,
	42	TPG_PAT_BLUE,
	43	TPG_PAT_CHECKERS_16X16,
1a05d313	44	TPG_PAT_CHECKERS_2X2,
63881df9	45	TPG_PAT_CHECKERS_1X1,
1a05d313 HV	46	TPG_PAT_COLOR_CHECKERS_2X2,
1a05d313 HV	47	TPG_PAT_COLOR_CHECKERS_1X1,
63881df9 HV	48	TPG_PAT_ALTERNATING_HLINES,
	49	TPG_PAT_ALTERNATING_VLINES,
	50	TPG_PAT_CROSS_1_PIXEL,
	51	TPG_PAT_CROSS_2_PIXELS,
	52	TPG_PAT_CROSS_10_PIXELS,
	53	TPG_PAT_GRAY_RAMP,
	54
	55	/* Must be the last pattern */
	56	TPG_PAT_NOISE,
	57	};
	58
	59	extern const char * const tpg_pattern_strings[];
	60
	61	enum tpg_quality {
	62	TPG_QUAL_COLOR,
	63	TPG_QUAL_GRAY,
	64	TPG_QUAL_NOISE
	65	};
	66
	67	enum tpg_video_aspect {
	68	TPG_VIDEO_ASPECT_IMAGE,
	69	TPG_VIDEO_ASPECT_4X3,
	70	TPG_VIDEO_ASPECT_14X9_CENTRE,
	71	TPG_VIDEO_ASPECT_16X9_CENTRE,
	72	TPG_VIDEO_ASPECT_16X9_ANAMORPHIC,
	73	};
	74
	75	enum tpg_pixel_aspect {
	76	TPG_PIXEL_ASPECT_SQUARE,
	77	TPG_PIXEL_ASPECT_NTSC,
	78	TPG_PIXEL_ASPECT_PAL,
	79	};
	80
	81	enum tpg_move_mode {
	82	TPG_MOVE_NEG_FAST,
	83	TPG_MOVE_NEG,
	84	TPG_MOVE_NEG_SLOW,
	85	TPG_MOVE_NONE,
	86	TPG_MOVE_POS_SLOW,
	87	TPG_MOVE_POS,
	88	TPG_MOVE_POS_FAST,
	89	};
	90
	91	extern const char * const tpg_aspect_strings[];
	92
	93	#define TPG_MAX_PLANES 2
	94	#define TPG_MAX_PAT_LINES 8
	95
	96	struct tpg_data {
	97	/* Source frame size */
	98	unsigned src_width, src_height;
	99	/* Buffer height */
	100	unsigned buf_height;
	101	/* Scaled output frame size */
	102	unsigned scaled_width;
	103	u32 field;
43047f6b	104	bool field_alternate;
63881df9 HV	105	/* crop coordinates are frame-based */
	106	struct v4l2_rect crop;
	107	/* compose coordinates are format-based */
	108	struct v4l2_rect compose;
	109	/* border and square coordinates are frame-based */
	110	struct v4l2_rect border;
	111	struct v4l2_rect square;
	112
	113	/* Color-related fields */
	114	enum tpg_quality qual;
	115	unsigned qual_offset;
	116	u8 alpha_component;
	117	bool alpha_red_only;
	118	u8 brightness;
	119	u8 contrast;
	120	u8 saturation;
	121	s16 hue;
	122	u32 fourcc;
	123	bool is_yuv;
	124	u32 colorspace;
481b97a1 HV	125	u32 ycbcr_enc;
	126	/*
	127	* Stores the actual Y'CbCr encoding, i.e. will never be
	128	* V4L2_YCBCR_ENC_DEFAULT.
	129	*/
	130	u32 real_ycbcr_enc;
	131	u32 quantization;
	132	/*
	133	* Stores the actual quantization, i.e. will never be
	134	* V4L2_QUANTIZATION_DEFAULT.
	135	*/
	136	u32 real_quantization;
63881df9 HV	137	enum tpg_video_aspect vid_aspect;
	138	enum tpg_pixel_aspect pix_aspect;
	139	unsigned rgb_range;
	140	unsigned real_rgb_range;
	141	unsigned planes;
	142	/* Used to store the colors in native format, either RGB or YUV */
	143	u8 colors[TPG_COLOR_MAX][3];
	144	u8 textfg[TPG_MAX_PLANES][8], textbg[TPG_MAX_PLANES][8];
	145	/* size in bytes for two pixels in each plane */
	146	unsigned twopixelsize[TPG_MAX_PLANES];
	147	unsigned bytesperline[TPG_MAX_PLANES];
	148
	149	/* Configuration */
	150	enum tpg_pattern pattern;
	151	bool hflip;
	152	bool vflip;
	153	unsigned perc_fill;
	154	bool perc_fill_blank;
	155	bool show_border;
	156	bool show_square;
	157	bool insert_sav;
	158	bool insert_eav;
	159
	160	/* Test pattern movement */
	161	enum tpg_move_mode mv_hor_mode;
	162	int mv_hor_count;
	163	int mv_hor_step;
	164	enum tpg_move_mode mv_vert_mode;
	165	int mv_vert_count;
	166	int mv_vert_step;
	167
	168	bool recalc_colors;
	169	bool recalc_lines;
	170	bool recalc_square_border;
	171
	172	/* Used to store TPG_MAX_PAT_LINES lines, each with up to two planes */
	173	unsigned max_line_width;
	174	u8 *lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
	175	u8 *random_line[TPG_MAX_PLANES];
	176	u8 *contrast_line[TPG_MAX_PLANES];
	177	u8 *black_line[TPG_MAX_PLANES];
	178	};
	179
	180	void tpg_init(struct tpg_data *tpg, unsigned w, unsigned h);
	181	int tpg_alloc(struct tpg_data *tpg, unsigned max_w);
	182	void tpg_free(struct tpg_data *tpg);
	183	void tpg_reset_source(struct tpg_data *tpg, unsigned width, unsigned height,
	184	u32 field);
	185
	186	void tpg_set_font(const u8 *f);
	187	void tpg_gen_text(struct tpg_data *tpg,
	188	u8 basep[TPG_MAX_PLANES][2], int y, int x, char text);
	189	void tpg_calc_text_basep(struct tpg_data *tpg,
	190	u8 basep[TPG_MAX_PLANES][2], unsigned p, u8 vbuf);
	191	void tpg_fillbuffer(struct tpg_data tpg, v4l2_std_id std, unsigned p, u8 vbuf);
	192	bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc);
	193	void tpg_s_crop_compose(struct tpg_data tpg, const struct v4l2_rect crop,
	194	const struct v4l2_rect *compose);
	195
	196	static inline void tpg_s_pattern(struct tpg_data *tpg, enum tpg_pattern pattern)
	197	{
	198	if (tpg->pattern == pattern)
	199	return;
	200	tpg->pattern = pattern;
201	tpg->recalc_colors = true;
202	}
203
204	static inline void tpg_s_quality(struct tpg_data *tpg,
205	enum tpg_quality qual, unsigned qual_offset)
206	{
207	if (tpg->qual == qual && tpg->qual_offset == qual_offset)
208	return;
209	tpg->qual = qual;
210	tpg->qual_offset = qual_offset;
211	tpg->recalc_colors = true;
212	}
213
214	static inline enum tpg_quality tpg_g_quality(const struct tpg_data *tpg)
215	{
216	return tpg->qual;
217	}
218
219	static inline void tpg_s_alpha_component(struct tpg_data *tpg,
220	u8 alpha_component)
221	{
222	if (tpg->alpha_component == alpha_component)
223	return;
224	tpg->alpha_component = alpha_component;
225	tpg->recalc_colors = true;
226	}
227
228	static inline void tpg_s_alpha_mode(struct tpg_data *tpg,
229	bool red_only)
230	{
231	if (tpg->alpha_red_only == red_only)
232	return;
233	tpg->alpha_red_only = red_only;
234	tpg->recalc_colors = true;
235	}
236
237	static inline void tpg_s_brightness(struct tpg_data *tpg,
238	u8 brightness)
239	{
240	if (tpg->brightness == brightness)
241	return;
242	tpg->brightness = brightness;
243	tpg->recalc_colors = true;
244	}
245
246	static inline void tpg_s_contrast(struct tpg_data *tpg,
247	u8 contrast)
248	{
249	if (tpg->contrast == contrast)
250	return;
251	tpg->contrast = contrast;
252	tpg->recalc_colors = true;
253	}
254
255	static inline void tpg_s_saturation(struct tpg_data *tpg,
256	u8 saturation)
257	{
258	if (tpg->saturation == saturation)
259	return;
260	tpg->saturation = saturation;
261	tpg->recalc_colors = true;
262	}
263
264	static inline void tpg_s_hue(struct tpg_data *tpg,
265	s16 hue)
266	{
267	if (tpg->hue == hue)
268	return;
269	tpg->hue = hue;
270	tpg->recalc_colors = true;
271	}
272
273	static inline void tpg_s_rgb_range(struct tpg_data *tpg,
274	unsigned rgb_range)
275	{
276	if (tpg->rgb_range == rgb_range)
277	return;
278	tpg->rgb_range = rgb_range;
279	tpg->recalc_colors = true;
280	}
281
282	static inline void tpg_s_real_rgb_range(struct tpg_data *tpg,
283	unsigned rgb_range)
284	{
285	if (tpg->real_rgb_range == rgb_range)
286	return;
287	tpg->real_rgb_range = rgb_range;
288	tpg->recalc_colors = true;
289	}
290
291	static inline void tpg_s_colorspace(struct tpg_data *tpg, u32 colorspace)
292	{
293	if (tpg->colorspace == colorspace)
294	return;
295	tpg->colorspace = colorspace;
296	tpg->recalc_colors = true;
297	}
298
299	static inline u32 tpg_g_colorspace(const struct tpg_data *tpg)
300	{
301	return tpg->colorspace;
302	}
303
481b97a1 HV	304	static inline void tpg_s_ycbcr_enc(struct tpg_data *tpg, u32 ycbcr_enc)
	305	{
	306	if (tpg->ycbcr_enc == ycbcr_enc)
	307	return;
	308	tpg->ycbcr_enc = ycbcr_enc;
	309	tpg->recalc_colors = true;
	310	}
	311
	312	static inline u32 tpg_g_ycbcr_enc(const struct tpg_data *tpg)
	313	{
	314	return tpg->ycbcr_enc;
	315	}
	316
	317	static inline void tpg_s_quantization(struct tpg_data *tpg, u32 quantization)
	318	{
	319	if (tpg->quantization == quantization)
	320	return;
	321	tpg->quantization = quantization;
	322	tpg->recalc_colors = true;
	323	}
	324
	325	static inline u32 tpg_g_quantization(const struct tpg_data *tpg)
	326	{
	327	return tpg->quantization;
	328	}
	329
63881df9 HV	330	static inline unsigned tpg_g_planes(const struct tpg_data *tpg)
	331	{
	332	return tpg->planes;
	333	}
	334
	335	static inline unsigned tpg_g_twopixelsize(const struct tpg_data *tpg, unsigned plane)
	336	{
	337	return tpg->twopixelsize[plane];
	338	}
	339
	340	static inline unsigned tpg_g_bytesperline(const struct tpg_data *tpg, unsigned plane)
	341	{
	342	return tpg->bytesperline[plane];
	343	}
	344
	345	static inline void tpg_s_bytesperline(struct tpg_data *tpg, unsigned plane, unsigned bpl)
	346	{
	347	tpg->bytesperline[plane] = bpl;
	348	}
	349
	350	static inline void tpg_s_buf_height(struct tpg_data *tpg, unsigned h)
	351	{
	352	tpg->buf_height = h;
	353	}
	354
43047f6b	355	static inline void tpg_s_field(struct tpg_data *tpg, unsigned field, bool alternate)
63881df9 HV	356	{
63881df9 HV	357	tpg->field = field;
43047f6b	358	tpg->field_alternate = alternate;
63881df9 HV	359	}
	360
	361	static inline void tpg_s_perc_fill(struct tpg_data *tpg,
	362	unsigned perc_fill)
	363	{
	364	tpg->perc_fill = perc_fill;
	365	}
	366
	367	static inline unsigned tpg_g_perc_fill(const struct tpg_data *tpg)
	368	{
	369	return tpg->perc_fill;
	370	}
	371
	372	static inline void tpg_s_perc_fill_blank(struct tpg_data *tpg,
	373	bool perc_fill_blank)
	374	{
	375	tpg->perc_fill_blank = perc_fill_blank;
	376	}
	377
	378	static inline void tpg_s_video_aspect(struct tpg_data *tpg,
	379	enum tpg_video_aspect vid_aspect)
	380	{
	381	if (tpg->vid_aspect == vid_aspect)
	382	return;
	383	tpg->vid_aspect = vid_aspect;
	384	tpg->recalc_square_border = true;
	385	}
	386
	387	static inline enum tpg_video_aspect tpg_g_video_aspect(const struct tpg_data *tpg)
	388	{
	389	return tpg->vid_aspect;
	390	}
	391
	392	static inline void tpg_s_pixel_aspect(struct tpg_data *tpg,
	393	enum tpg_pixel_aspect pix_aspect)
	394	{
	395	if (tpg->pix_aspect == pix_aspect)
	396	return;
	397	tpg->pix_aspect = pix_aspect;
	398	tpg->recalc_square_border = true;
	399	}
	400
	401	static inline void tpg_s_show_border(struct tpg_data *tpg,
	402	bool show_border)
	403	{
	404	tpg->show_border = show_border;
	405	}
	406
	407	static inline void tpg_s_show_square(struct tpg_data *tpg,
	408	bool show_square)
	409	{
	410	tpg->show_square = show_square;
	411	}
	412
	413	static inline void tpg_s_insert_sav(struct tpg_data *tpg, bool insert_sav)
	414	{
	415	tpg->insert_sav = insert_sav;
	416	}
	417
	418	static inline void tpg_s_insert_eav(struct tpg_data *tpg, bool insert_eav)
	419	{
	420	tpg->insert_eav = insert_eav;
	421	}
	422
423	void tpg_update_mv_step(struct tpg_data *tpg);
424
425	static inline void tpg_s_mv_hor_mode(struct tpg_data *tpg,
426	enum tpg_move_mode mv_hor_mode)
427	{
428	tpg->mv_hor_mode = mv_hor_mode;
429	tpg_update_mv_step(tpg);
430	}
431
432	static inline void tpg_s_mv_vert_mode(struct tpg_data *tpg,
433	enum tpg_move_mode mv_vert_mode)
434	{
435	tpg->mv_vert_mode = mv_vert_mode;
436	tpg_update_mv_step(tpg);
437	}
438
439	static inline void tpg_init_mv_count(struct tpg_data *tpg)
440	{
441	tpg->mv_hor_count = tpg->mv_vert_count = 0;
442	}
443
444	static inline void tpg_update_mv_count(struct tpg_data *tpg, bool frame_is_field)
445	{
446	tpg->mv_hor_count += tpg->mv_hor_step * (frame_is_field ? 1 : 2);
447	tpg->mv_vert_count += tpg->mv_vert_step * (frame_is_field ? 1 : 2);
448	}
449
450	static inline void tpg_s_hflip(struct tpg_data *tpg, bool hflip)
451	{
452	if (tpg->hflip == hflip)
453	return;
454	tpg->hflip = hflip;
455	tpg_update_mv_step(tpg);
456	tpg->recalc_lines = true;
457	}
458
459	static inline bool tpg_g_hflip(const struct tpg_data *tpg)
460	{
461	return tpg->hflip;
462	}
463
464	static inline void tpg_s_vflip(struct tpg_data *tpg, bool vflip)
465	{
466	tpg->vflip = vflip;
467	}
468
469	static inline bool tpg_g_vflip(const struct tpg_data *tpg)
470	{
471	return tpg->vflip;
472	}
473
474	static inline bool tpg_pattern_is_static(const struct tpg_data *tpg)
475	{
476	return tpg->pattern != TPG_PAT_NOISE &&
477	tpg->mv_hor_mode == TPG_MOVE_NONE &&
478	tpg->mv_vert_mode == TPG_MOVE_NONE;
479	}
480
481	#endif