[mirror_ubuntu-hirsute-kernel.git] / include / media / tpg / v4l2-tpg.h

/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * v4l2-tpg.h - Test Pattern Generator
 *
 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
 */

#ifndef _V4L2_TPG_H_
#define _V4L2_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>

struct tpg_rbg_color8 {
	unsigned char r, g, b;
};

struct tpg_rbg_color16 {
	__u16 r, g, b;
};

enum tpg_color {
	TPG_COLOR_CSC_WHITE,
	TPG_COLOR_CSC_YELLOW,
	TPG_COLOR_CSC_CYAN,
	TPG_COLOR_CSC_GREEN,
	TPG_COLOR_CSC_MAGENTA,
	TPG_COLOR_CSC_RED,
	TPG_COLOR_CSC_BLUE,
	TPG_COLOR_CSC_BLACK,
	TPG_COLOR_75_YELLOW,
	TPG_COLOR_75_CYAN,
	TPG_COLOR_75_GREEN,
	TPG_COLOR_75_MAGENTA,
	TPG_COLOR_75_RED,
	TPG_COLOR_75_BLUE,
	TPG_COLOR_100_WHITE,
	TPG_COLOR_100_YELLOW,
	TPG_COLOR_100_CYAN,
	TPG_COLOR_100_GREEN,
	TPG_COLOR_100_MAGENTA,
	TPG_COLOR_100_RED,
	TPG_COLOR_100_BLUE,
	TPG_COLOR_100_BLACK,
	TPG_COLOR_TEXTFG,
	TPG_COLOR_TEXTBG,
	TPG_COLOR_RANDOM,
	TPG_COLOR_RAMP,
	TPG_COLOR_MAX = TPG_COLOR_RAMP + 256
};

extern const struct tpg_rbg_color8 tpg_colors[TPG_COLOR_MAX];
extern const unsigned short tpg_rec709_to_linear[255 * 16 + 1];
extern const unsigned short tpg_linear_to_rec709[255 * 16 + 1];
extern const struct tpg_rbg_color16 tpg_csc_colors[V4L2_COLORSPACE_DCI_P3 + 1]
					  [V4L2_XFER_FUNC_SMPTE2084 + 1]
					  [TPG_COLOR_CSC_BLACK + 1];
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,
};

enum tgp_color_enc {
	TGP_COLOR_ENC_RGB,
	TGP_COLOR_ENC_YCBCR,
	TGP_COLOR_ENC_HSV,
	TGP_COLOR_ENC_LUMA,
};

extern const char * const tpg_aspect_strings[];

#define TPG_MAX_PLANES 3
#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;
	enum tgp_color_enc		color_enc;
	u32				colorspace;
	u32				xfer_func;
	u32				ycbcr_enc;
	u32				hsv_enc;
	/*
	 * Stores the actual transfer function, i.e. will never be
	 * V4L2_XFER_FUNC_DEFAULT.
	 */
	u32				real_xfer_func;
	/*
	 * Stores the actual Y'CbCr encoding, i.e. will never be
	 * V4L2_YCBCR_ENC_DEFAULT.
	 */
	u32				real_hsv_enc;
	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			buffers;
	unsigned			planes;
	bool				interleaved;
	u8				vdownsampling[TPG_MAX_PLANES];
	u8				hdownsampling[TPG_MAX_PLANES];
	/*
	 * horizontal positions must be ANDed with this value to enforce
	 * correct boundaries for packed YUYV values.
	 */
	unsigned			hmask[TPG_MAX_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				*downsampled_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_log_status(struct tpg_data *tpg);

void tpg_set_font(const u8 *f);
void tpg_gen_text(const struct tpg_data *tpg,
		u8 *basep[TPG_MAX_PLANES][2], int y, int x, const char *text);
void tpg_calc_text_basep(struct tpg_data *tpg,
		u8 *basep[TPG_MAX_PLANES][2], unsigned p, u8 *vbuf);
unsigned tpg_g_interleaved_plane(const struct tpg_data *tpg, unsigned buf_line);
void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std,
			   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);
const char *tpg_g_color_order(const struct tpg_data *tpg);

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)
{
	hue = clamp_t(s16, hue, -128, 128);
	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_hsv_enc(struct tpg_data *tpg, u32 hsv_enc)
{
	if (tpg->hsv_enc == hsv_enc)
		return;
	tpg->hsv_enc = hsv_enc;
	tpg->recalc_colors = true;
}

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

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

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

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_buffers(const struct tpg_data *tpg)
{
	return tpg->buffers;
}

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

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

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

static inline unsigned tpg_hdiv(const struct tpg_data *tpg,
				  unsigned plane, unsigned x)
{
	return ((x / tpg->hdownsampling[plane]) & tpg->hmask[plane]) *
		tpg->twopixelsize[plane] / 2;
}

static inline unsigned tpg_hscale(const struct tpg_data *tpg, unsigned x)
{
	return (x * tpg->scaled_width) / tpg->src_width;
}

static inline unsigned tpg_hscale_div(const struct tpg_data *tpg,
				      unsigned plane, unsigned x)
{
	return tpg_hdiv(tpg, plane, tpg_hscale(tpg, x));
}

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)
{
	unsigned p;

	if (tpg->buffers > 1) {
		tpg->bytesperline[plane] = bpl;
		return;
	}

	for (p = 0; p < tpg_g_planes(tpg); p++) {
		unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];

		tpg->bytesperline[p] = plane_w / tpg->hdownsampling[p];
	}
	if (tpg_g_interleaved(tpg))
		tpg->bytesperline[1] = tpg->bytesperline[0];
}


static inline unsigned tpg_g_line_width(const struct tpg_data *tpg, unsigned plane)
{
	unsigned w = 0;
	unsigned p;

	if (tpg->buffers > 1)
		return tpg_g_bytesperline(tpg, plane);
	for (p = 0; p < tpg_g_planes(tpg); p++) {
		unsigned plane_w = tpg_g_bytesperline(tpg, p);

		w += plane_w / tpg->vdownsampling[p];
	}
	return w;
}

static inline unsigned tpg_calc_line_width(const struct tpg_data *tpg,
					   unsigned plane, unsigned bpl)
{
	unsigned w = 0;
	unsigned p;

	if (tpg->buffers > 1)
		return bpl;
	for (p = 0; p < tpg_g_planes(tpg); p++) {
		unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];

		plane_w /= tpg->hdownsampling[p];
		w += plane_w / tpg->vdownsampling[p];
	}
	return w;
}

static inline unsigned tpg_calc_plane_size(const struct tpg_data *tpg, unsigned plane)
{
	if (plane >= tpg_g_planes(tpg))
		return 0;

	return tpg_g_bytesperline(tpg, plane) * tpg->buf_height /
	       tpg->vdownsampling[plane];
}

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
ab15d248	1	/* SPDX-License-Identifier: GPL-2.0-only */
63881df9	2	/*
e07d46e7	3	* v4l2-tpg.h - Test Pattern Generator
63881df9 HV	4	*
63881df9 HV	5	* Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
63881df9 HV	6	*/
63881df9 HV	7
e07d46e7 HMKF	8	#ifndef _V4L2_TPG_H_
e07d46e7 HMKF	9	#define _V4L2_TPG_H_
63881df9	10
63881df9 HV	11	#include <linux/types.h>
	12	#include <linux/errno.h>
	13	#include <linux/random.h>
	14	#include <linux/slab.h>
5754d0d5	15	#include <linux/vmalloc.h>
63881df9	16	#include <linux/videodev2.h>
63881df9	17
b29fd563	18	struct tpg_rbg_color8 {
1beb623b MCC	19	unsigned char r, g, b;
	20	};
	21
b29fd563	22	struct tpg_rbg_color16 {
43feabdb	23	__u16 r, g, b;
1beb623b MCC	24	};
	25
	26	enum tpg_color {
	27	TPG_COLOR_CSC_WHITE,
	28	TPG_COLOR_CSC_YELLOW,
	29	TPG_COLOR_CSC_CYAN,
	30	TPG_COLOR_CSC_GREEN,
	31	TPG_COLOR_CSC_MAGENTA,
	32	TPG_COLOR_CSC_RED,
	33	TPG_COLOR_CSC_BLUE,
	34	TPG_COLOR_CSC_BLACK,
	35	TPG_COLOR_75_YELLOW,
	36	TPG_COLOR_75_CYAN,
	37	TPG_COLOR_75_GREEN,
	38	TPG_COLOR_75_MAGENTA,
	39	TPG_COLOR_75_RED,
	40	TPG_COLOR_75_BLUE,
	41	TPG_COLOR_100_WHITE,
	42	TPG_COLOR_100_YELLOW,
	43	TPG_COLOR_100_CYAN,
	44	TPG_COLOR_100_GREEN,
	45	TPG_COLOR_100_MAGENTA,
	46	TPG_COLOR_100_RED,
	47	TPG_COLOR_100_BLUE,
	48	TPG_COLOR_100_BLACK,
	49	TPG_COLOR_TEXTFG,
	50	TPG_COLOR_TEXTBG,
	51	TPG_COLOR_RANDOM,
	52	TPG_COLOR_RAMP,
	53	TPG_COLOR_MAX = TPG_COLOR_RAMP + 256
	54	};
	55
b29fd563	56	extern const struct tpg_rbg_color8 tpg_colors[TPG_COLOR_MAX];
1beb623b MCC	57	extern const unsigned short tpg_rec709_to_linear[255 * 16 + 1];
1beb623b MCC	58	extern const unsigned short tpg_linear_to_rec709[255 * 16 + 1];
b29fd563	59	extern const struct tpg_rbg_color16 tpg_csc_colors[V4L2_COLORSPACE_DCI_P3 + 1]
1beb623b MCC	60	[V4L2_XFER_FUNC_SMPTE2084 + 1]
1beb623b MCC	61	[TPG_COLOR_CSC_BLACK + 1];
63881df9 HV	62	enum tpg_pattern {
	63	TPG_PAT_75_COLORBAR,
	64	TPG_PAT_100_COLORBAR,
	65	TPG_PAT_CSC_COLORBAR,
	66	TPG_PAT_100_HCOLORBAR,
	67	TPG_PAT_100_COLORSQUARES,
	68	TPG_PAT_BLACK,
	69	TPG_PAT_WHITE,
	70	TPG_PAT_RED,
	71	TPG_PAT_GREEN,
	72	TPG_PAT_BLUE,
	73	TPG_PAT_CHECKERS_16X16,
1a05d313	74	TPG_PAT_CHECKERS_2X2,
63881df9	75	TPG_PAT_CHECKERS_1X1,
1a05d313 HV	76	TPG_PAT_COLOR_CHECKERS_2X2,
1a05d313 HV	77	TPG_PAT_COLOR_CHECKERS_1X1,
63881df9 HV	78	TPG_PAT_ALTERNATING_HLINES,
	79	TPG_PAT_ALTERNATING_VLINES,
	80	TPG_PAT_CROSS_1_PIXEL,
	81	TPG_PAT_CROSS_2_PIXELS,
	82	TPG_PAT_CROSS_10_PIXELS,
	83	TPG_PAT_GRAY_RAMP,
	84
	85	/* Must be the last pattern */
	86	TPG_PAT_NOISE,
	87	};
	88
	89	extern const char * const tpg_pattern_strings[];
	90
	91	enum tpg_quality {
	92	TPG_QUAL_COLOR,
	93	TPG_QUAL_GRAY,
	94	TPG_QUAL_NOISE
	95	};
	96
	97	enum tpg_video_aspect {
	98	TPG_VIDEO_ASPECT_IMAGE,
	99	TPG_VIDEO_ASPECT_4X3,
	100	TPG_VIDEO_ASPECT_14X9_CENTRE,
	101	TPG_VIDEO_ASPECT_16X9_CENTRE,
	102	TPG_VIDEO_ASPECT_16X9_ANAMORPHIC,
	103	};
	104
	105	enum tpg_pixel_aspect {
	106	TPG_PIXEL_ASPECT_SQUARE,
	107	TPG_PIXEL_ASPECT_NTSC,
	108	TPG_PIXEL_ASPECT_PAL,
	109	};
	110
	111	enum tpg_move_mode {
	112	TPG_MOVE_NEG_FAST,
	113	TPG_MOVE_NEG,
	114	TPG_MOVE_NEG_SLOW,
	115	TPG_MOVE_NONE,
	116	TPG_MOVE_POS_SLOW,
	117	TPG_MOVE_POS,
	118	TPG_MOVE_POS_FAST,
	119	};
	120
646895e9 RR	121	enum tgp_color_enc {
	122	TGP_COLOR_ENC_RGB,
	123	TGP_COLOR_ENC_YCBCR,
54fb1534	124	TGP_COLOR_ENC_HSV,
ca2b32da	125	TGP_COLOR_ENC_LUMA,
646895e9 RR	126	};
646895e9 RR	127
63881df9 HV	128	extern const char * const tpg_aspect_strings[];
63881df9 HV	129
ba01f673	130	#define TPG_MAX_PLANES 3
63881df9 HV	131	#define TPG_MAX_PAT_LINES 8
	132
	133	struct tpg_data {
	134	/* Source frame size */
	135	unsigned src_width, src_height;
	136	/* Buffer height */
	137	unsigned buf_height;
	138	/* Scaled output frame size */
	139	unsigned scaled_width;
	140	u32 field;
43047f6b	141	bool field_alternate;
63881df9 HV	142	/* crop coordinates are frame-based */
	143	struct v4l2_rect crop;
	144	/* compose coordinates are format-based */
	145	struct v4l2_rect compose;
	146	/* border and square coordinates are frame-based */
	147	struct v4l2_rect border;
	148	struct v4l2_rect square;
	149
	150	/* Color-related fields */
	151	enum tpg_quality qual;
	152	unsigned qual_offset;
	153	u8 alpha_component;
	154	bool alpha_red_only;
	155	u8 brightness;
	156	u8 contrast;
	157	u8 saturation;
	158	s16 hue;
	159	u32 fourcc;
646895e9	160	enum tgp_color_enc color_enc;
63881df9	161	u32 colorspace;
ca5316db	162	u32 xfer_func;
481b97a1	163	u32 ycbcr_enc;
429175e4	164	u32 hsv_enc;
ca5316db HV	165	/*
	166	* Stores the actual transfer function, i.e. will never be
	167	* V4L2_XFER_FUNC_DEFAULT.
	168	*/
	169	u32 real_xfer_func;
481b97a1 HV	170	/*
	171	* Stores the actual Y'CbCr encoding, i.e. will never be
	172	* V4L2_YCBCR_ENC_DEFAULT.
	173	*/
429175e4	174	u32 real_hsv_enc;
481b97a1 HV	175	u32 real_ycbcr_enc;
	176	u32 quantization;
	177	/*
	178	* Stores the actual quantization, i.e. will never be
	179	* V4L2_QUANTIZATION_DEFAULT.
	180	*/
	181	u32 real_quantization;
63881df9 HV	182	enum tpg_video_aspect vid_aspect;
	183	enum tpg_pixel_aspect pix_aspect;
	184	unsigned rgb_range;
	185	unsigned real_rgb_range;
06d1f0c2	186	unsigned buffers;
63881df9	187	unsigned planes;
02aa769d	188	bool interleaved;
ba01f673 HV	189	u8 vdownsampling[TPG_MAX_PLANES];
ba01f673 HV	190	u8 hdownsampling[TPG_MAX_PLANES];
9991deff HV	191	/*
	192	* horizontal positions must be ANDed with this value to enforce
	193	* correct boundaries for packed YUYV values.
	194	*/
	195	unsigned hmask[TPG_MAX_PLANES];
63881df9 HV	196	/* Used to store the colors in native format, either RGB or YUV */
	197	u8 colors[TPG_COLOR_MAX][3];
	198	u8 textfg[TPG_MAX_PLANES][8], textbg[TPG_MAX_PLANES][8];
	199	/* size in bytes for two pixels in each plane */
	200	unsigned twopixelsize[TPG_MAX_PLANES];
	201	unsigned bytesperline[TPG_MAX_PLANES];
	202
	203	/* Configuration */
	204	enum tpg_pattern pattern;
	205	bool hflip;
	206	bool vflip;
	207	unsigned perc_fill;
	208	bool perc_fill_blank;
	209	bool show_border;
	210	bool show_square;
	211	bool insert_sav;
	212	bool insert_eav;
	213
	214	/* Test pattern movement */
	215	enum tpg_move_mode mv_hor_mode;
	216	int mv_hor_count;
	217	int mv_hor_step;
	218	enum tpg_move_mode mv_vert_mode;
	219	int mv_vert_count;
	220	int mv_vert_step;
	221
	222	bool recalc_colors;
	223	bool recalc_lines;
	224	bool recalc_square_border;
	225
	226	/* Used to store TPG_MAX_PAT_LINES lines, each with up to two planes */
	227	unsigned max_line_width;
	228	u8 *lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
5d7c539e	229	u8 *downsampled_lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
63881df9 HV	230	u8 *random_line[TPG_MAX_PLANES];
	231	u8 *contrast_line[TPG_MAX_PLANES];
	232	u8 *black_line[TPG_MAX_PLANES];
	233	};
	234
	235	void tpg_init(struct tpg_data *tpg, unsigned w, unsigned h);
	236	int tpg_alloc(struct tpg_data *tpg, unsigned max_w);
	237	void tpg_free(struct tpg_data *tpg);
	238	void tpg_reset_source(struct tpg_data *tpg, unsigned width, unsigned height,
	239	u32 field);
84b76d74	240	void tpg_log_status(struct tpg_data *tpg);
63881df9 HV	241
63881df9 HV	242	void tpg_set_font(const u8 *f);
dfff0489	243	void tpg_gen_text(const struct tpg_data *tpg,
9dc75e79	244	u8 basep[TPG_MAX_PLANES][2], int y, int x, const char text);
63881df9 HV	245	void tpg_calc_text_basep(struct tpg_data *tpg,
63881df9 HV	246	u8 basep[TPG_MAX_PLANES][2], unsigned p, u8 vbuf);
02aa769d	247	unsigned tpg_g_interleaved_plane(const struct tpg_data *tpg, unsigned buf_line);
dfff0489 HV	248	void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std,
	249	unsigned p, u8 *vbuf);
	250	void tpg_fillbuffer(struct tpg_data *tpg, v4l2_std_id std,
	251	unsigned p, u8 *vbuf);
63881df9 HV	252	bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc);
	253	void tpg_s_crop_compose(struct tpg_data tpg, const struct v4l2_rect crop,
	254	const struct v4l2_rect *compose);
7a785081	255	const char tpg_g_color_order(const struct tpg_data tpg);
63881df9 HV	256
	257	static inline void tpg_s_pattern(struct tpg_data *tpg, enum tpg_pattern pattern)
	258	{
	259	if (tpg->pattern == pattern)
	260	return;
	261	tpg->pattern = pattern;
	262	tpg->recalc_colors = true;
	263	}
	264
	265	static inline void tpg_s_quality(struct tpg_data *tpg,
	266	enum tpg_quality qual, unsigned qual_offset)
	267	{
	268	if (tpg->qual == qual && tpg->qual_offset == qual_offset)
	269	return;
	270	tpg->qual = qual;
	271	tpg->qual_offset = qual_offset;
	272	tpg->recalc_colors = true;
	273	}
	274
	275	static inline enum tpg_quality tpg_g_quality(const struct tpg_data *tpg)
	276	{
	277	return tpg->qual;
	278	}
	279
	280	static inline void tpg_s_alpha_component(struct tpg_data *tpg,
	281	u8 alpha_component)
	282	{
	283	if (tpg->alpha_component == alpha_component)
	284	return;
	285	tpg->alpha_component = alpha_component;
	286	tpg->recalc_colors = true;
	287	}
	288
	289	static inline void tpg_s_alpha_mode(struct tpg_data *tpg,
	290	bool red_only)
	291	{
	292	if (tpg->alpha_red_only == red_only)
	293	return;
	294	tpg->alpha_red_only = red_only;
	295	tpg->recalc_colors = true;
	296	}
	297
	298	static inline void tpg_s_brightness(struct tpg_data *tpg,
	299	u8 brightness)
	300	{
	301	if (tpg->brightness == brightness)
	302	return;
	303	tpg->brightness = brightness;
	304	tpg->recalc_colors = true;
	305	}
	306
	307	static inline void tpg_s_contrast(struct tpg_data *tpg,
	308	u8 contrast)
	309	{
	310	if (tpg->contrast == contrast)
	311	return;
	312	tpg->contrast = contrast;
	313	tpg->recalc_colors = true;
	314	}
	315
	316	static inline void tpg_s_saturation(struct tpg_data *tpg,
	317	u8 saturation)
	318	{
	319	if (tpg->saturation == saturation)
320	return;
321	tpg->saturation = saturation;
322	tpg->recalc_colors = true;
323	}
324
325	static inline void tpg_s_hue(struct tpg_data *tpg,
326	s16 hue)
327	{
45c2044c	328	hue = clamp_t(s16, hue, -128, 128);
63881df9 HV	329	if (tpg->hue == hue)
	330	return;
	331	tpg->hue = hue;
	332	tpg->recalc_colors = true;
	333	}
	334
	335	static inline void tpg_s_rgb_range(struct tpg_data *tpg,
	336	unsigned rgb_range)
	337	{
	338	if (tpg->rgb_range == rgb_range)
	339	return;
	340	tpg->rgb_range = rgb_range;
	341	tpg->recalc_colors = true;
	342	}
	343
	344	static inline void tpg_s_real_rgb_range(struct tpg_data *tpg,
	345	unsigned rgb_range)
	346	{
	347	if (tpg->real_rgb_range == rgb_range)
	348	return;
	349	tpg->real_rgb_range = rgb_range;
	350	tpg->recalc_colors = true;
	351	}
	352
	353	static inline void tpg_s_colorspace(struct tpg_data *tpg, u32 colorspace)
	354	{
	355	if (tpg->colorspace == colorspace)
	356	return;
	357	tpg->colorspace = colorspace;
	358	tpg->recalc_colors = true;
	359	}
	360
	361	static inline u32 tpg_g_colorspace(const struct tpg_data *tpg)
	362	{
	363	return tpg->colorspace;
	364	}
	365
481b97a1 HV	366	static inline void tpg_s_ycbcr_enc(struct tpg_data *tpg, u32 ycbcr_enc)
	367	{
	368	if (tpg->ycbcr_enc == ycbcr_enc)
	369	return;
	370	tpg->ycbcr_enc = ycbcr_enc;
	371	tpg->recalc_colors = true;
	372	}
	373
	374	static inline u32 tpg_g_ycbcr_enc(const struct tpg_data *tpg)
	375	{
	376	return tpg->ycbcr_enc;
	377	}
	378
429175e4 RR	379	static inline void tpg_s_hsv_enc(struct tpg_data *tpg, u32 hsv_enc)
	380	{
	381	if (tpg->hsv_enc == hsv_enc)
	382	return;
	383	tpg->hsv_enc = hsv_enc;
	384	tpg->recalc_colors = true;
	385	}
	386
	387	static inline u32 tpg_g_hsv_enc(const struct tpg_data *tpg)
	388	{
	389	return tpg->hsv_enc;
	390	}
	391
ca5316db HV	392	static inline void tpg_s_xfer_func(struct tpg_data *tpg, u32 xfer_func)
	393	{
	394	if (tpg->xfer_func == xfer_func)
	395	return;
	396	tpg->xfer_func = xfer_func;
	397	tpg->recalc_colors = true;
	398	}
	399
	400	static inline u32 tpg_g_xfer_func(const struct tpg_data *tpg)
	401	{
	402	return tpg->xfer_func;
	403	}
	404
481b97a1 HV	405	static inline void tpg_s_quantization(struct tpg_data *tpg, u32 quantization)
	406	{
	407	if (tpg->quantization == quantization)
	408	return;
	409	tpg->quantization = quantization;
	410	tpg->recalc_colors = true;
	411	}
	412
	413	static inline u32 tpg_g_quantization(const struct tpg_data *tpg)
	414	{
	415	return tpg->quantization;
	416	}
	417
06d1f0c2 HV	418	static inline unsigned tpg_g_buffers(const struct tpg_data *tpg)
	419	{
	420	return tpg->buffers;
	421	}
	422
63881df9 HV	423	static inline unsigned tpg_g_planes(const struct tpg_data *tpg)
63881df9 HV	424	{
02aa769d HV	425	return tpg->interleaved ? 1 : tpg->planes;
	426	}
	427
	428	static inline bool tpg_g_interleaved(const struct tpg_data *tpg)
	429	{
	430	return tpg->interleaved;
63881df9 HV	431	}
	432
	433	static inline unsigned tpg_g_twopixelsize(const struct tpg_data *tpg, unsigned plane)
	434	{
	435	return tpg->twopixelsize[plane];
	436	}
	437
9991deff HV	438	static inline unsigned tpg_hdiv(const struct tpg_data *tpg,
	439	unsigned plane, unsigned x)
	440	{
	441	return ((x / tpg->hdownsampling[plane]) & tpg->hmask[plane]) *
	442	tpg->twopixelsize[plane] / 2;
	443	}
	444
	445	static inline unsigned tpg_hscale(const struct tpg_data *tpg, unsigned x)
	446	{
	447	return (x * tpg->scaled_width) / tpg->src_width;
	448	}
	449
	450	static inline unsigned tpg_hscale_div(const struct tpg_data *tpg,
	451	unsigned plane, unsigned x)
	452	{
	453	return tpg_hdiv(tpg, plane, tpg_hscale(tpg, x));
	454	}
	455
63881df9 HV	456	static inline unsigned tpg_g_bytesperline(const struct tpg_data *tpg, unsigned plane)
	457	{
	458	return tpg->bytesperline[plane];
	459	}
	460
	461	static inline void tpg_s_bytesperline(struct tpg_data *tpg, unsigned plane, unsigned bpl)
	462	{
4db22041 HV	463	unsigned p;
	464
	465	if (tpg->buffers > 1) {
	466	tpg->bytesperline[plane] = bpl;
	467	return;
	468	}
	469
02aa769d	470	for (p = 0; p < tpg_g_planes(tpg); p++) {
4db22041 HV	471	unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];
4db22041 HV	472
ba01f673	473	tpg->bytesperline[p] = plane_w / tpg->hdownsampling[p];
4db22041	474	}
3541e349 HV	475	if (tpg_g_interleaved(tpg))
3541e349 HV	476	tpg->bytesperline[1] = tpg->bytesperline[0];
4db22041 HV	477	}
4db22041 HV	478
ba01f673	479
4db22041 HV	480	static inline unsigned tpg_g_line_width(const struct tpg_data *tpg, unsigned plane)
	481	{
	482	unsigned w = 0;
	483	unsigned p;
	484
	485	if (tpg->buffers > 1)
	486	return tpg_g_bytesperline(tpg, plane);
02aa769d	487	for (p = 0; p < tpg_g_planes(tpg); p++) {
4db22041 HV	488	unsigned plane_w = tpg_g_bytesperline(tpg, p);
4db22041 HV	489
ba01f673	490	w += plane_w / tpg->vdownsampling[p];
4db22041 HV	491	}
	492	return w;
	493	}
	494
	495	static inline unsigned tpg_calc_line_width(const struct tpg_data *tpg,
	496	unsigned plane, unsigned bpl)
	497	{
	498	unsigned w = 0;
	499	unsigned p;
	500
	501	if (tpg->buffers > 1)
	502	return bpl;
02aa769d	503	for (p = 0; p < tpg_g_planes(tpg); p++) {
4db22041 HV	504	unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];
4db22041 HV	505
ba01f673 HV	506	plane_w /= tpg->hdownsampling[p];
ba01f673 HV	507	w += plane_w / tpg->vdownsampling[p];
4db22041 HV	508	}
	509	return w;
	510	}
	511
	512	static inline unsigned tpg_calc_plane_size(const struct tpg_data *tpg, unsigned plane)
	513	{
02aa769d	514	if (plane >= tpg_g_planes(tpg))
4db22041 HV	515	return 0;
4db22041 HV	516
ba01f673 HV	517	return tpg_g_bytesperline(tpg, plane) * tpg->buf_height /
ba01f673 HV	518	tpg->vdownsampling[plane];
63881df9 HV	519	}
	520
	521	static inline void tpg_s_buf_height(struct tpg_data *tpg, unsigned h)
	522	{
	523	tpg->buf_height = h;
	524	}
	525
43047f6b	526	static inline void tpg_s_field(struct tpg_data *tpg, unsigned field, bool alternate)
63881df9 HV	527	{
63881df9 HV	528	tpg->field = field;
43047f6b	529	tpg->field_alternate = alternate;
63881df9 HV	530	}
	531
	532	static inline void tpg_s_perc_fill(struct tpg_data *tpg,
	533	unsigned perc_fill)
	534	{
	535	tpg->perc_fill = perc_fill;
	536	}
	537
	538	static inline unsigned tpg_g_perc_fill(const struct tpg_data *tpg)
	539	{
	540	return tpg->perc_fill;
	541	}
	542
	543	static inline void tpg_s_perc_fill_blank(struct tpg_data *tpg,
	544	bool perc_fill_blank)
	545	{
	546	tpg->perc_fill_blank = perc_fill_blank;
	547	}
	548
	549	static inline void tpg_s_video_aspect(struct tpg_data *tpg,
	550	enum tpg_video_aspect vid_aspect)
	551	{
	552	if (tpg->vid_aspect == vid_aspect)
	553	return;
	554	tpg->vid_aspect = vid_aspect;
	555	tpg->recalc_square_border = true;
	556	}
	557
	558	static inline enum tpg_video_aspect tpg_g_video_aspect(const struct tpg_data *tpg)
	559	{
	560	return tpg->vid_aspect;
	561	}
	562
	563	static inline void tpg_s_pixel_aspect(struct tpg_data *tpg,
	564	enum tpg_pixel_aspect pix_aspect)
	565	{
	566	if (tpg->pix_aspect == pix_aspect)
	567	return;
	568	tpg->pix_aspect = pix_aspect;
	569	tpg->recalc_square_border = true;
	570	}
	571
	572	static inline void tpg_s_show_border(struct tpg_data *tpg,
	573	bool show_border)
	574	{
	575	tpg->show_border = show_border;
	576	}
	577
	578	static inline void tpg_s_show_square(struct tpg_data *tpg,
	579	bool show_square)
	580	{
	581	tpg->show_square = show_square;
	582	}
	583
	584	static inline void tpg_s_insert_sav(struct tpg_data *tpg, bool insert_sav)
	585	{
	586	tpg->insert_sav = insert_sav;
	587	}
	588
	589	static inline void tpg_s_insert_eav(struct tpg_data *tpg, bool insert_eav)
	590	{
	591	tpg->insert_eav = insert_eav;
	592	}
	593
594	void tpg_update_mv_step(struct tpg_data *tpg);
595
596	static inline void tpg_s_mv_hor_mode(struct tpg_data *tpg,
597	enum tpg_move_mode mv_hor_mode)
598	{
599	tpg->mv_hor_mode = mv_hor_mode;
600	tpg_update_mv_step(tpg);
601	}
602
603	static inline void tpg_s_mv_vert_mode(struct tpg_data *tpg,
604	enum tpg_move_mode mv_vert_mode)
605	{
606	tpg->mv_vert_mode = mv_vert_mode;
607	tpg_update_mv_step(tpg);
608	}
609
610	static inline void tpg_init_mv_count(struct tpg_data *tpg)
611	{
612	tpg->mv_hor_count = tpg->mv_vert_count = 0;
613	}
614
615	static inline void tpg_update_mv_count(struct tpg_data *tpg, bool frame_is_field)
616	{
617	tpg->mv_hor_count += tpg->mv_hor_step * (frame_is_field ? 1 : 2);
618	tpg->mv_vert_count += tpg->mv_vert_step * (frame_is_field ? 1 : 2);
619	}
620
621	static inline void tpg_s_hflip(struct tpg_data *tpg, bool hflip)
622	{
623	if (tpg->hflip == hflip)
624	return;
625	tpg->hflip = hflip;
626	tpg_update_mv_step(tpg);
627	tpg->recalc_lines = true;
628	}
629
630	static inline bool tpg_g_hflip(const struct tpg_data *tpg)
631	{
632	return tpg->hflip;
633	}
634
635	static inline void tpg_s_vflip(struct tpg_data *tpg, bool vflip)
636	{
637	tpg->vflip = vflip;
638	}
639
640	static inline bool tpg_g_vflip(const struct tpg_data *tpg)
641	{
642	return tpg->vflip;
643	}
644
645	static inline bool tpg_pattern_is_static(const struct tpg_data *tpg)
646	{
647	return tpg->pattern != TPG_PAT_NOISE &&
648	tpg->mv_hor_mode == TPG_MOVE_NONE &&
649	tpg->mv_vert_mode == TPG_MOVE_NONE;
650	}
651
652	#endif