WebSVN – Kolibri OS – Diff – /drivers/video/Intel-2D/gen6_render.c

  *    Keith Packard
  *    Chris Wilson
+ *
  */
-#ifdef HAVE_CONFIG_H
-#include "config.h"
 #endif
 #include "sna.h"
 #include "sna_reg.h"
 #define NO_FILL 0
 #define NO_FILL_BOXES 0
 #define NO_FILL_ONE 0
 #define NO_FILL_CLEAR 0
-#define NO_RING_SWITCH 1
+#define NO_RING_SWITCH 0
 #define PREFER_RENDER 0
 #define USE_8_PIXEL_DISPATCH 1
 #endif
 #define GEN6_MAX_SIZE 8192
 struct gt_info {
-struct gt_info {
+	const char *name;
 	int max_vs_threads;
 	int max_gs_threads;
 	int max_wm_threads;
 		int max_gs_entries;
 	} urb;
 };
+static const struct gt_info gt1_info = {
-static const struct gt_info gt1_info = {
+	.name = "Sandybridge (gen6, gt1)",
 	.max_vs_threads = 24,
 	.max_gs_threads = 21,
 	.max_wm_threads = 40,
 	.urb = { 32, 256, 256 },
 };
 static const struct gt_info gt2_info = {
-static const struct gt_info gt2_info = {
+	.name = "Sandybridge (gen6, gt2)",
 	.max_vs_threads = 60,
 	.max_gs_threads = 60,
 	.max_wm_threads = 80,
 		return -1;
 	case PICT_a8r8g8b8:
     return GEN6_SURFACEFORMAT_B8G8R8A8_UNORM;
 	case PICT_x8r8g8b8:
 		return GEN6_SURFACEFORMAT_B8G8R8X8_UNORM;
-	case PICT_a8:
-		return GEN6_SURFACEFORMAT_A8_UNORM;
-	};
-/*
-	switch (format) {
-	default:
-		return -1;
-	case PICT_a8r8g8b8:
-		return GEN6_SURFACEFORMAT_B8G8R8A8_UNORM;
-	case PICT_x8r8g8b8:
-		return GEN6_SURFACEFORMAT_B8G8R8X8_UNORM;
 	case PICT_a8b8g8r8:
 		return GEN6_SURFACEFORMAT_R8G8B8A8_UNORM;
 	case PICT_x8b8g8r8:
 		return GEN6_SURFACEFORMAT_R8G8B8X8_UNORM;
 	case PICT_a2r10g10b10:
 	case PICT_a8:
 		return GEN6_SURFACEFORMAT_A8_UNORM;
 	case PICT_a4r4g4b4:
 		return GEN6_SURFACEFORMAT_B4G4R4A4_UNORM;
+	}
- */
+}
 static uint32_t gen6_get_dest_format(PictFormat format)
+{
 gen6_choose_composite_kernel(int op, bool has_mask, bool is_ca, bool is_affine)
+{
 	int base;
-	if (has_mask) {
 	if (has_mask) {
 		if (is_ca) {
 			if (gen6_blend_op[op].src_alpha)
 				base = GEN6_WM_KERNEL_MASKSA;
 			else
 				base = GEN6_WM_KERNEL_MASKCA;
 		} else
-			base = GEN6_WM_KERNEL_MASK;
 			base = GEN6_WM_KERNEL_MASK;
 	} else
 		base = GEN6_WM_KERNEL_NOMASK;
 		const struct sna_composite_op *op,
 		uint16_t wm_binding_table)
+{
 	bool need_stall = wm_binding_table & 1;
+	assert(op->dst.bo->exec);
 	if (gen6_emit_cc(sna, GEN6_BLEND(op->u.gen6.flags)))
 		need_stall = false;
 	gen6_emit_sampler(sna, GEN6_SAMPLER(op->u.gen6.flags));
 	gen6_emit_sf(sna, GEN6_VERTEX(op->u.gen6.flags) >> 2);
 	if (gen6_emit_drawing_rectangle(sna, op))
 		need_stall = false;
 	if (kgem_bo_is_dirty(op->src.bo) || kgem_bo_is_dirty(op->mask.bo)) {
         gen6_emit_flush(sna);
         kgem_clear_dirty(&sna->kgem);
-		if (op->dst.bo->exec)
+		assert(op->dst.bo->exec);
 		kgem_bo_mark_dirty(op->dst.bo);
 		need_stall = false;
+	}
 	if (need_stall) {
 		OUT_BATCH(GEN6_PIPE_CONTROL | (4 - 2));
+}
 static uint32_t
 gen6_tiling_bits(uint32_t tiling)
-{
-    return 0;
 /*
 	switch (tiling) {
 	default: assert(0);
 	case I915_TILING_NONE: return 0;
 	case I915_TILING_X: return GEN6_SURFACE_TILED;
 	case I915_TILING_Y: return GEN6_SURFACE_TILED | GEN6_SURFACE_TILED_Y;
-	}
 */
+}
 /**
 	uint32_t domains;
 	uint16_t offset;
 	uint32_t is_scanout = is_dst && bo->scanout;
 	/* After the first bind, we manage the cache domains within the batch */
-	offset = kgem_bo_get_binding(bo, format | is_scanout << 31);
+	offset = kgem_bo_get_binding(bo, format | is_dst << 30 | is_scanout << 31);
 	if (offset) {
 		DBG(("[%x]  bo(handle=%d), format=%d, reuse %s binding\n",
 		     offset, bo->handle, format,
 		     is_dst ? "render" : "sampler"));
 		sizeof(struct gen6_surface_state_padded) / sizeof(uint32_t);
 	ss = sna->kgem.batch + offset;
 	ss[0] = (GEN6_SURFACE_2D << GEN6_SURFACE_TYPE_SHIFT |
 		 GEN6_SURFACE_BLEND_ENABLED |
 		 format << GEN6_SURFACE_FORMAT_SHIFT);
-	if (is_dst)
+	if (is_dst) {
+		ss[0] |= GEN6_SURFACE_RC_READ_WRITE;
 		domains = I915_GEM_DOMAIN_RENDER << 16 |I915_GEM_DOMAIN_RENDER;
-	else
+	} else
 		domains = I915_GEM_DOMAIN_SAMPLER << 16;
 	ss[1] = kgem_add_reloc(&sna->kgem, offset + 1, bo, domains, 0);
 	ss[2] = ((width - 1)  << GEN6_SURFACE_WIDTH_SHIFT |
 		 (height - 1) << GEN6_SURFACE_HEIGHT_SHIFT);
 	assert(bo->pitch <= (1 << 18));
 	ss[3] = (gen6_tiling_bits(bo->tiling) |
 		 (bo->pitch - 1) << GEN6_SURFACE_PITCH_SHIFT);
 	ss[4] = 0;
-	ss[5] = is_scanout ? 0 : 3 << 16;
+	ss[5] = (is_scanout || bo->io) ? 0 : 3 << 16;
-	kgem_bo_set_binding(bo, format | is_scanout << 31, offset);
+	kgem_bo_set_binding(bo, format | is_dst << 30 | is_scanout << 31, offset);
 	DBG(("[%x] bind bo(handle=%d, addr=%d), format=%d, width=%d, height=%d, pitch=%d, tiling=%d -> %s\n",
 	     offset, bo->handle, ss[1],
 				      int want,
 				      void (*emit_state)(struct sna *, const struct sna_composite_op *op))
+{
 	int rem;
+	assert(want);
 start:
 	rem = vertex_space(sna);
 	if (unlikely(rem < op->floats_per_rect)) {
 		DBG(("flushing vbo for %s: %d < %d\n",
 		     __FUNCTION__, rem, op->floats_per_rect));
 		rem = gen6_get_rectangles__flush(sna, op);
 		if (unlikely(rem == 0))
 			goto flush;
 	}
-	if (unlikely(sna->render.vertex_offset == 0 &&
+	if (unlikely(sna->render.vertex_offset == 0)) {
+		if (!gen6_rectangle_begin(sna, op))
+		goto flush;
+		else
+			goto start;
+	}
 		     !gen6_rectangle_begin(sna, op)))
-		goto flush;
+	assert(rem <= vertex_space(sna));
 	assert(op->floats_per_rect <= rem);
 	if (want > 1 && want * op->floats_per_rect > rem)
 		sna->render_state.gen6.floats_per_vertex = op->floats_per_vertex;
+	}
 	assert((sna->render.vertex_used % op->floats_per_vertex) == 0);
+}
 fastcall static void
 gen6_render_composite_blt(struct sna *sna,
 			  const struct sna_composite_op *op,
 			  const struct sna_composite_rectangles *r)
+{
 	gen6_get_rectangles(sna, op, 1, gen6_emit_composite_state);
 	op->prim_emit(sna, op, r);
+}
 #if 0
 #if 0
 fastcall static void
 gen6_render_composite_box(struct sna *sna,
 			  const struct sna_composite_op *op,
 		sna_vertex_lock(&sna->render);
 		sna_vertex_release__locked(&sna->render);
 	} while (nbox);
 	sna_vertex_unlock(&sna->render);
+}
 #endif
 #ifndef MAX
 #define MAX(a,b) ((a) > (b) ? (a) : (b))
 	return sna_static_stream_offsetof(stream, base);
+}
 #if 0
 #if 0
 static uint32_t gen6_bind_video_source(struct sna *sna,
 				       struct kgem_bo *src_bo,
 				       uint32_t src_offset,
 static bool
 gen6_render_video(struct sna *sna,
 		  struct sna_video *video,
 		  struct sna_video_frame *frame,
 		  RegionPtr dstRegion,
-		  short src_w, short src_h,
-		  short drw_w, short drw_h,
-		  short dx, short dy,
 		  PixmapPtr pixmap)
+{
 	struct sna_composite_op tmp;
+	int dst_width = dstRegion->extents.x2 - dstRegion->extents.x1;
+	int dst_height = dstRegion->extents.y2 - dstRegion->extents.y1;
+	int src_width = frame->src.x2 - frame->src.x1;
+	int src_height = frame->src.y2 - frame->src.y1;
-	int nbox, pix_xoff, pix_yoff;
+	float src_offset_x, src_offset_y;
 	float src_scale_x, src_scale_y;
+	int nbox, pix_xoff, pix_yoff;
 	struct sna_pixmap *priv;
 	unsigned filter;
 	BoxPtr box;
+	DBG(("%s: src=(%d, %d), dst=(%d, %d), %ldx[(%d, %d), (%d, %d)...]\n",
-	DBG(("%s: src=(%d, %d), dst=(%d, %d), %dx[(%d, %d), (%d, %d)...]\n",
+	     __FUNCTION__,
-	     __FUNCTION__, src_w, src_h, drw_w, drw_h,
+	     src_width, src_height, dst_width, dst_height,
-	     REGION_NUM_RECTS(dstRegion),
+	     (long)REGION_NUM_RECTS(dstRegion),
 	     REGION_EXTENTS(NULL, dstRegion)->x1,
 	     REGION_EXTENTS(NULL, dstRegion)->y1,
 	     REGION_EXTENTS(NULL, dstRegion)->x2,
 	tmp.mask.bo = NULL;
 	tmp.floats_per_vertex = 3;
 	tmp.floats_per_rect = 9;
-	if (src_w == drw_w && src_h == drw_h)
+	if (src_width == dst_width && src_height == dst_height)
 		filter = SAMPLER_FILTER_NEAREST;
 	else
 #else
 	pix_xoff = 0;
 	pix_yoff = 0;
 #endif
-	/* Use normalized texture coordinates */
+	src_scale_x = (float)src_width / dst_width / frame->width;
+	src_offset_x = (float)frame->src.x1 / frame->width - dstRegion->extents.x1 * src_scale_x;
-	src_scale_x = ((float)src_w / frame->width) / (float)drw_w;
+	src_scale_y = (float)src_height / dst_height / frame->height;
-	src_scale_y = ((float)src_h / frame->height) / (float)drw_h;
+	src_offset_y = (float)frame->src.y1 / frame->height - dstRegion->extents.y1 * src_scale_y;
 	box = REGION_RECTS(dstRegion);
 	nbox = REGION_NUM_RECTS(dstRegion);
 		r.y2 = box->y2 + pix_yoff;
 		gen6_get_rectangles(sna, &tmp, 1, gen6_emit_video_state);
 		OUT_VERTEX(r.x2, r.y2);
-		OUT_VERTEX_F((box->x2 - dx) * src_scale_x);
+		OUT_VERTEX_F(box->x2 * src_scale_x + src_offset_x);
-		OUT_VERTEX_F((box->y2 - dy) * src_scale_y);
+		OUT_VERTEX_F(box->y2 * src_scale_y + src_offset_y);
 		OUT_VERTEX(r.x1, r.y2);
-		OUT_VERTEX_F((box->x1 - dx) * src_scale_x);
+		OUT_VERTEX_F(box->x1 * src_scale_x + src_offset_x);
-		OUT_VERTEX_F((box->y2 - dy) * src_scale_y);
+		OUT_VERTEX_F(box->y2 * src_scale_y + src_offset_y);
 		OUT_VERTEX(r.x1, r.y1);
-		OUT_VERTEX_F((box->x1 - dx) * src_scale_x);
+		OUT_VERTEX_F(box->x1 * src_scale_x + src_offset_x);
-		OUT_VERTEX_F((box->y1 - dy) * src_scale_y);
+		OUT_VERTEX_F(box->y1 * src_scale_y + src_offset_y);
 		if (!DAMAGE_IS_ALL(priv->gpu_damage)) {
-			sna_damage_add_box(&priv->gpu_damage, &r);
-			sna_damage_subtract_box(&priv->cpu_damage, &r);
+			sna_damage_add_box(&priv->gpu_damage, &r);
 			sna_damage_subtract_box(&priv->cpu_damage, &r);
 		box++;
 	channel->filter = gen6_filter(channel->filter);
 	if (channel->card_format == (unsigned)-1)
 		channel->card_format = gen6_get_card_format(channel->pict_format);
 	assert(channel->card_format != (unsigned)-1);
+}
 #endif
 static void gen6_render_composite_done(struct sna *sna,
                        const struct sna_composite_op *op)
 		gen4_vertex_flush(sna);
         gen6_magic_ca_pass(sna, op);
+    }
 //   sna_render_composite_redirect_done(sna, op);
-}
+}
 #if 0
 #if 0
 static bool
 gen6_composite_set_target(struct sna *sna,
+			  struct sna_composite_op *op,
-			  struct sna_composite_op *op,
+			  PicturePtr dst,
-			  PicturePtr dst,
+			  int x, int y, int w, int h,
-			  int x, int y, int w, int h)
+			  bool partial)
+{
 		return false;
 	return true;
+}
+static bool
+prefer_blt_composite(struct sna *sna, struct sna_composite_op *tmp)
+{
+	if (untiled_tlb_miss(tmp->dst.bo) ||
+	    untiled_tlb_miss(tmp->src.bo))
+		return true;
+	if (kgem_bo_is_render(tmp->dst.bo) ||
+	    kgem_bo_is_render(tmp->src.bo))
+		return false;
+	if (!prefer_blt_ring(sna, tmp->dst.bo, 0))
+		return false;
 	return prefer_blt_bo(sna, tmp->dst.bo) || prefer_blt_bo(sna, tmp->src.bo);
+}
 static bool
 		return false;
     DBG(("%s: %dx%d, current mode=%d\n", __FUNCTION__,
+         width, height, sna->kgem.ring));
+	if (mask == NULL &&
+	    try_blt(sna, dst, src, width, height) &&
+	    sna_blt_composite(sna, op,
+			      src, dst,
+			      src_x, src_y,
+			      dst_x, dst_y,
+			      width, height,
+			      tmp, false))
+		return true;
+	if (gen6_composite_fallback(sna, src, mask, dst))
+		return false;
+	if (need_tiling(sna, width, height))
+		return sna_tiling_composite(op, src, mask, dst,
+					    src_x, src_y,
+					    msk_x, msk_y,
+					    dst_x, dst_y,
+					    width, height,
-         width, height, sna->kgem.ring));
+					    tmp);
 	if (op == PictOpClear)
 		op = PictOpSrc;
 	tmp->op = op;
+	if (!gen6_composite_set_target(sna, tmp, dst,
-	if (!gen6_composite_set_target(sna, tmp, dst,
+				       dst_x, dst_y, width, height,
-				       dst_x, dst_y, width, height))
+				       op > PictOpSrc || dst->pCompositeClip->data))
 		return false;
 					      tmp->dst.format),
 			       gen6_choose_composite_kernel(tmp->op,
 							    tmp->mask.bo != NULL,
 							    tmp->has_component_alpha,
 							    tmp->is_affine),
-			       gen4_choose_composite_emitter(tmp));
+			       gen4_choose_composite_emitter(sna, tmp));
-//	tmp->blt   = gen6_render_composite_blt;
+	tmp->blt   = gen6_render_composite_blt;
-//    tmp->box   = gen6_render_composite_box;
+	tmp->box   = gen6_render_composite_box;
-//	tmp->boxes = gen6_render_composite_boxes__blt;
+	tmp->boxes = gen6_render_composite_boxes__blt;
-//	if (tmp->emit_boxes) {
+	if (tmp->emit_boxes) {
-//		tmp->boxes = gen6_render_composite_boxes;
+		tmp->boxes = gen6_render_composite_boxes;
-//		tmp->thread_boxes = gen6_render_composite_boxes__thread;
+		tmp->thread_boxes = gen6_render_composite_boxes__thread;
 //	}
 	tmp->done  = gen6_render_composite_done;
 	kgem_set_mode(&sna->kgem, KGEM_RENDER, tmp->dst.bo);
 	if (tmp->redirect.real_bo)
 		kgem_bo_destroy(&sna->kgem, tmp->dst.bo);
 	return false;
+}
 #if !NO_COMPOSITE_SPANS
 fastcall static void
 gen6_render_composite_spans_box(struct sna *sna,
 				const struct sna_composite_spans_op *op,
 						  width, height, flags, tmp);
+	}
 	tmp->base.op = op;
 	if (!gen6_composite_set_target(sna, &tmp->base, dst,
-				       dst_x, dst_y, width, height))
+				       dst_x, dst_y, width, height, true))
 		return false;
 	switch (gen6_composite_picture(sna, src, &tmp->base.src,
 					      tmp->base.src.repeat,
 					      SAMPLER_FILTER_NEAREST,
 					      SAMPLER_EXTEND_PAD),
 			       gen6_get_blend(tmp->base.op, false, tmp->base.dst.format),
 			       GEN6_WM_KERNEL_OPACITY | !tmp->base.is_affine,
-			       gen4_choose_spans_emitter(tmp));
+			       gen4_choose_spans_emitter(sna, tmp));
 	tmp->box   = gen6_render_composite_spans_box;
 	tmp->boxes = gen6_render_composite_spans_boxes;
 	if (tmp->emit_boxes)
 		kgem_bo_destroy(&sna->kgem, tmp->base.dst.bo);
 	return false;
+}
 #endif
 static void
 gen6_emit_copy_state(struct sna *sna,
 		     const struct sna_composite_op *op)
+{
+	}
 	gen6_emit_state(sna, op, offset | dirty);
-}
+}
 static inline bool prefer_blt_copy(struct sna *sna,
 				   struct kgem_bo *src_bo,
 				   struct kgem_bo *dst_bo,
 	if (untiled_tlb_miss(src_bo) ||
 	    untiled_tlb_miss(dst_bo))
+		return true;
+	if (kgem_bo_is_render(dst_bo) ||
+	    kgem_bo_is_render(src_bo))
-		return true;
+		return false;
 	if (!prefer_blt_ring(sna, dst_bo, flags))
-		return false;
 		return false;
 	return (prefer_blt_bo(sna, src_bo) >= 0 &&
-		prefer_blt_bo(sna, dst_bo) > 0);
+	return prefer_blt_bo(sna, src_bo) || prefer_blt_bo(sna, dst_bo);
+}
 		if (!sna_render_composite_redirect(sna, &tmp,
 						   extents.x1 + dst_dx,
 						   extents.y1 + dst_dy,
 						   extents.x2 - extents.x1,
+						   extents.y2 - extents.y1,
-						   extents.y2 - extents.y1))
+						   n > 1))
 			goto fallback_tiled;
 	if (too_large(src->drawable.width, src->drawable.height)) {
 		int i;
 		extents = box[0];
 		for (i = 1; i < n; i++) {
-			if (extents.x1 < box[i].x1)
+			if (box[i].x1 < extents.x1)
 				extents.x1 = box[i].x1;
-			if (extents.y1 < box[i].y1)
+			if (box[i].y1 < extents.y1)
 				extents.y1 = box[i].y1;
-			if (extents.x2 > box[i].x2)
+			if (box[i].x2 > extents.x2)
 				extents.x2 = box[i].x2;
-			if (extents.y2 > box[i].y2)
+			if (box[i].y2 > extents.y2)
 				extents.y2 = box[i].y2;
+		}
 	DBG(("%s (alu=%d, src=(%dx%d), dst=(%dx%d))\n",
 	     __FUNCTION__, alu,
 	     src->drawable.width, src->drawable.height,
 	     dst->drawable.width, dst->drawable.height));
+	if (prefer_blt_copy(sna, src_bo, dst_bo, 0) &&
+	    sna_blt_compare_depth(&src->drawable, &dst->drawable) &&
+	    sna_blt_copy(sna, alu,
+			 src_bo, dst_bo,
+			 dst->drawable.bitsPerPixel,
+			 op))
+		return true;
+	if (!(alu == GXcopy || alu == GXclear) || src_bo == dst_bo ||
+	    too_large(src->drawable.width, src->drawable.height) ||
 	    too_large(dst->drawable.width, dst->drawable.height)) {
+fallback:
+		if (!sna_blt_compare_depth(&src->drawable, &dst->drawable))
+			return false;
+		return sna_blt_copy(sna, alu, src_bo, dst_bo,
+				    dst->drawable.bitsPerPixel,
+				    op);
+	}
-fallback:
 	if (dst->drawable.depth == src->drawable.depth) {
+		op->base.dst.format = sna_render_format_for_depth(dst->drawable.depth);
+	op->base.src.pict_format = op->base.dst.format;
+	} else {
+		op->base.dst.format = sna_format_for_depth(dst->drawable.depth);
+		op->base.src.pict_format = sna_format_for_depth(src->drawable.depth);
+	}
-    op->base.dst.format = PIXMAN_a8r8g8b8;
+	if (!gen6_check_format(op->base.src.pict_format))
-	op->base.src.pict_format = op->base.dst.format;
+		goto fallback;
 	op->base.dst.pixmap = dst;
 	op->done = gen6_render_copy_done;
 	return true;
+}
 #endif
-static bool
-gen6_blit_tex(struct sna *sna,
-              uint8_t op, bool scale,
-		      PixmapPtr src, struct kgem_bo *src_bo,
-		      PixmapPtr mask,struct kgem_bo *mask_bo,
-		      PixmapPtr dst, struct kgem_bo *dst_bo,
-              int32_t src_x, int32_t src_y,
-              int32_t msk_x, int32_t msk_y,
-              int32_t dst_x, int32_t dst_y,
-              int32_t width, int32_t height,
-              struct sna_composite_op *tmp)
-{
-    DBG(("%s: %dx%d, current mode=%d\n", __FUNCTION__,
-         width, height, sna->kgem.ring));
-    tmp->op = PictOpSrc;
-    tmp->dst.pixmap = dst;
-    tmp->dst.bo     = dst_bo;
-    tmp->dst.width  = dst->drawable.width;
-    tmp->dst.height = dst->drawable.height;
-    tmp->dst.format = PICT_x8r8g8b8;
-	tmp->src.repeat = SAMPLER_EXTEND_NONE;
-    tmp->src.is_affine = true;
-    tmp->src.bo = src_bo;
-	tmp->src.pict_format = PICT_x8r8g8b8;
-    tmp->src.card_format = gen6_get_card_format(tmp->src.pict_format);
-    tmp->src.width  = src->drawable.width;
-    tmp->src.height = src->drawable.height;
-	if ( (tmp->src.width  == width) &&
-         (tmp->src.height == height) )
-		tmp->src.filter = SAMPLER_FILTER_NEAREST;
-	else
-		tmp->src.filter = SAMPLER_FILTER_BILINEAR;
-	tmp->is_affine = tmp->src.is_affine;
-	tmp->has_component_alpha = false;
-	tmp->need_magic_ca_pass = false;
-	tmp->mask.repeat = SAMPLER_EXTEND_NONE;
-	tmp->mask.filter = SAMPLER_FILTER_NEAREST;
-    tmp->mask.is_affine = true;
-    tmp->mask.bo = mask_bo;
-    tmp->mask.pict_format = PIXMAN_a8;
-    tmp->mask.card_format = gen6_get_card_format(tmp->mask.pict_format);
-    tmp->mask.width  = mask->drawable.width;
-    tmp->mask.height = mask->drawable.height;
-    if( scale )
-    {
-        tmp->src.scale[0] = 1.f/width;
-        tmp->src.scale[1] = 1.f/height;
-    }
-    else
-    {
-        tmp->src.scale[0] = 1.f/src->drawable.width;
-        tmp->src.scale[1] = 1.f/src->drawable.height;
-    }
-//    tmp->src.offset[0] = -dst_x;
-//    tmp->src.offset[1] = -dst_y;
-    tmp->mask.scale[0] = 1.f/mask->drawable.width;
-    tmp->mask.scale[1] = 1.f/mask->drawable.height;
-//    tmp->mask.offset[0] = -dst_x;
-//    tmp->mask.offset[1] = -dst_y;
-	tmp->u.gen6.flags =
-		GEN6_SET_FLAGS(SAMPLER_OFFSET(tmp->src.filter,
-					      tmp->src.repeat,
-					      tmp->mask.filter,
-					      tmp->mask.repeat),
-			       gen6_get_blend(tmp->op,
-					      tmp->has_component_alpha,
-					      tmp->dst.format),
-/*			       gen6_choose_composite_kernel(tmp->op,
-							    tmp->mask.bo != NULL,
-							    tmp->has_component_alpha,
-							    tmp->is_affine),
-*/
-                   GEN6_WM_KERNEL_MASK,
-			       gen4_choose_composite_emitter(tmp));
-	tmp->blt   = gen6_render_composite_blt;
-//    tmp->box   = gen6_render_composite_box;
-	tmp->done  = gen6_render_composite_done;
-	kgem_set_mode(&sna->kgem, KGEM_RENDER, tmp->dst.bo);
-	if (!kgem_check_bo(&sna->kgem,
-			   tmp->dst.bo, tmp->src.bo, tmp->mask.bo,
-			   NULL)) {
-		kgem_submit(&sna->kgem);
-		_kgem_set_mode(&sna->kgem, KGEM_RENDER);
-	}
-    gen6_emit_composite_state(sna, tmp);
-    gen6_align_vertex(sna, tmp);
-	return true;
-}
-#if 0
 #if 0
 static void
 gen6_emit_fill_state(struct sna *sna, const struct sna_composite_op *op)
+{
 	uint32_t *binding_table;
 				   struct kgem_bo *bo)
+{
 	if (PREFER_RENDER)
 		return PREFER_RENDER < 0;
+	if (kgem_bo_is_render(bo))
+		return false;
 	if (untiled_tlb_miss(bo))
+		return true;
+	if (!prefer_blt_ring(sna, bo, 0))
-		return true;
+		return false;
-	return prefer_blt_ring(sna, bo, 0) || prefer_blt_bo(sna, bo) >= 0;
+	return prefer_blt_bo(sna, bo);
+}
 		boxes_extents(box, n, &extents);
 		if (!sna_render_composite_redirect(sna, &tmp,
 						   extents.x1, extents.y1,
 						   extents.x2 - extents.x1,
+						   extents.y2 - extents.y1,
-						   extents.y2 - extents.y1))
+						   n > 1))
 			return sna_tiling_fill_boxes(sna, op, format, color,
 						     dst, dst_bo, box, n);
+	}
     kgem_bo_destroy(&sna->kgem, sna->render_state.gen6.general_bo);
+}
 static bool is_gt2(struct sna *sna)
 {
-	return DEVICE_ID(sna->PciInfo) & 0x30;
+	return sna->PciInfo->device_id & 0x30;
+}
 static bool is_mobile(struct sna *sna)
+{
-	return (DEVICE_ID(sna->PciInfo) & 0xf) == 0x6;
+	return (sna->PciInfo->device_id & 0xf) == 0x6;
+}
     state->general_bo = sna_static_stream_fini(sna, &general);
     return state->general_bo != NULL;
 }
-bool gen6_render_init(struct sna *sna)
+const char *gen6_render_init(struct sna *sna, const char *backend)
 {
     if (!gen6_render_setup(sna))
-		return false;
+		return backend;
+	sna->kgem.context_switch = gen6_render_context_switch;
+	sna->kgem.retire = gen6_render_retire;
-	sna->kgem.context_switch = gen6_render_context_switch;
+	sna->kgem.expire = gen6_render_expire;
-      sna->kgem.retire = gen6_render_retire;
+#if 0
+#if !NO_COMPOSITE
+	sna->render.composite = gen6_render_composite;
-	sna->kgem.expire = gen6_render_expire;
+	sna->render.prefer_gpu |= PREFER_GPU_RENDER;
+#endif
+#if !NO_COMPOSITE_SPANS
+	sna->render.check_composite_spans = gen6_check_composite_spans;
+	sna->render.composite_spans = gen6_render_composite_spans;
+	if (is_mobile(sna))
+		sna->render.prefer_gpu |= PREFER_GPU_SPANS;
+#endif
+	sna->render.video = gen6_render_video;
+#if !NO_COPY_BOXES
+	sna->render.copy_boxes = gen6_render_copy_boxes;
+#endif
+#if !NO_COPY
+	sna->render.copy = gen6_render_copy;
+#endif
+#if !NO_FILL_BOXES
+	sna->render.fill_boxes = gen6_render_fill_boxes;
+#endif
-//    sna->render.composite = gen6_render_composite;
+#if !NO_FILL
+	sna->render.fill = gen6_render_fill;
+#endif
-//    sna->render.video = gen6_render_video;
+#if !NO_FILL_ONE
-//    sna->render.copy_boxes = gen6_render_copy_boxes;
+	sna->render.fill_one = gen6_render_fill_one;
-    sna->render.blit_tex = gen6_blit_tex;
+#endif
 #if !NO_FILL_CLEAR
-//    sna->render.copy = gen6_render_copy;
+	sna->render.clear = gen6_render_clear;
 #endif
-//    sna->render.fill_boxes = gen6_render_fill_boxes;
+#endif
-//    sna->render.fill = gen6_render_fill;
+    sna->render.caps = HW_BIT_BLIT | HW_TEX_BLIT;
-//    sna->render.fill_one = gen6_render_fill_one;
+    sna->render.blit_tex = gen6_blit_tex;
+    sna->render.flush = gen6_render_flush;
+    sna->render.reset = gen6_render_reset;
+	sna->render.fini = gen6_render_fini;
+    sna->render.max_3d_size = GEN6_MAX_SIZE;
+    sna->render.max_3d_pitch = 1 << 18;
+	return sna->render_state.gen6.info->name;
+}
+static bool
+gen6_blit_tex(struct sna *sna,
+              uint8_t op, bool scale,
+		      PixmapPtr src, struct kgem_bo *src_bo,
+		      PixmapPtr mask,struct kgem_bo *mask_bo,
+		      PixmapPtr dst, struct kgem_bo *dst_bo,
+              int32_t src_x, int32_t src_y,
+              int32_t msk_x, int32_t msk_y,
+              int32_t dst_x, int32_t dst_y,
+              int32_t width, int32_t height,
+              struct sna_composite_op *tmp)
+{
+    DBG(("%s: %dx%d, current mode=%d\n", __FUNCTION__,
+         width, height, sna->kgem.ring));
+    tmp->op = PictOpSrc;
+    tmp->dst.pixmap = dst;
+    tmp->dst.bo     = dst_bo;
+    tmp->dst.width  = dst->drawable.width;
+    tmp->dst.height = dst->drawable.height;
+    tmp->dst.format = PICT_x8r8g8b8;
+	tmp->src.repeat = SAMPLER_EXTEND_NONE;
+    tmp->src.is_affine = true;
+    tmp->src.bo = src_bo;
+	tmp->src.pict_format = PICT_x8r8g8b8;
+    tmp->src.card_format = gen6_get_card_format(tmp->src.pict_format);
+    tmp->src.width  = src->drawable.width;
+    tmp->src.height = src->drawable.height;
+	if ( (tmp->src.width  == width) &&
+         (tmp->src.height == height) )
+		tmp->src.filter = SAMPLER_FILTER_NEAREST;
+	else
+		tmp->src.filter = SAMPLER_FILTER_BILINEAR;
+	tmp->is_affine = tmp->src.is_affine;
+	tmp->has_component_alpha = false;
+	tmp->need_magic_ca_pass = false;
+	tmp->mask.repeat = SAMPLER_EXTEND_NONE;
+	tmp->mask.filter = SAMPLER_FILTER_NEAREST;
+    tmp->mask.is_affine = true;
+    tmp->mask.bo = mask_bo;
+    tmp->mask.pict_format = PIXMAN_a8;
+    tmp->mask.card_format = gen6_get_card_format(tmp->mask.pict_format);
+    tmp->mask.width  = mask->drawable.width;
+    tmp->mask.height = mask->drawable.height;
+    if( scale )
+    {
+        tmp->src.scale[0] = 1.f/width;
+        tmp->src.scale[1] = 1.f/height;
+    }
+    else
+    {
+        tmp->src.scale[0] = 1.f/src->drawable.width;
+        tmp->src.scale[1] = 1.f/src->drawable.height;
+    }
+//    tmp->src.offset[0] = -dst_x;
+//    tmp->src.offset[1] = -dst_y;
+    tmp->mask.scale[0] = 1.f/mask->drawable.width;
+    tmp->mask.scale[1] = 1.f/mask->drawable.height;
+//    tmp->mask.offset[0] = -dst_x;
+//    tmp->mask.offset[1] = -dst_y;
+	tmp->u.gen6.flags =
+		GEN6_SET_FLAGS(SAMPLER_OFFSET(tmp->src.filter,
+					      tmp->src.repeat,
+					      tmp->mask.filter,
+					      tmp->mask.repeat),
+			       gen6_get_blend(tmp->op,
+					      tmp->has_component_alpha,
+					      tmp->dst.format),
+/*			       gen6_choose_composite_kernel(tmp->op,
+							    tmp->mask.bo != NULL,
+							    tmp->has_component_alpha,
+							    tmp->is_affine),
+*/
+                   GEN6_WM_KERNEL_MASK,
+			       gen4_choose_composite_emitter(sna, tmp));
 //    sna->render.clear = gen6_render_clear;
+	tmp->blt   = gen6_render_composite_blt;
+//    tmp->box   = gen6_render_composite_box;
+	tmp->done  = gen6_render_composite_done;

Subversion Repositories Kolibri OS

(root)/drivers/video/Intel-2D/gen6_render.c – Rev 3769 → 4251