[deliverable/linux.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 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;
	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			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_set_font(const u8 *f);
void tpg_gen_text(const 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);
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);

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_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];
	}
}


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
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
ba01f673	93	#define TPG_MAX_PLANES 3
63881df9 HV	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;
06d1f0c2	141	unsigned buffers;
63881df9	142	unsigned planes;
02aa769d	143	bool interleaved;
ba01f673 HV	144	u8 vdownsampling[TPG_MAX_PLANES];
ba01f673 HV	145	u8 hdownsampling[TPG_MAX_PLANES];
9991deff HV	146	/*
	147	* horizontal positions must be ANDed with this value to enforce
	148	* correct boundaries for packed YUYV values.
	149	*/
	150	unsigned hmask[TPG_MAX_PLANES];
63881df9 HV	151	/* Used to store the colors in native format, either RGB or YUV */
	152	u8 colors[TPG_COLOR_MAX][3];
	153	u8 textfg[TPG_MAX_PLANES][8], textbg[TPG_MAX_PLANES][8];
	154	/* size in bytes for two pixels in each plane */
	155	unsigned twopixelsize[TPG_MAX_PLANES];
	156	unsigned bytesperline[TPG_MAX_PLANES];
	157
	158	/* Configuration */
	159	enum tpg_pattern pattern;
	160	bool hflip;
	161	bool vflip;
	162	unsigned perc_fill;
	163	bool perc_fill_blank;
	164	bool show_border;
	165	bool show_square;
	166	bool insert_sav;
	167	bool insert_eav;
	168
	169	/* Test pattern movement */
	170	enum tpg_move_mode mv_hor_mode;
	171	int mv_hor_count;
	172	int mv_hor_step;
	173	enum tpg_move_mode mv_vert_mode;
	174	int mv_vert_count;
	175	int mv_vert_step;
	176
	177	bool recalc_colors;
	178	bool recalc_lines;
	179	bool recalc_square_border;
	180
	181	/* Used to store TPG_MAX_PAT_LINES lines, each with up to two planes */
	182	unsigned max_line_width;
	183	u8 *lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
5d7c539e	184	u8 *downsampled_lines[TPG_MAX_PAT_LINES][TPG_MAX_PLANES];
63881df9 HV	185	u8 *random_line[TPG_MAX_PLANES];
	186	u8 *contrast_line[TPG_MAX_PLANES];
	187	u8 *black_line[TPG_MAX_PLANES];
	188	};
	189
	190	void tpg_init(struct tpg_data *tpg, unsigned w, unsigned h);
	191	int tpg_alloc(struct tpg_data *tpg, unsigned max_w);
	192	void tpg_free(struct tpg_data *tpg);
	193	void tpg_reset_source(struct tpg_data *tpg, unsigned width, unsigned height,
	194	u32 field);
	195
	196	void tpg_set_font(const u8 *f);
dfff0489	197	void tpg_gen_text(const struct tpg_data *tpg,
63881df9 HV	198	u8 basep[TPG_MAX_PLANES][2], int y, int x, char text);
	199	void tpg_calc_text_basep(struct tpg_data *tpg,
	200	u8 basep[TPG_MAX_PLANES][2], unsigned p, u8 vbuf);
02aa769d	201	unsigned tpg_g_interleaved_plane(const struct tpg_data *tpg, unsigned buf_line);
dfff0489 HV	202	void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std,
	203	unsigned p, u8 *vbuf);
	204	void tpg_fillbuffer(struct tpg_data *tpg, v4l2_std_id std,
	205	unsigned p, u8 *vbuf);
63881df9 HV	206	bool tpg_s_fourcc(struct tpg_data *tpg, u32 fourcc);
	207	void tpg_s_crop_compose(struct tpg_data tpg, const struct v4l2_rect crop,
	208	const struct v4l2_rect *compose);
	209
	210	static inline void tpg_s_pattern(struct tpg_data *tpg, enum tpg_pattern pattern)
	211	{
	212	if (tpg->pattern == pattern)
	213	return;
	214	tpg->pattern = pattern;
	215	tpg->recalc_colors = true;
	216	}
	217
	218	static inline void tpg_s_quality(struct tpg_data *tpg,
	219	enum tpg_quality qual, unsigned qual_offset)
	220	{
	221	if (tpg->qual == qual && tpg->qual_offset == qual_offset)
	222	return;
	223	tpg->qual = qual;
	224	tpg->qual_offset = qual_offset;
	225	tpg->recalc_colors = true;
	226	}
	227
	228	static inline enum tpg_quality tpg_g_quality(const struct tpg_data *tpg)
	229	{
	230	return tpg->qual;
	231	}
	232
	233	static inline void tpg_s_alpha_component(struct tpg_data *tpg,
	234	u8 alpha_component)
	235	{
	236	if (tpg->alpha_component == alpha_component)
	237	return;
	238	tpg->alpha_component = alpha_component;
	239	tpg->recalc_colors = true;
	240	}
	241
	242	static inline void tpg_s_alpha_mode(struct tpg_data *tpg,
	243	bool red_only)
	244	{
	245	if (tpg->alpha_red_only == red_only)
	246	return;
	247	tpg->alpha_red_only = red_only;
	248	tpg->recalc_colors = true;
	249	}
	250
	251	static inline void tpg_s_brightness(struct tpg_data *tpg,
	252	u8 brightness)
	253	{
	254	if (tpg->brightness == brightness)
	255	return;
	256	tpg->brightness = brightness;
	257	tpg->recalc_colors = true;
	258	}
	259
	260	static inline void tpg_s_contrast(struct tpg_data *tpg,
	261	u8 contrast)
	262	{
	263	if (tpg->contrast == contrast)
	264	return;
	265	tpg->contrast = contrast;
	266	tpg->recalc_colors = true;
	267	}
	268
	269	static inline void tpg_s_saturation(struct tpg_data *tpg,
270	u8 saturation)
271	{
272	if (tpg->saturation == saturation)
273	return;
274	tpg->saturation = saturation;
275	tpg->recalc_colors = true;
276	}
277
278	static inline void tpg_s_hue(struct tpg_data *tpg,
279	s16 hue)
280	{
281	if (tpg->hue == hue)
282	return;
283	tpg->hue = hue;
284	tpg->recalc_colors = true;
285	}
286
287	static inline void tpg_s_rgb_range(struct tpg_data *tpg,
288	unsigned rgb_range)
289	{
290	if (tpg->rgb_range == rgb_range)
291	return;
292	tpg->rgb_range = rgb_range;
293	tpg->recalc_colors = true;
294	}
295
296	static inline void tpg_s_real_rgb_range(struct tpg_data *tpg,
297	unsigned rgb_range)
298	{
299	if (tpg->real_rgb_range == rgb_range)
300	return;
301	tpg->real_rgb_range = rgb_range;
302	tpg->recalc_colors = true;
303	}
304
305	static inline void tpg_s_colorspace(struct tpg_data *tpg, u32 colorspace)
306	{
307	if (tpg->colorspace == colorspace)
308	return;
309	tpg->colorspace = colorspace;
310	tpg->recalc_colors = true;
311	}
312
313	static inline u32 tpg_g_colorspace(const struct tpg_data *tpg)
314	{
315	return tpg->colorspace;
316	}
317
481b97a1 HV	318	static inline void tpg_s_ycbcr_enc(struct tpg_data *tpg, u32 ycbcr_enc)
	319	{
	320	if (tpg->ycbcr_enc == ycbcr_enc)
	321	return;
	322	tpg->ycbcr_enc = ycbcr_enc;
	323	tpg->recalc_colors = true;
	324	}
	325
	326	static inline u32 tpg_g_ycbcr_enc(const struct tpg_data *tpg)
	327	{
	328	return tpg->ycbcr_enc;
	329	}
	330
	331	static inline void tpg_s_quantization(struct tpg_data *tpg, u32 quantization)
	332	{
	333	if (tpg->quantization == quantization)
	334	return;
	335	tpg->quantization = quantization;
	336	tpg->recalc_colors = true;
	337	}
	338
	339	static inline u32 tpg_g_quantization(const struct tpg_data *tpg)
	340	{
	341	return tpg->quantization;
	342	}
	343
06d1f0c2 HV	344	static inline unsigned tpg_g_buffers(const struct tpg_data *tpg)
	345	{
	346	return tpg->buffers;
	347	}
	348
63881df9 HV	349	static inline unsigned tpg_g_planes(const struct tpg_data *tpg)
63881df9 HV	350	{
02aa769d HV	351	return tpg->interleaved ? 1 : tpg->planes;
	352	}
	353
	354	static inline bool tpg_g_interleaved(const struct tpg_data *tpg)
	355	{
	356	return tpg->interleaved;
63881df9 HV	357	}
	358
	359	static inline unsigned tpg_g_twopixelsize(const struct tpg_data *tpg, unsigned plane)
	360	{
	361	return tpg->twopixelsize[plane];
	362	}
	363
9991deff HV	364	static inline unsigned tpg_hdiv(const struct tpg_data *tpg,
	365	unsigned plane, unsigned x)
	366	{
	367	return ((x / tpg->hdownsampling[plane]) & tpg->hmask[plane]) *
	368	tpg->twopixelsize[plane] / 2;
	369	}
	370
	371	static inline unsigned tpg_hscale(const struct tpg_data *tpg, unsigned x)
	372	{
	373	return (x * tpg->scaled_width) / tpg->src_width;
	374	}
	375
	376	static inline unsigned tpg_hscale_div(const struct tpg_data *tpg,
	377	unsigned plane, unsigned x)
	378	{
	379	return tpg_hdiv(tpg, plane, tpg_hscale(tpg, x));
	380	}
	381
63881df9 HV	382	static inline unsigned tpg_g_bytesperline(const struct tpg_data *tpg, unsigned plane)
	383	{
	384	return tpg->bytesperline[plane];
	385	}
	386
	387	static inline void tpg_s_bytesperline(struct tpg_data *tpg, unsigned plane, unsigned bpl)
	388	{
4db22041 HV	389	unsigned p;
	390
	391	if (tpg->buffers > 1) {
	392	tpg->bytesperline[plane] = bpl;
	393	return;
	394	}
	395
02aa769d	396	for (p = 0; p < tpg_g_planes(tpg); p++) {
4db22041 HV	397	unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];
4db22041 HV	398
ba01f673	399	tpg->bytesperline[p] = plane_w / tpg->hdownsampling[p];
4db22041 HV	400	}
	401	}
	402
ba01f673	403
4db22041 HV	404	static inline unsigned tpg_g_line_width(const struct tpg_data *tpg, unsigned plane)
	405	{
	406	unsigned w = 0;
	407	unsigned p;
	408
	409	if (tpg->buffers > 1)
	410	return tpg_g_bytesperline(tpg, plane);
02aa769d	411	for (p = 0; p < tpg_g_planes(tpg); p++) {
4db22041 HV	412	unsigned plane_w = tpg_g_bytesperline(tpg, p);
4db22041 HV	413
ba01f673	414	w += plane_w / tpg->vdownsampling[p];
4db22041 HV	415	}
	416	return w;
	417	}
	418
	419	static inline unsigned tpg_calc_line_width(const struct tpg_data *tpg,
	420	unsigned plane, unsigned bpl)
	421	{
	422	unsigned w = 0;
	423	unsigned p;
	424
	425	if (tpg->buffers > 1)
	426	return bpl;
02aa769d	427	for (p = 0; p < tpg_g_planes(tpg); p++) {
4db22041 HV	428	unsigned plane_w = bpl * tpg->twopixelsize[p] / tpg->twopixelsize[0];
4db22041 HV	429
ba01f673 HV	430	plane_w /= tpg->hdownsampling[p];
ba01f673 HV	431	w += plane_w / tpg->vdownsampling[p];
4db22041 HV	432	}
	433	return w;
	434	}
	435
	436	static inline unsigned tpg_calc_plane_size(const struct tpg_data *tpg, unsigned plane)
	437	{
02aa769d	438	if (plane >= tpg_g_planes(tpg))
4db22041 HV	439	return 0;
4db22041 HV	440
ba01f673 HV	441	return tpg_g_bytesperline(tpg, plane) * tpg->buf_height /
ba01f673 HV	442	tpg->vdownsampling[plane];
63881df9 HV	443	}
	444
	445	static inline void tpg_s_buf_height(struct tpg_data *tpg, unsigned h)
	446	{
	447	tpg->buf_height = h;
	448	}
	449
43047f6b	450	static inline void tpg_s_field(struct tpg_data *tpg, unsigned field, bool alternate)
63881df9 HV	451	{
63881df9 HV	452	tpg->field = field;
43047f6b	453	tpg->field_alternate = alternate;
63881df9 HV	454	}
	455
	456	static inline void tpg_s_perc_fill(struct tpg_data *tpg,
	457	unsigned perc_fill)
	458	{
	459	tpg->perc_fill = perc_fill;
	460	}
	461
	462	static inline unsigned tpg_g_perc_fill(const struct tpg_data *tpg)
	463	{
	464	return tpg->perc_fill;
	465	}
	466
	467	static inline void tpg_s_perc_fill_blank(struct tpg_data *tpg,
	468	bool perc_fill_blank)
	469	{
	470	tpg->perc_fill_blank = perc_fill_blank;
	471	}
	472
	473	static inline void tpg_s_video_aspect(struct tpg_data *tpg,
	474	enum tpg_video_aspect vid_aspect)
	475	{
	476	if (tpg->vid_aspect == vid_aspect)
	477	return;
	478	tpg->vid_aspect = vid_aspect;
	479	tpg->recalc_square_border = true;
	480	}
	481
	482	static inline enum tpg_video_aspect tpg_g_video_aspect(const struct tpg_data *tpg)
	483	{
	484	return tpg->vid_aspect;
	485	}
	486
	487	static inline void tpg_s_pixel_aspect(struct tpg_data *tpg,
	488	enum tpg_pixel_aspect pix_aspect)
	489	{
	490	if (tpg->pix_aspect == pix_aspect)
	491	return;
	492	tpg->pix_aspect = pix_aspect;
	493	tpg->recalc_square_border = true;
	494	}
	495
	496	static inline void tpg_s_show_border(struct tpg_data *tpg,
	497	bool show_border)
	498	{
	499	tpg->show_border = show_border;
	500	}
	501
	502	static inline void tpg_s_show_square(struct tpg_data *tpg,
	503	bool show_square)
	504	{
	505	tpg->show_square = show_square;
	506	}
	507
	508	static inline void tpg_s_insert_sav(struct tpg_data *tpg, bool insert_sav)
	509	{
	510	tpg->insert_sav = insert_sav;
	511	}
	512
	513	static inline void tpg_s_insert_eav(struct tpg_data *tpg, bool insert_eav)
	514	{
	515	tpg->insert_eav = insert_eav;
	516	}
	517
518	void tpg_update_mv_step(struct tpg_data *tpg);
519
520	static inline void tpg_s_mv_hor_mode(struct tpg_data *tpg,
521	enum tpg_move_mode mv_hor_mode)
522	{
523	tpg->mv_hor_mode = mv_hor_mode;
524	tpg_update_mv_step(tpg);
525	}
526
527	static inline void tpg_s_mv_vert_mode(struct tpg_data *tpg,
528	enum tpg_move_mode mv_vert_mode)
529	{
530	tpg->mv_vert_mode = mv_vert_mode;
531	tpg_update_mv_step(tpg);
532	}
533
534	static inline void tpg_init_mv_count(struct tpg_data *tpg)
535	{
536	tpg->mv_hor_count = tpg->mv_vert_count = 0;
537	}
538
539	static inline void tpg_update_mv_count(struct tpg_data *tpg, bool frame_is_field)
540	{
541	tpg->mv_hor_count += tpg->mv_hor_step * (frame_is_field ? 1 : 2);
542	tpg->mv_vert_count += tpg->mv_vert_step * (frame_is_field ? 1 : 2);
543	}
544
545	static inline void tpg_s_hflip(struct tpg_data *tpg, bool hflip)
546	{
547	if (tpg->hflip == hflip)
548	return;
549	tpg->hflip = hflip;
550	tpg_update_mv_step(tpg);
551	tpg->recalc_lines = true;
552	}
553
554	static inline bool tpg_g_hflip(const struct tpg_data *tpg)
555	{
556	return tpg->hflip;
557	}
558
559	static inline void tpg_s_vflip(struct tpg_data *tpg, bool vflip)
560	{
561	tpg->vflip = vflip;
562	}
563
564	static inline bool tpg_g_vflip(const struct tpg_data *tpg)
565	{
566	return tpg->vflip;
567	}
568
569	static inline bool tpg_pattern_is_static(const struct tpg_data *tpg)
570	{
571	return tpg->pattern != TPG_PAT_NOISE &&
572	tpg->mv_hor_mode == TPG_MOVE_NONE &&
573	tpg->mv_vert_mode == TPG_MOVE_NONE;
574	}
575
576	#endif