Update to xf86-video-intel 2.3.1. Tested by many.

1 files changed, 210 insertions, 266 deletions

diff --git a/driver/xf86-video-intel/src/i915_video.c b/driver/xf86-video-intel/src/i915_video.c
index 0833d508d..aeb372930 100644
--- a/driver/xf86-video-intel/src/i915_video.c
+++ b/driver/xf86-video-intel/src/i915_video.c
@@ -39,34 +39,24 @@
 #include "i915_reg.h"
 #include "i915_3d.h"
 
-union intfloat {
-   CARD32 ui;
-   float f;
-};
-
-#define OUT_RING_F(x) do {						\
-   union intfloat _tmp;							\
-   _tmp.f = x;								\
-   OUT_RING(_tmp.ui);							\
-} while (0)
-
-
 void
 I915DisplayVideoTextured(ScrnInfoPtr pScrn, I830PortPrivPtr pPriv, int id,
 			 RegionPtr dstRegion,
 			 short width, short height, int video_pitch,
 			 int x1, int y1, int x2, int y2,
 			 short src_w, short src_h, short drw_w, short drw_h,
-			 DrawablePtr pDraw)
+			 PixmapPtr pPixmap)
 {
    I830Ptr pI830 = I830PTR(pScrn);
-   CARD32 format, ms3, s2;
+   uint32_t format, ms3, s5;
    BoxPtr pbox;
-   int nbox, dxo, dyo;
+   int nbox, dxo, dyo, pix_xoff, pix_yoff;
    Bool planar;
 
+#if 0
    ErrorF("I915DisplayVideo: %dx%d (pitch %d)\n", width, height,
 	  video_pitch);
+#endif
 
    switch (id) {
    case FOURCC_UYVY:
@@ -79,143 +69,97 @@ I915DisplayVideoTextured(ScrnInfoPtr pScrn, I830PortPrivPtr pPriv, int id,
       break;
    default:
       ErrorF("Unknown format 0x%x\n", id);
-      planar = FALSE;
-      break;
+      return;
    }
 
-   /* Tell the rotation code that we have stomped its invariant state by
-    * setting a high bit.  We don't use any invariant 3D state for video, so we
-    * don't have to worry about it ourselves.
-    */
-   *pI830->used3D |= 1 << 30;
-
-   BEGIN_LP_RING(44);
-
-   /* invarient state */
-   OUT_RING(MI_NOOP);
-   OUT_RING(_3DSTATE_AA_CMD |
-	    AA_LINE_ECAAR_WIDTH_ENABLE | AA_LINE_ECAAR_WIDTH_1_0 |
-	    AA_LINE_REGION_WIDTH_ENABLE | AA_LINE_REGION_WIDTH_1_0);
-
-   OUT_RING(_3DSTATE_DFLT_DIFFUSE_CMD);
-   OUT_RING(0x00000000);
+   IntelEmitInvarientState(pScrn);
+   *pI830->last_3d = LAST_3D_VIDEO;
 
-   OUT_RING(_3DSTATE_DFLT_SPEC_CMD);
-   OUT_RING(0x00000000);
-
-   OUT_RING(_3DSTATE_DFLT_Z_CMD);
-   OUT_RING(0x00000000);
-
-   OUT_RING(_3DSTATE_COORD_SET_BINDINGS | CSB_TCB(0, 0) | CSB_TCB(1, 1) |
-	    CSB_TCB(2,2) | CSB_TCB(3,3) | CSB_TCB(4,4) | CSB_TCB(5,5) |
-	    CSB_TCB(6,6) | CSB_TCB(7,7));
-
-   OUT_RING(_3DSTATE_RASTER_RULES_CMD |
-	    ENABLE_TRI_FAN_PROVOKE_VRTX | TRI_FAN_PROVOKE_VRTX(2) |
-	    ENABLE_LINE_STRIP_PROVOKE_VRTX | LINE_STRIP_PROVOKE_VRTX(1) |
-	    ENABLE_TEXKILL_3D_4D | TEXKILL_4D |
-	    ENABLE_POINT_RASTER_RULE | OGL_POINT_RASTER_RULE);
-
-   OUT_RING(_3DSTATE_LOAD_STATE_IMMEDIATE_1 | I1_LOAD_S(3) | 1);
-   OUT_RING(0x00000000); /* texture coordinate wrap */
+   BEGIN_BATCH(20);
 
    /* flush map & render cache */
-   OUT_RING(MI_FLUSH | MI_WRITE_DIRTY_STATE | MI_INVALIDATE_MAP_CACHE);
-   OUT_RING(0x00000000);
+   OUT_BATCH(MI_FLUSH | MI_WRITE_DIRTY_STATE | MI_INVALIDATE_MAP_CACHE);
+   OUT_BATCH(0x00000000);
 
    /* draw rect -- just clipping */
-   OUT_RING(_3DSTATE_DRAW_RECT_CMD);
-   OUT_RING(0x00000000);	/* flags */
-   OUT_RING(0x00000000);	/* ymin, xmin */
-   OUT_RING((pScrn->virtualX - 1) |
-	    (pScrn->virtualY - 1) << 16); /* ymax, xmax */
-   OUT_RING(0x00000000);	/* yorigin, xorigin */
-   OUT_RING(MI_NOOP);
-
-   /* scissor */
-   OUT_RING(_3DSTATE_SCISSOR_ENABLE_CMD | DISABLE_SCISSOR_RECT);
-   OUT_RING(_3DSTATE_SCISSOR_RECT_0_CMD);
-   OUT_RING(0x00000000);	/* ymin, xmin */
-   OUT_RING(0x00000000);	/* ymax, xmax */
-
-   OUT_RING(0x7c000003);	/* unknown command */
-   OUT_RING(0x7d070000);
-   OUT_RING(0x00000000);
-   OUT_RING(0x68000002);
-
-   /* context setup */
-   OUT_RING(_3DSTATE_MODES_4_CMD |
-	    ENABLE_LOGIC_OP_FUNC | LOGIC_OP_FUNC(LOGICOP_COPY) |
-	    ENABLE_STENCIL_WRITE_MASK | STENCIL_WRITE_MASK(0xff) |
-	    ENABLE_STENCIL_TEST_MASK | STENCIL_TEST_MASK(0xff));
-
-   OUT_RING(_3DSTATE_LOAD_STATE_IMMEDIATE_1 | I1_LOAD_S(2) |
-	    I1_LOAD_S(4) | I1_LOAD_S(5) | I1_LOAD_S(6) | 4);
-   s2 = S2_TEXCOORD_FMT(0, TEXCOORDFMT_2D);
-   if (planar)
-      s2 |= S2_TEXCOORD_FMT(1, TEXCOORDFMT_2D);
-   else
-      s2 |= S2_TEXCOORD_FMT(1, TEXCOORDFMT_NOT_PRESENT);
-   s2 |= S2_TEXCOORD_FMT(2, TEXCOORDFMT_NOT_PRESENT) |
-      S2_TEXCOORD_FMT(3, TEXCOORDFMT_NOT_PRESENT) |
-      S2_TEXCOORD_FMT(4, TEXCOORDFMT_NOT_PRESENT) |
-      S2_TEXCOORD_FMT(5, TEXCOORDFMT_NOT_PRESENT) |
-      S2_TEXCOORD_FMT(6, TEXCOORDFMT_NOT_PRESENT) |
-      S2_TEXCOORD_FMT(7, TEXCOORDFMT_NOT_PRESENT);
-   OUT_RING(s2);
-   OUT_RING((1 << S4_POINT_WIDTH_SHIFT) | S4_LINE_WIDTH_ONE |
-	    S4_CULLMODE_NONE | S4_VFMT_XY);
-   OUT_RING(0x00000000); /* S5 - enable bits */
-   OUT_RING((2 << S6_DEPTH_TEST_FUNC_SHIFT) |
-	    (2 << S6_CBUF_SRC_BLEND_FACT_SHIFT) |
-	    (1 << S6_CBUF_DST_BLEND_FACT_SHIFT) | S6_COLOR_WRITE_ENABLE |
-	    (2 << S6_TRISTRIP_PV_SHIFT));
-
-   OUT_RING(_3DSTATE_INDEPENDENT_ALPHA_BLEND_CMD |
-	    IAB_MODIFY_ENABLE |
-	    IAB_MODIFY_FUNC | (BLENDFUNC_ADD << IAB_FUNC_SHIFT) |
-	    IAB_MODIFY_SRC_FACTOR | (BLENDFACT_ONE << IAB_SRC_FACTOR_SHIFT) |
-	    IAB_MODIFY_DST_FACTOR | (BLENDFACT_ZERO << IAB_DST_FACTOR_SHIFT));
-
-   OUT_RING(_3DSTATE_CONST_BLEND_COLOR_CMD);
-   OUT_RING(0x00000000);
-
-   OUT_RING(_3DSTATE_DST_BUF_VARS_CMD);
+   OUT_BATCH(_3DSTATE_DRAW_RECT_CMD);
+   OUT_BATCH(DRAW_DITHER_OFS_X(pPixmap->drawable.x & 3) |
+	     DRAW_DITHER_OFS_Y(pPixmap->drawable.y & 3));
+   OUT_BATCH(0x00000000);	/* ymin, xmin */
+   OUT_BATCH((pPixmap->drawable.width - 1) |
+	     (pPixmap->drawable.height - 1) << 16); /* ymax, xmax */
+   OUT_BATCH(0x00000000);	/* yorigin, xorigin */
+   OUT_BATCH(MI_NOOP);
+
+   OUT_BATCH(_3DSTATE_LOAD_STATE_IMMEDIATE_1 | I1_LOAD_S(2) |
+	     I1_LOAD_S(4) | I1_LOAD_S(5) | I1_LOAD_S(6) | 3);
+   OUT_BATCH(S2_TEXCOORD_FMT(0, TEXCOORDFMT_2D) |
+	     S2_TEXCOORD_FMT(1, TEXCOORDFMT_NOT_PRESENT) |
+	     S2_TEXCOORD_FMT(2, TEXCOORDFMT_NOT_PRESENT) |
+	     S2_TEXCOORD_FMT(3, TEXCOORDFMT_NOT_PRESENT) |
+	     S2_TEXCOORD_FMT(4, TEXCOORDFMT_NOT_PRESENT) |
+	     S2_TEXCOORD_FMT(5, TEXCOORDFMT_NOT_PRESENT) |
+	     S2_TEXCOORD_FMT(6, TEXCOORDFMT_NOT_PRESENT) |
+	     S2_TEXCOORD_FMT(7, TEXCOORDFMT_NOT_PRESENT));
+   OUT_BATCH((1 << S4_POINT_WIDTH_SHIFT) | S4_LINE_WIDTH_ONE |
+	     S4_CULLMODE_NONE | S4_VFMT_XY);
+   s5 = 0x0;
+   if (pI830->cpp == 2)
+      s5 |= S5_COLOR_DITHER_ENABLE;
+   OUT_BATCH(s5); /* S5 - enable bits */
+   OUT_BATCH((2 << S6_DEPTH_TEST_FUNC_SHIFT) |
+	     (2 << S6_CBUF_SRC_BLEND_FACT_SHIFT) |
+	     (1 << S6_CBUF_DST_BLEND_FACT_SHIFT) | S6_COLOR_WRITE_ENABLE |
+	     (2 << S6_TRISTRIP_PV_SHIFT));
+
+   OUT_BATCH(_3DSTATE_CONST_BLEND_COLOR_CMD);
+   OUT_BATCH(0x00000000);
+
+   OUT_BATCH(_3DSTATE_DST_BUF_VARS_CMD);
    if (pI830->cpp == 2)
       format = COLR_BUF_RGB565;
    else
       format = COLR_BUF_ARGB8888 | DEPTH_FRMT_24_FIXED_8_OTHER;
 
-   OUT_RING(LOD_PRECLAMP_OGL |
-     DSTORG_HORT_BIAS(0x80) | DSTORG_VERT_BIAS(0x80) | format);
-
-   OUT_RING(_3DSTATE_STIPPLE);
-   OUT_RING(0x00000000);
+   OUT_BATCH(LOD_PRECLAMP_OGL |
+	     DSTORG_HORT_BIAS(0x80) |
+	     DSTORG_VERT_BIAS(0x80) |
+	     format);
 
    /* front buffer, pitch, offset */
-   OUT_RING(_3DSTATE_BUF_INFO_CMD);
-   OUT_RING(BUF_3D_ID_COLOR_BACK | BUF_3D_USE_FENCE |
-	    (((pI830->displayWidth * pI830->cpp) / 4) << 2));
-   OUT_RING(pI830->bufferOffset);
-   ADVANCE_LP_RING();
+   OUT_BATCH(_3DSTATE_BUF_INFO_CMD);
+   OUT_BATCH(BUF_3D_ID_COLOR_BACK | BUF_3D_USE_FENCE |
+	     BUF_3D_PITCH(intel_get_pixmap_pitch(pPixmap)));
+   OUT_BATCH(BUF_3D_ADDR(intel_get_pixmap_offset(pPixmap)));
+   ADVANCE_BATCH();
 
    if (!planar) {
-      FS_LOCALS(3);
-
-      BEGIN_LP_RING(10);
-      OUT_RING(_3DSTATE_SAMPLER_STATE | 3);
-      OUT_RING(0x00000001);
-      OUT_RING(SS2_COLORSPACE_CONVERSION |
-	       (FILTER_LINEAR << SS2_MAG_FILTER_SHIFT) |
-	       (FILTER_LINEAR << SS2_MIN_FILTER_SHIFT));
-      OUT_RING((TEXCOORDMODE_CLAMP_EDGE << SS3_TCX_ADDR_MODE_SHIFT) |
-	       (TEXCOORDMODE_CLAMP_EDGE << SS3_TCY_ADDR_MODE_SHIFT));
-      OUT_RING(0x00000000);
-
-      OUT_RING(_3DSTATE_MAP_STATE | 3);
-      OUT_RING(0x00000001);	/* texture map #1 */
-      OUT_RING(pPriv->YBuf0offset);
-      ms3 = MAPSURF_422;
+      FS_LOCALS(10);
+
+      BEGIN_BATCH(16);
+      OUT_BATCH(_3DSTATE_PIXEL_SHADER_CONSTANTS | 4);
+      OUT_BATCH(0x0000001);	/* constant 0 */
+      /* constant 0: brightness/contrast */
+      OUT_BATCH_F(pPriv->brightness / 128.0);
+      OUT_BATCH_F(pPriv->contrast / 255.0);
+      OUT_BATCH_F(0.0);
+      OUT_BATCH_F(0.0);
+
+      OUT_BATCH(_3DSTATE_SAMPLER_STATE | 3);
+      OUT_BATCH(0x00000001);
+      OUT_BATCH(SS2_COLORSPACE_CONVERSION |
+		(FILTER_LINEAR << SS2_MAG_FILTER_SHIFT) |
+		(FILTER_LINEAR << SS2_MIN_FILTER_SHIFT));
+      OUT_BATCH((TEXCOORDMODE_CLAMP_EDGE << SS3_TCX_ADDR_MODE_SHIFT) |
+		(TEXCOORDMODE_CLAMP_EDGE << SS3_TCY_ADDR_MODE_SHIFT) |
+		(0 << SS3_TEXTUREMAP_INDEX_SHIFT) |
+		SS3_NORMALIZED_COORDS);
+      OUT_BATCH(0x00000000);
+
+      OUT_BATCH(_3DSTATE_MAP_STATE | 3);
+      OUT_BATCH(0x00000001);	/* texture map #1 */
+      OUT_BATCH(pPriv->YBuf0offset);
+      ms3 = MAPSURF_422 | MS3_USE_FENCE_REGS;
       switch (id) {
       case FOURCC_YUY2:
 	 ms3 |= MT_422_YCRCB_NORMAL;
@@ -226,22 +170,25 @@ I915DisplayVideoTextured(ScrnInfoPtr pScrn, I830PortPrivPtr pPriv, int id,
       }
       ms3 |= (height - 1) << MS3_HEIGHT_SHIFT;
       ms3 |= (width - 1) << MS3_WIDTH_SHIFT;
-      if (!pI830->disableTiling)
-	 ms3 |= MS3_USE_FENCE_REGS;
-      OUT_RING(ms3);
-      OUT_RING(((video_pitch / 4) - 1) << 21);
-      ADVANCE_LP_RING();
+      OUT_BATCH(ms3);
+      OUT_BATCH(((video_pitch / 4) - 1) << MS4_PITCH_SHIFT);
+
+      ADVANCE_BATCH();
 
       FS_BEGIN();
       i915_fs_dcl(FS_S0);
       i915_fs_dcl(FS_T0);
       i915_fs_texld(FS_OC, FS_S0, FS_T0);
+      if (pPriv->brightness != 0) {
+	  i915_fs_add(FS_OC,
+		      i915_fs_operand_reg(FS_OC),
+		      i915_fs_operand(FS_C0, X, X, X, ZERO));
+      }
       FS_END();
    } else {
       FS_LOCALS(16);
 
-      BEGIN_LP_RING(1 + 18 + 11 + 11);
-      OUT_RING(MI_NOOP);
+      BEGIN_BATCH(22 + 11 + 11);
       /* For the planar formats, we set up three samplers -- one for each plane,
        * in a Y8 format.  Because I couldn't get the special PLANAR_TO_PACKED
        * shader setup to work, I did the manual pixel shader:
@@ -261,87 +208,95 @@ I915DisplayVideoTextured(ScrnInfoPtr pScrn, I830PortPrivPtr pPriv, int id,
        * r3 = (v,v,v,v)
        * OC = (r,g,b,1)
        */
-      OUT_RING(_3DSTATE_PIXEL_SHADER_CONSTANTS | 16);
-      OUT_RING(0x000000f);	/* constants 0-3 */
+      OUT_BATCH(_3DSTATE_PIXEL_SHADER_CONSTANTS | (22 - 2));
+      OUT_BATCH(0x000001f);	/* constants 0-4 */
       /* constant 0: normalization offsets */
-      OUT_RING_F(-0.0625);
-      OUT_RING_F(-0.5);
-      OUT_RING_F(-0.5);
-      OUT_RING_F(0.0);
+      OUT_BATCH_F(-0.0625);
+      OUT_BATCH_F(-0.5);
+      OUT_BATCH_F(-0.5);
+      OUT_BATCH_F(0.0);
       /* constant 1: r coefficients*/
-      OUT_RING_F(1.1643);
-      OUT_RING_F(0.0);
-      OUT_RING_F(1.5958);
-      OUT_RING_F(0.0);
+      OUT_BATCH_F(1.1643);
+      OUT_BATCH_F(0.0);
+      OUT_BATCH_F(1.5958);
+      OUT_BATCH_F(0.0);
       /* constant 2: g coefficients */
-      OUT_RING_F(1.1643);
-      OUT_RING_F(-0.39173);
-      OUT_RING_F(-0.81290);
-      OUT_RING_F(0.0);
+      OUT_BATCH_F(1.1643);
+      OUT_BATCH_F(-0.39173);
+      OUT_BATCH_F(-0.81290);
+      OUT_BATCH_F(0.0);
       /* constant 3: b coefficients */
-      OUT_RING_F(1.1643);
-      OUT_RING_F(2.017);
-      OUT_RING_F(0.0);
-      OUT_RING_F(0.0);
-
-      OUT_RING(_3DSTATE_SAMPLER_STATE | 9);
-      OUT_RING(0x00000007);
+      OUT_BATCH_F(1.1643);
+      OUT_BATCH_F(2.017);
+      OUT_BATCH_F(0.0);
+      OUT_BATCH_F(0.0);
+      /* constant 4: brightness/contrast */
+      OUT_BATCH_F(pPriv->brightness / 128.0);
+      OUT_BATCH_F(pPriv->contrast / 255.0);
+      OUT_BATCH_F(0.0);
+      OUT_BATCH_F(0.0);
+
+      OUT_BATCH(_3DSTATE_SAMPLER_STATE | 9);
+      OUT_BATCH(0x00000007);
       /* sampler 0 */
-      OUT_RING(0x00000000);
-      OUT_RING((FILTER_LINEAR << SS2_MAG_FILTER_SHIFT) |
+      OUT_BATCH((FILTER_LINEAR << SS2_MAG_FILTER_SHIFT) |
 	       (FILTER_LINEAR << SS2_MIN_FILTER_SHIFT));
-      OUT_RING((TEXCOORDMODE_CLAMP_EDGE << SS3_TCX_ADDR_MODE_SHIFT) |
-	       (TEXCOORDMODE_CLAMP_EDGE << SS3_TCY_ADDR_MODE_SHIFT));
+      OUT_BATCH((TEXCOORDMODE_CLAMP_EDGE << SS3_TCX_ADDR_MODE_SHIFT) |
+	       (TEXCOORDMODE_CLAMP_EDGE << SS3_TCY_ADDR_MODE_SHIFT) |
+	       (0 << SS3_TEXTUREMAP_INDEX_SHIFT) |
+	       SS3_NORMALIZED_COORDS);
+      OUT_BATCH(0x00000000);
       /* sampler 1 */
-      OUT_RING(0x00000000);
-      OUT_RING((FILTER_LINEAR << SS2_MAG_FILTER_SHIFT) |
+      OUT_BATCH((FILTER_LINEAR << SS2_MAG_FILTER_SHIFT) |
 	       (FILTER_LINEAR << SS2_MIN_FILTER_SHIFT));
-      OUT_RING((TEXCOORDMODE_CLAMP_EDGE << SS3_TCX_ADDR_MODE_SHIFT) |
-	       (TEXCOORDMODE_CLAMP_EDGE << SS3_TCY_ADDR_MODE_SHIFT));
+      OUT_BATCH((TEXCOORDMODE_CLAMP_EDGE << SS3_TCX_ADDR_MODE_SHIFT) |
+	       (TEXCOORDMODE_CLAMP_EDGE << SS3_TCY_ADDR_MODE_SHIFT) |
+	       (1 << SS3_TEXTUREMAP_INDEX_SHIFT) |
+	       SS3_NORMALIZED_COORDS);
+      OUT_BATCH(0x00000000);
       /* sampler 2 */
-      OUT_RING(0x00000000);
-      OUT_RING((FILTER_LINEAR << SS2_MAG_FILTER_SHIFT) |
-	       (FILTER_LINEAR << SS2_MIN_FILTER_SHIFT));
-      OUT_RING((TEXCOORDMODE_CLAMP_EDGE << SS3_TCX_ADDR_MODE_SHIFT) |
-	       (TEXCOORDMODE_CLAMP_EDGE << SS3_TCY_ADDR_MODE_SHIFT));
-
-      OUT_RING(_3DSTATE_MAP_STATE | 9);
-      OUT_RING(0x00000007);
-
-      OUT_RING(pPriv->YBuf0offset);
-      ms3 = MAPSURF_8BIT | MT_8BIT_I8;
+      OUT_BATCH((FILTER_LINEAR << SS2_MAG_FILTER_SHIFT) |
+		(FILTER_LINEAR << SS2_MIN_FILTER_SHIFT));
+      OUT_BATCH((TEXCOORDMODE_CLAMP_EDGE << SS3_TCX_ADDR_MODE_SHIFT) |
+		(TEXCOORDMODE_CLAMP_EDGE << SS3_TCY_ADDR_MODE_SHIFT) |
+		(2 << SS3_TEXTUREMAP_INDEX_SHIFT) |
+		SS3_NORMALIZED_COORDS);
+      OUT_BATCH(0x00000000);
+
+      OUT_BATCH(_3DSTATE_MAP_STATE | 9);
+      OUT_BATCH(0x00000007);
+
+      OUT_BATCH(pPriv->YBuf0offset);
+      ms3 = MAPSURF_8BIT | MT_8BIT_I8 | MS3_USE_FENCE_REGS;
       ms3 |= (height - 1) << MS3_HEIGHT_SHIFT;
       ms3 |= (width - 1) << MS3_WIDTH_SHIFT;
-      OUT_RING(ms3);
-      OUT_RING(((video_pitch * 2 / 4) - 1) << 21);
+      OUT_BATCH(ms3);
+      OUT_BATCH(((video_pitch * 2 / 4) - 1) << MS4_PITCH_SHIFT);
 
-      OUT_RING(pPriv->UBuf0offset);
-      ms3 = MAPSURF_8BIT | MT_8BIT_I8;
+      OUT_BATCH(pPriv->UBuf0offset);
+      ms3 = MAPSURF_8BIT | MT_8BIT_I8 | MS3_USE_FENCE_REGS;
       ms3 |= (height / 2 - 1) << MS3_HEIGHT_SHIFT;
       ms3 |= (width / 2 - 1) << MS3_WIDTH_SHIFT;
-      OUT_RING(ms3);
-      OUT_RING(((video_pitch / 4) - 1) << 21);
+      OUT_BATCH(ms3);
+      OUT_BATCH(((video_pitch / 4) - 1) << MS4_PITCH_SHIFT);
 
-      OUT_RING(pPriv->VBuf0offset);
-      ms3 = MAPSURF_8BIT | MT_8BIT_I8;
+      OUT_BATCH(pPriv->VBuf0offset);
+      ms3 = MAPSURF_8BIT | MT_8BIT_I8 | MS3_USE_FENCE_REGS;
       ms3 |= (height / 2 - 1) << MS3_HEIGHT_SHIFT;
       ms3 |= (width / 2 - 1) << MS3_WIDTH_SHIFT;
-      OUT_RING(ms3);
-      OUT_RING(((video_pitch / 4) - 1) << 21);
-      ADVANCE_LP_RING();
+      OUT_BATCH(ms3);
+      OUT_BATCH(((video_pitch / 4) - 1) << MS4_PITCH_SHIFT);
+      ADVANCE_BATCH();
 
       FS_BEGIN();
       /* Declare samplers */
-      i915_fs_dcl(FS_S0);
-      i915_fs_dcl(FS_S1);
-      i915_fs_dcl(FS_S2);
-      i915_fs_dcl(FS_T0);
-      i915_fs_dcl(FS_T1);
+      i915_fs_dcl(FS_S0); /* Y */
+      i915_fs_dcl(FS_S1); /* U */
+      i915_fs_dcl(FS_S2); /* V */
+      i915_fs_dcl(FS_T0); /* normalized coords */
 
-      /* Load samplers to temporaries.  Y (sampler 0) gets the un-halved coords-
-       * from t1.
-       */
-      i915_fs_texld(FS_R1, FS_S0, FS_T1);
+      /* Load samplers to temporaries. */
+      i915_fs_texld(FS_R1, FS_S0, FS_T0);
       i915_fs_texld(FS_R2, FS_S1, FS_T0);
       i915_fs_texld(FS_R3, FS_S2, FS_T0);
 
@@ -354,32 +309,50 @@ I915DisplayVideoTextured(ScrnInfoPtr pScrn, I830PortPrivPtr pPriv, int id,
       i915_fs_add(FS_R0, i915_fs_operand_reg(FS_R0),
                  i915_fs_operand_reg(FS_C0));
       /* dot-product the YUV data in R0 by the vectors of coefficients for
-       * calculating R, G, and B, storing the results in the R, G, or B channels
-       * of the output color.
+       * calculating R, G, and B, storing the results in the R, G, or B
+       * channels of the output color.  The OC results are implicitly clamped
+       * at the end of the program.
        */
-      i915_fs_dp3_masked(FS_OC, MASK_X | MASK_SATURATE,
+      i915_fs_dp3_masked(FS_OC, MASK_X,
                         i915_fs_operand_reg(FS_R0),
                         i915_fs_operand_reg(FS_C1));
-      i915_fs_dp3_masked(FS_OC, MASK_Y | MASK_SATURATE,
+      i915_fs_dp3_masked(FS_OC, MASK_Y,
                         i915_fs_operand_reg(FS_R0),
                         i915_fs_operand_reg(FS_C2));
-      i915_fs_dp3_masked(FS_OC, MASK_Z | MASK_SATURATE,
+      i915_fs_dp3_masked(FS_OC, MASK_Z,
                         i915_fs_operand_reg(FS_R0),
                         i915_fs_operand_reg(FS_C3));
       /* Set alpha of the output to 1.0, by wiring W to 1 and not actually using
        * the source.
        */
       i915_fs_mov_masked(FS_OC, MASK_W, i915_fs_operand_one());
+
+      if (pPriv->brightness != 0) {
+	  i915_fs_add(FS_OC,
+		      i915_fs_operand_reg(FS_OC),
+		      i915_fs_operand(FS_C4, X, X, X, ZERO));
+      }
       FS_END();
    }
    
    {
-      BEGIN_LP_RING(2);
-      OUT_RING(MI_FLUSH | MI_WRITE_DIRTY_STATE | MI_INVALIDATE_MAP_CACHE);
-      OUT_RING(0x00000000);
-      ADVANCE_LP_RING();
+      BEGIN_BATCH(2);
+      OUT_BATCH(MI_FLUSH | MI_WRITE_DIRTY_STATE | MI_INVALIDATE_MAP_CACHE);
+      OUT_BATCH(0x00000000);
+      ADVANCE_BATCH();
    }
 
+   /* Set up the offset for translating from the given region (in screen
+    * coordinates) to the backing pixmap.
+    */
+#ifdef COMPOSITE
+   pix_xoff = -pPixmap->screen_x + pPixmap->drawable.x;
+   pix_yoff = -pPixmap->screen_y + pPixmap->drawable.y;
+#else
+   pix_xoff = 0;
+   pix_yoff = 0;
+#endif
+
    dxo = dstRegion->extents.x1;
    dyo = dstRegion->extents.y1;
 
@@ -392,76 +365,47 @@ I915DisplayVideoTextured(ScrnInfoPtr pScrn, I830PortPrivPtr pPriv, int id,
       int box_x2 = pbox->x2;
       int box_y2 = pbox->y2;
       float src_scale_x, src_scale_y;
-      int vert_data_count;
 
       pbox++;
 
-      src_scale_x = (float)src_w / (float)drw_w;
-      src_scale_y  = (float)src_h / (float)drw_h;
+      src_scale_x = ((float)src_w / width) / drw_w;
+      src_scale_y  = ((float)src_h / height) / drw_h;
 
-      if (!planar)
-	 vert_data_count = 12;
-      else
-	 vert_data_count = 18;
-
-      BEGIN_LP_RING(vert_data_count + 8);
-      OUT_RING(MI_NOOP);
-      OUT_RING(MI_NOOP);
-      OUT_RING(MI_NOOP);
-      OUT_RING(MI_NOOP);
-      OUT_RING(MI_NOOP);
-      OUT_RING(MI_NOOP);
-      OUT_RING(MI_NOOP);
+      BEGIN_BATCH(8 + 12);
+      OUT_BATCH(MI_NOOP);
+      OUT_BATCH(MI_NOOP);
+      OUT_BATCH(MI_NOOP);
+      OUT_BATCH(MI_NOOP);
+      OUT_BATCH(MI_NOOP);
+      OUT_BATCH(MI_NOOP);
+      OUT_BATCH(MI_NOOP);
 
       /* vertex data - rect list consists of bottom right, bottom left, and top
        * left vertices.
        */
-      OUT_RING(PRIM3D_INLINE | PRIM3D_RECTLIST |
-	       (vert_data_count - 1));
+      OUT_BATCH(PRIM3D_INLINE | PRIM3D_RECTLIST | (12 - 1));
 
       /* bottom right */
-      OUT_RING_F(box_x2);
-      OUT_RING_F(box_y2);
-      if (!planar) {
-	 OUT_RING_F((box_x2 - dxo) * src_scale_x);
-	 OUT_RING_F((box_y2 - dyo) * src_scale_y);
-      } else {
-	 OUT_RING_F((box_x2 - dxo) * src_scale_x / 2.0);
-	 OUT_RING_F((box_y2 - dyo) * src_scale_y / 2.0);
-	 OUT_RING_F((box_x2 - dxo) * src_scale_x);
-	 OUT_RING_F((box_y2 - dyo) * src_scale_y);
-      }
+      OUT_BATCH_F(box_x2 + pix_xoff);
+      OUT_BATCH_F(box_y2 + pix_yoff);
+      OUT_BATCH_F((box_x2 - dxo) * src_scale_x);
+      OUT_BATCH_F((box_y2 - dyo) * src_scale_y);
 
       /* bottom left */
-      OUT_RING_F(box_x1);
-      OUT_RING_F(box_y2);
-      if (!planar) {
-	 OUT_RING_F((box_x1 - dxo) * src_scale_x);
-	 OUT_RING_F((box_y2 - dyo) * src_scale_y);
-      } else {
-	 OUT_RING_F((box_x1 - dxo) * src_scale_x / 2.0);
-	 OUT_RING_F((box_y2 - dyo) * src_scale_y / 2.0);
-	 OUT_RING_F((box_x1 - dxo) * src_scale_x);
-	 OUT_RING_F((box_y2 - dyo) * src_scale_y);
-      }
+      OUT_BATCH_F(box_x1 + pix_xoff);
+      OUT_BATCH_F(box_y2 + pix_yoff);
+      OUT_BATCH_F((box_x1 - dxo) * src_scale_x);
+      OUT_BATCH_F((box_y2 - dyo) * src_scale_y);
 
       /* top left */
-      OUT_RING_F(box_x1);
-      OUT_RING_F(box_y1);
-      if (!planar) {
-	 OUT_RING_F((box_x1 - dxo) * src_scale_x);
-	 OUT_RING_F((box_y1 - dyo) * src_scale_y);
-      } else {
-	 OUT_RING_F((box_x1 - dxo) * src_scale_x / 2.0);
-	 OUT_RING_F((box_y1 - dyo) * src_scale_y / 2.0);
-	 OUT_RING_F((box_x1 - dxo) * src_scale_x);
-	 OUT_RING_F((box_y1 - dyo) * src_scale_y);
-      }
+      OUT_BATCH_F(box_x1 + pix_xoff);
+      OUT_BATCH_F(box_y1 + pix_yoff);
+      OUT_BATCH_F((box_x1 - dxo) * src_scale_x);
+      OUT_BATCH_F((box_y1 - dyo) * src_scale_y);
 
-      ADVANCE_LP_RING();
+      ADVANCE_BATCH();
    }
 
-   if (pI830->AccelInfoRec)
-      pI830->AccelInfoRec->NeedToSync = TRUE;
+   i830MarkSync(pScrn);
 }