[media] vivid-tpg: split off the pattern drawing code

The last part of the vivid-tpg refactoring: split off the pattern
drawing code into a function of its own. This greatly improves the
readability and maintainability of this code.
Signed-off-by: Hans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@osg.samsung.com>

drivers/media/platform/vivid/vivid-tpg.c

@@ -1693,57 +1693,21 @@ static void tpg_fill_plane_extras(const struct tpg_data *tpg,
 	}
 }
 
-void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std, unsigned p, u8 *vbuf)
+static void tpg_fill_plane_pattern(const struct tpg_data *tpg,
+				   const struct tpg_draw_params *params,
+				   unsigned p, unsigned h, u8 *vbuf)
 {
-	struct tpg_draw_params params;
-	unsigned mv_hor_old;
-	unsigned mv_hor_new;
-	unsigned mv_vert_old;
-	unsigned mv_vert_new;
-	int h;
-	unsigned twopixsize;
-	unsigned vdiv = tpg->vdownsampling[p];
-	unsigned img_width;
-	unsigned line_offset;
-	unsigned stride;
-	unsigned factor = V4L2_FIELD_HAS_T_OR_B(tpg->field) ? 2 : 1;
-
-	/* Coarse scaling with Bresenham */
-	unsigned int_part = (tpg->crop.height / factor) / tpg->compose.height;
-	unsigned fract_part = (tpg->crop.height / factor) % tpg->compose.height;
-	unsigned src_y = 0;
-	unsigned error = 0;
-
-	tpg_recalc(tpg);
-
-	params.is_tv = std;
-	params.is_60hz = std & V4L2_STD_525_60;
-	params.twopixsize = tpg->twopixelsize[p];
-	params.img_width = tpg_hdiv(tpg, p, tpg->compose.width);
-	params.stride = tpg->bytesperline[p];
-	params.hmax = (tpg->compose.height * tpg->perc_fill) / 100;
-
-	tpg_fill_params_pattern(tpg, p, &params);
-
-	mv_hor_old = params.mv_hor_old;
-	mv_hor_new = params.mv_hor_new;
-	mv_vert_old = params.mv_vert_old;
-	mv_vert_new = params.mv_vert_new;
-
-	tpg_fill_params_extras(tpg, p, &params);
-
-	twopixsize = params.twopixsize;
-	img_width = params.img_width;
-	stride = params.stride;
-
-	vbuf += tpg_hdiv(tpg, p, tpg->compose.left);
-	line_offset = tpg_hscale_div(tpg, p, tpg->crop.left);
-
-	for (h = 0; h < tpg->compose.height; h++) {
+	unsigned twopixsize = params->twopixsize;
+	unsigned img_width = params->img_width;
+	unsigned mv_hor_old = params->mv_hor_old;
+	unsigned mv_hor_new = params->mv_hor_new;
+	unsigned mv_vert_old = params->mv_vert_old;
+	unsigned mv_vert_new = params->mv_vert_new;
+	unsigned frame_line = params->frame_line;
+	unsigned frame_line_next = params->frame_line_next;
+	unsigned line_offset = tpg_hscale_div(tpg, p, tpg->crop.left);
 	bool even;
 	bool fill_blank = false;
-		unsigned frame_line;
-		unsigned buf_line;
 	unsigned pat_line_old;
 	unsigned pat_line_new;
 	u8 *linestart_older;
@@ -1751,48 +1715,20 @@ void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std, unsigned p, u8
 	u8 *linestart_top;
 	u8 *linestart_bottom;
 
-		params.frame_line = tpg_calc_frameline(tpg, src_y, tpg->field);
-		params.frame_line_next = params.frame_line;
-		frame_line = params.frame_line;
 	even = !(frame_line & 1);
-		buf_line = tpg_calc_buffer_line(tpg, h, tpg->field);
-		src_y += int_part;
-		error += fract_part;
-		if (error >= tpg->compose.height) {
-			error -= tpg->compose.height;
-			src_y++;
-		}
-
-		if (vdiv > 1) {
-			/*
-			 * When doing vertical downsampling the field setting
-			 * matters: for SEQ_BT/TB we downsample each field
-			 * separately (i.e. lines 0+2 are combined, as are
-			 * lines 1+3), for the other field settings we combine
-			 * odd and even lines. Doing that for SEQ_BT/TB would
-			 * be really weird.
-			 */
-			if (tpg->field == V4L2_FIELD_SEQ_BT ||
-			    tpg->field == V4L2_FIELD_SEQ_TB) {
-				if ((h & 3) >= 2)
-					continue;
-			} else if (h & 1) {
-				continue;
-			}
-
-			buf_line /= vdiv;
-		}
 
-		if (h >= params.hmax) {
-			if (params.hmax == tpg->compose.height)
-				continue;
+	if (h >= params->hmax) {
+		if (params->hmax == tpg->compose.height)
+			return;
 		if (!tpg->perc_fill_blank)
-				continue;
+			return;
 		fill_blank = true;
 	}
 
-		if (tpg->vflip)
+	if (tpg->vflip) {
 		frame_line = tpg->src_height - frame_line - 1;
+		frame_line_next = tpg->src_height - frame_line_next - 1;
+	}
 
 	if (fill_blank) {
 		linestart_older = tpg->contrast_line[p];
@@ -1820,17 +1756,13 @@ void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std, unsigned p, u8
 		linestart_older = tpg->lines[pat_line_old][p] + mv_hor_old;
 		linestart_newer = tpg->lines[pat_line_new][p] + mv_hor_new;
 
-			if (vdiv > 1) {
-				unsigned frame_line_next;
+		if (tpg->vdownsampling[p] > 1 && frame_line != frame_line_next) {
 			int avg_pat;
 
 			/*
 			 * Now decide whether we need to use downsampled_lines[].
 			 * That's necessary if the two lines use different patterns.
 			 */
-				frame_line_next = tpg_calc_frameline(tpg, src_y, tpg->field);
-				if (tpg->vflip)
-					frame_line_next = tpg->src_height - frame_line_next - 1;
 			pat_line_next_old = tpg_get_pat_line(tpg,
 					(frame_line_next + mv_vert_old) % tpg->src_height);
 			pat_line_next_new = tpg_get_pat_line(tpg,
@@ -1867,7 +1799,7 @@ void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std, unsigned p, u8
 	}
 	if (tpg->field_alternate) {
 		linestart_top = linestart_bottom = linestart_older;
-		} else if (params.is_60hz) {
+	} else if (params->is_60hz) {
 		linestart_top = linestart_newer;
 		linestart_bottom = linestart_older;
 	} else {
@@ -1881,28 +1813,100 @@ void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std, unsigned p, u8
 	case V4L2_FIELD_SEQ_TB:
 	case V4L2_FIELD_SEQ_BT:
 		if (even)
-				memcpy(vbuf + buf_line * stride, linestart_top, img_width);
+			memcpy(vbuf, linestart_top, img_width);
 		else
-				memcpy(vbuf + buf_line * stride, linestart_bottom, img_width);
+			memcpy(vbuf, linestart_bottom, img_width);
 		break;
 	case V4L2_FIELD_INTERLACED_BT:
 		if (even)
-				memcpy(vbuf + buf_line * stride, linestart_bottom, img_width);
+			memcpy(vbuf, linestart_bottom, img_width);
 		else
-				memcpy(vbuf + buf_line * stride, linestart_top, img_width);
+			memcpy(vbuf, linestart_top, img_width);
 		break;
 	case V4L2_FIELD_TOP:
-			memcpy(vbuf + buf_line * stride, linestart_top, img_width);
+		memcpy(vbuf, linestart_top, img_width);
 		break;
 	case V4L2_FIELD_BOTTOM:
-			memcpy(vbuf + buf_line * stride, linestart_bottom, img_width);
+		memcpy(vbuf, linestart_bottom, img_width);
 		break;
 	case V4L2_FIELD_NONE:
 	default:
-			memcpy(vbuf + buf_line * stride, linestart_older, img_width);
+		memcpy(vbuf, linestart_older, img_width);
 		break;
 	}
+}
+
+void tpg_fill_plane_buffer(struct tpg_data *tpg, v4l2_std_id std,
+			   unsigned p, u8 *vbuf)
+{
+	struct tpg_draw_params params;
+	unsigned factor = V4L2_FIELD_HAS_T_OR_B(tpg->field) ? 2 : 1;
+
+	/* Coarse scaling with Bresenham */
+	unsigned int_part = (tpg->crop.height / factor) / tpg->compose.height;
+	unsigned fract_part = (tpg->crop.height / factor) % tpg->compose.height;
+	unsigned src_y = 0;
+	unsigned error = 0;
+	unsigned h;
 
+	tpg_recalc(tpg);
+
+	params.is_tv = std;
+	params.is_60hz = std & V4L2_STD_525_60;
+	params.twopixsize = tpg->twopixelsize[p];
+	params.img_width = tpg_hdiv(tpg, p, tpg->compose.width);
+	params.stride = tpg->bytesperline[p];
+	params.hmax = (tpg->compose.height * tpg->perc_fill) / 100;
+
+	tpg_fill_params_pattern(tpg, p, &params);
+	tpg_fill_params_extras(tpg, p, &params);
+
+	vbuf += tpg_hdiv(tpg, p, tpg->compose.left);
+
+	for (h = 0; h < tpg->compose.height; h++) {
+		unsigned buf_line;
+
+		params.frame_line = tpg_calc_frameline(tpg, src_y, tpg->field);
+		params.frame_line_next = params.frame_line;
+		buf_line = tpg_calc_buffer_line(tpg, h, tpg->field);
+		src_y += int_part;
+		error += fract_part;
+		if (error >= tpg->compose.height) {
+			error -= tpg->compose.height;
+			src_y++;
+		}
+
+		if (tpg->vdownsampling[p] > 1) {
+			/*
+			 * When doing vertical downsampling the field setting
+			 * matters: for SEQ_BT/TB we downsample each field
+			 * separately (i.e. lines 0+2 are combined, as are
+			 * lines 1+3), for the other field settings we combine
+			 * odd and even lines. Doing that for SEQ_BT/TB would
+			 * be really weird.
+			 */
+			if (tpg->field == V4L2_FIELD_SEQ_BT ||
+			    tpg->field == V4L2_FIELD_SEQ_TB) {
+				unsigned next_src_y = src_y;
+
+				if ((h & 3) >= 2)
+					continue;
+				next_src_y += int_part;
+				if (error + fract_part >= tpg->compose.height)
+					next_src_y++;
+				params.frame_line_next =
+					tpg_calc_frameline(tpg, next_src_y, tpg->field);
+			} else {
+				if (h & 1)
+					continue;
+				params.frame_line_next =
+					tpg_calc_frameline(tpg, src_y, tpg->field);
+			}
+
+			buf_line /= tpg->vdownsampling[p];
+		}
+		tpg_fill_plane_pattern(tpg, &params, p, h,
+				vbuf + buf_line * params.stride);
 		tpg_fill_plane_extras(tpg, &params, p, h,
 				vbuf + buf_line * params.stride);
 	}