[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;
	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);
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->planes;
}

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