src/gallium/state_trackers/nine/nine_pipe.c

   1 /*
   2  * Copyright 2011 Joakim Sindholt <opensource@zhasha.com>
   3  * Copyright 2013 Christoph Bumiller
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * on the rights to use, copy, modify, merge, publish, distribute, sub
   9  * license, and/or sell copies of the Software, and to permit persons to whom
  10  * the Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  22  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
  23
  24 #include "device9.h"
  25 #include "nine_pipe.h"
  26
  27 #include "cso_cache/cso_context.h"
  28
  29 void
  30 nine_convert_dsa_state(struct pipe_depth_stencil_alpha_state *dsa_state,
  31                        const DWORD *rs)
  32 {
  33     struct pipe_depth_stencil_alpha_state dsa;
  34
  35     memset(&dsa, 0, sizeof(dsa)); /* memcmp safety */
  36
  37     if (rs[D3DRS_ZENABLE]) {
  38         dsa.depth.enabled = 1;
  39         dsa.depth.writemask = !!rs[D3DRS_ZWRITEENABLE];
  40         dsa.depth.func = d3dcmpfunc_to_pipe_func(rs[D3DRS_ZFUNC]);
  41     }
  42
  43     if (rs[D3DRS_STENCILENABLE]) {
  44         dsa.stencil[0].enabled = 1;
  45         dsa.stencil[0].func = d3dcmpfunc_to_pipe_func(rs[D3DRS_STENCILFUNC]);
  46         dsa.stencil[0].fail_op = d3dstencilop_to_pipe_stencil_op(rs[D3DRS_STENCILFAIL]);
  47         dsa.stencil[0].zpass_op = d3dstencilop_to_pipe_stencil_op(rs[D3DRS_STENCILPASS]);
  48         dsa.stencil[0].zfail_op = d3dstencilop_to_pipe_stencil_op(rs[D3DRS_STENCILZFAIL]);
  49         dsa.stencil[0].valuemask = rs[D3DRS_STENCILMASK];
  50         dsa.stencil[0].writemask = rs[D3DRS_STENCILWRITEMASK];
  51
  52         if (rs[D3DRS_TWOSIDEDSTENCILMODE]) {
  53             dsa.stencil[1].enabled = 1;
  54             dsa.stencil[1].func = d3dcmpfunc_to_pipe_func(rs[D3DRS_CCW_STENCILFUNC]);
  55             dsa.stencil[1].fail_op = d3dstencilop_to_pipe_stencil_op(rs[D3DRS_CCW_STENCILFAIL]);
  56             dsa.stencil[1].zpass_op = d3dstencilop_to_pipe_stencil_op(rs[D3DRS_CCW_STENCILPASS]);
  57             dsa.stencil[1].zfail_op = d3dstencilop_to_pipe_stencil_op(rs[D3DRS_CCW_STENCILZFAIL]);
  58             dsa.stencil[1].valuemask = dsa.stencil[0].valuemask;
  59             dsa.stencil[1].writemask = dsa.stencil[0].writemask;
  60         }
  61     }
  62
  63     if (rs[D3DRS_ALPHATESTENABLE]) {
  64         dsa.alpha.enabled = 1;
  65         dsa.alpha.func = d3dcmpfunc_to_pipe_func(rs[D3DRS_ALPHAFUNC]);
  66         dsa.alpha.ref_value = (float)rs[D3DRS_ALPHAREF] / 255.0f;
  67     }
  68
  69     *dsa_state = dsa;
  70 }
  71
  72 void
  73 nine_convert_rasterizer_state(struct pipe_rasterizer_state *rast_state, const DWORD *rs)
  74 {
  75     struct pipe_rasterizer_state rast;
  76
  77     memset(&rast, 0, sizeof(rast));
  78
  79     rast.flatshade = rs[D3DRS_SHADEMODE] == D3DSHADE_FLAT;
  80  /* rast.light_twoside = 0; */
  81  /* rast.clamp_fragment_color = 0; */
  82  /* rast.clamp_vertex_color = 0; */
  83  /* rast.front_ccw = 0; */
  84     rast.cull_face = d3dcull_to_pipe_face(rs[D3DRS_CULLMODE]);
  85     rast.fill_front = d3dfillmode_to_pipe_polygon_mode(rs[D3DRS_FILLMODE]);
  86     rast.fill_back = rast.fill_front;
  87     rast.offset_tri = !!(rs[D3DRS_DEPTHBIAS] | rs[D3DRS_SLOPESCALEDEPTHBIAS]);
  88     rast.offset_line = rast.offset_tri; /* triangles in wireframe mode */
  89     rast.offset_point = 0; /* XXX ? */
  90     rast.scissor = !!rs[D3DRS_SCISSORTESTENABLE];
  91  /* rast.poly_smooth = 0; */
  92  /* rast.poly_stipple_enable = 0; */
  93  /* rast.point_smooth = 0; */
  94     rast.sprite_coord_mode = PIPE_SPRITE_COORD_UPPER_LEFT;
  95     rast.point_quad_rasterization = 1;
  96     rast.point_size_per_vertex = rs[NINED3DRS_VSPOINTSIZE];
  97     rast.multisample = !!rs[D3DRS_MULTISAMPLEANTIALIAS];
  98     rast.line_smooth = !!rs[D3DRS_ANTIALIASEDLINEENABLE];
  99  /* rast.line_stipple_enable = 0; */
 100     rast.line_last_pixel = !!rs[D3DRS_LASTPIXEL];
 101     rast.flatshade_first = 1;
 102  /* rast.half_pixel_center = 0; */
 103  /* rast.lower_left_origin = 0; */
 104  /* rast.bottom_edge_rule = 0; */
 105  /* rast.rasterizer_discard = 0; */
 106     rast.depth_clip = 1;
 107     rast.clip_halfz = 1;
 108     rast.clip_plane_enable = rs[D3DRS_CLIPPLANEENABLE];
 109  /* rast.line_stipple_factor = 0; */
 110  /* rast.line_stipple_pattern = 0; */
 111     rast.sprite_coord_enable = rs[D3DRS_POINTSPRITEENABLE] ? 0xff : 0x00;
 112     rast.line_width = 1.0f;
 113     if (rs[NINED3DRS_VSPOINTSIZE]) {
 114         rast.point_size = 1.0f;
 115     } else {
 116         rast.point_size = CLAMP(asfloat(rs[D3DRS_POINTSIZE]),
 117                 asfloat(rs[D3DRS_POINTSIZE_MIN]),
 118                 asfloat(rs[D3DRS_POINTSIZE_MAX]));
 119     }
 120     /* offset_units has the ogl/d3d11 meaning.
 121      * d3d9: offset = scale * dz + bias
 122      * ogl/d3d11: offset = scale * dz + r * bias
 123      * with r implementation dependant and is supposed to be
 124      * the smallest value the depth buffer format can hold.
 125      * In practice on current and past hw it seems to be 2^-23
 126      * for all formats except float formats where it varies depending
 127      * on the content.
 128      * For now use 1 << 23, but in the future perhaps add a way in gallium
 129      * to get r for the format or get the gallium behaviour */
 130     rast.offset_units = asfloat(rs[D3DRS_DEPTHBIAS]) * (float)(1 << 23);
 131     rast.offset_scale = asfloat(rs[D3DRS_SLOPESCALEDEPTHBIAS]);
 132  /* rast.offset_clamp = 0.0f; */
 133
 134     *rast_state = rast;
 135 }
 136
 137 static inline void
 138 nine_convert_blend_state_fixup(struct pipe_blend_state *blend, const DWORD *rs)
 139 {
 140     if (unlikely(rs[D3DRS_SRCBLEND] == D3DBLEND_BOTHSRCALPHA ||
 141                  rs[D3DRS_SRCBLEND] == D3DBLEND_BOTHINVSRCALPHA)) {
 142         blend->rt[0].rgb_dst_factor = (rs[D3DRS_SRCBLEND] == D3DBLEND_BOTHSRCALPHA) ?
 143             PIPE_BLENDFACTOR_INV_SRC_ALPHA : PIPE_BLENDFACTOR_SRC_ALPHA;
 144         if (!rs[D3DRS_SEPARATEALPHABLENDENABLE])
 145             blend->rt[0].alpha_dst_factor = blend->rt[0].rgb_dst_factor;
 146     } else
 147     if (unlikely(rs[D3DRS_SEPARATEALPHABLENDENABLE] &&
 148                  (rs[D3DRS_SRCBLENDALPHA] == D3DBLEND_BOTHSRCALPHA ||
 149                   rs[D3DRS_SRCBLENDALPHA] == D3DBLEND_BOTHINVSRCALPHA))) {
 150         blend->rt[0].alpha_dst_factor = (rs[D3DRS_SRCBLENDALPHA] == D3DBLEND_BOTHSRCALPHA) ?
 151             PIPE_BLENDFACTOR_INV_SRC_ALPHA : PIPE_BLENDFACTOR_SRC_ALPHA;
 152     }
 153 }
 154
 155 void
 156 nine_convert_blend_state(struct pipe_blend_state *blend_state, const DWORD *rs)
 157 {
 158     struct pipe_blend_state blend;
 159
 160     memset(&blend, 0, sizeof(blend)); /* memcmp safety */
 161
 162     blend.dither = !!rs[D3DRS_DITHERENABLE];
 163
 164  /* blend.alpha_to_one = 0; */
 165     blend.alpha_to_coverage = !!rs[NINED3DRS_ALPHACOVERAGE];
 166
 167     blend.rt[0].blend_enable = !!rs[D3DRS_ALPHABLENDENABLE];
 168     if (blend.rt[0].blend_enable) {
 169         blend.rt[0].rgb_func = d3dblendop_to_pipe_blend(rs[D3DRS_BLENDOP]);
 170         blend.rt[0].rgb_src_factor = d3dblend_color_to_pipe_blendfactor(rs[D3DRS_SRCBLEND]);
 171         blend.rt[0].rgb_dst_factor = d3dblend_color_to_pipe_blendfactor(rs[D3DRS_DESTBLEND]);
 172         if (rs[D3DRS_SEPARATEALPHABLENDENABLE]) {
 173             blend.rt[0].alpha_func = d3dblendop_to_pipe_blend(rs[D3DRS_BLENDOPALPHA]);
 174             blend.rt[0].alpha_src_factor = d3dblend_alpha_to_pipe_blendfactor(rs[D3DRS_SRCBLENDALPHA]);
 175             blend.rt[0].alpha_dst_factor = d3dblend_alpha_to_pipe_blendfactor(rs[D3DRS_DESTBLENDALPHA]);
 176         } else {
 177             /* TODO: Just copy the rgb values ? SRC1_x may differ ... */
 178             blend.rt[0].alpha_func = blend.rt[0].rgb_func;
 179             blend.rt[0].alpha_src_factor = d3dblend_alpha_to_pipe_blendfactor(rs[D3DRS_SRCBLEND]);
 180             blend.rt[0].alpha_dst_factor = d3dblend_alpha_to_pipe_blendfactor(rs[D3DRS_DESTBLEND]);
 181         }
 182         nine_convert_blend_state_fixup(&blend, rs); /* for BOTH[INV]SRCALPHA */
 183     }
 184     blend.rt[0].colormask = rs[D3DRS_COLORWRITEENABLE];
 185
 186     if (rs[D3DRS_COLORWRITEENABLE1] != rs[D3DRS_COLORWRITEENABLE] ||
 187         rs[D3DRS_COLORWRITEENABLE2] != rs[D3DRS_COLORWRITEENABLE] ||
 188         rs[D3DRS_COLORWRITEENABLE3] != rs[D3DRS_COLORWRITEENABLE]) {
 189         unsigned i;
 190         blend.independent_blend_enable = TRUE;
 191         for (i = 1; i < 4; ++i)
 192             blend.rt[i] = blend.rt[0];
 193         blend.rt[1].colormask = rs[D3DRS_COLORWRITEENABLE1];
 194         blend.rt[2].colormask = rs[D3DRS_COLORWRITEENABLE2];
 195         blend.rt[3].colormask = rs[D3DRS_COLORWRITEENABLE3];
 196     }
 197
 198     /* blend.force_srgb = !!rs[D3DRS_SRGBWRITEENABLE]; */
 199
 200     *blend_state = blend;
 201 }
 202
 203 void
 204 nine_convert_sampler_state(struct cso_context *ctx, int idx, const DWORD *ss)
 205 {
 206     struct pipe_sampler_state samp;
 207
 208     assert(idx >= 0 &&
 209            (idx < NINE_MAX_SAMPLERS_PS || idx >= NINE_SAMPLER_VS(0)) &&
 210            (idx < NINE_MAX_SAMPLERS));
 211
 212     memset(&samp, 0, sizeof(samp)); /* memcmp safety */
 213
 214     if (ss[D3DSAMP_MIPFILTER] != D3DTEXF_NONE) {
 215         samp.lod_bias = asfloat(ss[D3DSAMP_MIPMAPLODBIAS]);
 216         samp.min_lod = ss[NINED3DSAMP_MINLOD];
 217         samp.min_mip_filter = (ss[D3DSAMP_MIPFILTER] == D3DTEXF_POINT) ? PIPE_TEX_FILTER_NEAREST : PIPE_TEX_FILTER_LINEAR;
 218     } else {
 219         samp.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
 220     }
 221     samp.max_lod = 15.0f;
 222     samp.wrap_s = d3dtextureaddress_to_pipe_tex_wrap(ss[D3DSAMP_ADDRESSU]);
 223     samp.wrap_t = d3dtextureaddress_to_pipe_tex_wrap(ss[D3DSAMP_ADDRESSV]);
 224     samp.wrap_r = d3dtextureaddress_to_pipe_tex_wrap(ss[D3DSAMP_ADDRESSW]);
 225     samp.min_img_filter = ss[D3DSAMP_MINFILTER] == D3DTEXF_POINT ? PIPE_TEX_FILTER_NEAREST : PIPE_TEX_FILTER_LINEAR;
 226     samp.mag_img_filter = ss[D3DSAMP_MAGFILTER] == D3DTEXF_POINT ? PIPE_TEX_FILTER_NEAREST : PIPE_TEX_FILTER_LINEAR;
 227     if (ss[D3DSAMP_MINFILTER] == D3DTEXF_ANISOTROPIC ||
 228         ss[D3DSAMP_MAGFILTER] == D3DTEXF_ANISOTROPIC)
 229         samp.max_anisotropy = ss[D3DSAMP_MAXANISOTROPY];
 230     samp.compare_mode = ss[NINED3DSAMP_SHADOW] ? PIPE_TEX_COMPARE_R_TO_TEXTURE : PIPE_TEX_COMPARE_NONE;
 231     samp.compare_func = PIPE_FUNC_LEQUAL;
 232     samp.normalized_coords = 1;
 233     samp.seamless_cube_map = 1;
 234     d3dcolor_to_pipe_color_union(&samp.border_color, ss[D3DSAMP_BORDERCOLOR]);
 235
 236     /* see nine_state.h */
 237     if (idx < NINE_MAX_SAMPLERS_PS)
 238         cso_single_sampler(ctx, PIPE_SHADER_FRAGMENT, idx - NINE_SAMPLER_PS(0), &samp);
 239     else
 240         cso_single_sampler(ctx, PIPE_SHADER_VERTEX, idx - NINE_SAMPLER_VS(0), &samp);
 241 }
 242
 243 void
 244 nine_pipe_context_clear(struct NineDevice9 *This)
 245 {
 246     struct pipe_context *pipe = This->pipe;
 247     struct cso_context *cso = This->cso;
 248     pipe->bind_vs_state(pipe, NULL);
 249     pipe->bind_fs_state(pipe, NULL);
 250
 251     /* Don't unbind constant buffers, they're device-private and
 252      * do not change on Reset.
 253      */
 254
 255     cso_set_samplers(cso, PIPE_SHADER_VERTEX, 0, NULL);
 256     cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 0, NULL);
 257
 258     pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0, 0, NULL);
 259     pipe->set_sampler_views(pipe, PIPE_SHADER_VERTEX, 0, 0, NULL);
 260
 261     pipe->set_vertex_buffers(pipe, 0, This->caps.MaxStreams, NULL);
 262     pipe->set_index_buffer(pipe, NULL);
 263 }
 264
 265 const enum pipe_format nine_d3d9_to_pipe_format_map[120] =
 266 {
 267    [D3DFMT_UNKNOWN]       = PIPE_FORMAT_NONE,
 268    [D3DFMT_R8G8B8]        = PIPE_FORMAT_NONE,
 269    [D3DFMT_A8R8G8B8]      = PIPE_FORMAT_B8G8R8A8_UNORM,
 270    [D3DFMT_X8R8G8B8]      = PIPE_FORMAT_B8G8R8X8_UNORM,
 271    [D3DFMT_R5G6B5]        = PIPE_FORMAT_B5G6R5_UNORM,
 272    [D3DFMT_X1R5G5B5]      = PIPE_FORMAT_B5G5R5X1_UNORM,
 273    [D3DFMT_A1R5G5B5]      = PIPE_FORMAT_B5G5R5A1_UNORM,
 274    [D3DFMT_A4R4G4B4]      = PIPE_FORMAT_B4G4R4A4_UNORM,
 275    [D3DFMT_R3G3B2]        = PIPE_FORMAT_B2G3R3_UNORM,
 276    [D3DFMT_A8]            = PIPE_FORMAT_A8_UNORM,
 277    [D3DFMT_A8R3G3B2]      = PIPE_FORMAT_NONE,
 278    [D3DFMT_X4R4G4B4]      = PIPE_FORMAT_B4G4R4X4_UNORM,
 279    [D3DFMT_A2B10G10R10]   = PIPE_FORMAT_R10G10B10A2_UNORM,
 280    [D3DFMT_A8B8G8R8]      = PIPE_FORMAT_R8G8B8A8_UNORM,
 281    [D3DFMT_X8B8G8R8]      = PIPE_FORMAT_R8G8B8X8_UNORM,
 282    [D3DFMT_G16R16]        = PIPE_FORMAT_R16G16_UNORM,
 283    [D3DFMT_A2R10G10B10]   = PIPE_FORMAT_B10G10R10A2_UNORM,
 284    [D3DFMT_A16B16G16R16]  = PIPE_FORMAT_R16G16B16A16_UNORM,
 285    [D3DFMT_A8P8]          = PIPE_FORMAT_NONE,
 286    [D3DFMT_P8]            = PIPE_FORMAT_NONE,
 287    [D3DFMT_L8]            = PIPE_FORMAT_L8_UNORM,
 288    [D3DFMT_A8L8]          = PIPE_FORMAT_L8A8_UNORM,
 289    [D3DFMT_A4L4]          = PIPE_FORMAT_L4A4_UNORM,
 290    [D3DFMT_V8U8]          = PIPE_FORMAT_R8G8_SNORM,
 291    [D3DFMT_L6V5U5]        = PIPE_FORMAT_NONE,
 292    [D3DFMT_X8L8V8U8]      = PIPE_FORMAT_NONE,
 293    [D3DFMT_Q8W8V8U8]      = PIPE_FORMAT_R8G8B8A8_SNORM,
 294    [D3DFMT_V16U16]        = PIPE_FORMAT_R16G16_SNORM,
 295    [D3DFMT_A2W10V10U10]   = PIPE_FORMAT_R10SG10SB10SA2U_NORM,
 296    [D3DFMT_D16_LOCKABLE]  = PIPE_FORMAT_Z16_UNORM,
 297    [D3DFMT_D32]           = PIPE_FORMAT_Z32_UNORM,
 298    [D3DFMT_D15S1]         = PIPE_FORMAT_Z24_UNORM_S8_UINT,
 299    [D3DFMT_D24S8]         = PIPE_FORMAT_S8_UINT_Z24_UNORM,
 300    [D3DFMT_D24X8]         = PIPE_FORMAT_X8Z24_UNORM,
 301    [D3DFMT_D24X4S4]       = PIPE_FORMAT_Z24_UNORM_S8_UINT,
 302    [D3DFMT_D16]           = PIPE_FORMAT_Z16_UNORM,
 303    [D3DFMT_D32F_LOCKABLE] = PIPE_FORMAT_Z32_FLOAT,
 304    [D3DFMT_D24FS8]        = PIPE_FORMAT_Z32_FLOAT_S8X24_UINT,
 305    [D3DFMT_D32_LOCKABLE]  = PIPE_FORMAT_NONE,
 306    [D3DFMT_S8_LOCKABLE]   = PIPE_FORMAT_NONE,
 307    [D3DFMT_L16]           = PIPE_FORMAT_L16_UNORM,
 308    [D3DFMT_VERTEXDATA]    = PIPE_FORMAT_NONE,
 309    [D3DFMT_INDEX16]       = PIPE_FORMAT_R16_UINT,
 310    [D3DFMT_INDEX32]       = PIPE_FORMAT_R32_UINT,
 311    [D3DFMT_Q16W16V16U16]  = PIPE_FORMAT_R16G16B16A16_SNORM,
 312    [D3DFMT_R16F]          = PIPE_FORMAT_R16_FLOAT,
 313    [D3DFMT_G16R16F]       = PIPE_FORMAT_R16G16_FLOAT,
 314    [D3DFMT_A16B16G16R16F] = PIPE_FORMAT_R16G16B16A16_FLOAT,
 315    [D3DFMT_R32F]          = PIPE_FORMAT_R32_FLOAT,
 316    [D3DFMT_G32R32F]       = PIPE_FORMAT_R32G32_FLOAT,
 317    [D3DFMT_A32B32G32R32F] = PIPE_FORMAT_R32G32B32A32_FLOAT,
 318    [D3DFMT_CxV8U8]        = PIPE_FORMAT_NONE,
 319    [D3DFMT_A1]            = PIPE_FORMAT_NONE,
 320    [D3DFMT_A2B10G10R10_XR_BIAS] = PIPE_FORMAT_NONE,
 321 };
 322
 323 const D3DFORMAT nine_pipe_to_d3d9_format_map[PIPE_FORMAT_COUNT] =
 324 {
 325    [PIPE_FORMAT_NONE]               = D3DFMT_UNKNOWN,
 326
 327 /* [PIPE_FORMAT_B8G8R8_UNORM]       = D3DFMT_R8G8B8, */
 328    [PIPE_FORMAT_B8G8R8A8_UNORM]     = D3DFMT_A8R8G8B8,
 329    [PIPE_FORMAT_B8G8R8X8_UNORM]     = D3DFMT_X8R8G8B8,
 330    [PIPE_FORMAT_B5G6R5_UNORM]       = D3DFMT_R5G6B5,
 331    [PIPE_FORMAT_B5G5R5X1_UNORM]     = D3DFMT_X1R5G5B5,
 332    [PIPE_FORMAT_B5G5R5A1_UNORM]     = D3DFMT_A1R5G5B5,
 333    [PIPE_FORMAT_B4G4R4A4_UNORM]     = D3DFMT_A4R4G4B4,
 334    [PIPE_FORMAT_B2G3R3_UNORM]       = D3DFMT_R3G3B2,
 335    [PIPE_FORMAT_A8_UNORM]           = D3DFMT_A8,
 336 /* [PIPE_FORMAT_B2G3R3A8_UNORM]     = D3DFMT_A8R3G3B2, */
 337    [PIPE_FORMAT_B4G4R4X4_UNORM]     = D3DFMT_X4R4G4B4,
 338    [PIPE_FORMAT_R10G10B10A2_UNORM]  = D3DFMT_A2B10G10R10,
 339    [PIPE_FORMAT_R8G8B8A8_UNORM]     = D3DFMT_A8B8G8R8,
 340    [PIPE_FORMAT_R8G8B8X8_UNORM]     = D3DFMT_X8B8G8R8,
 341    [PIPE_FORMAT_R16G16_UNORM]       = D3DFMT_G16R16,
 342    [PIPE_FORMAT_B10G10R10A2_UNORM]  = D3DFMT_A2R10G10B10,
 343    [PIPE_FORMAT_R16G16B16A16_UNORM] = D3DFMT_A16B16G16R16,
 344
 345    [PIPE_FORMAT_R8_UINT]            = D3DFMT_P8,
 346    [PIPE_FORMAT_R8A8_UINT]          = D3DFMT_A8P8,
 347
 348    [PIPE_FORMAT_L8_UNORM]           = D3DFMT_L8,
 349    [PIPE_FORMAT_L8A8_UNORM]         = D3DFMT_A8L8,
 350    [PIPE_FORMAT_L4A4_UNORM]         = D3DFMT_A4L4,
 351
 352    [PIPE_FORMAT_R8G8_SNORM]           = D3DFMT_V8U8,
 353 /* [PIPE_FORMAT_?]                    = D3DFMT_L6V5U5, */
 354 /* [PIPE_FORMAT_?]                    = D3DFMT_X8L8V8U8, */
 355    [PIPE_FORMAT_R8G8B8A8_SNORM]       = D3DFMT_Q8W8V8U8,
 356    [PIPE_FORMAT_R16G16_SNORM]         = D3DFMT_V16U16,
 357    [PIPE_FORMAT_R10SG10SB10SA2U_NORM] = D3DFMT_A2W10V10U10,
 358
 359    [PIPE_FORMAT_YUYV]               = D3DFMT_UYVY,
 360 /* [PIPE_FORMAT_YUY2]               = D3DFMT_YUY2, */
 361    [PIPE_FORMAT_DXT1_RGBA]          = D3DFMT_DXT1,
 362 /* [PIPE_FORMAT_DXT2_RGBA]          = D3DFMT_DXT2, */
 363    [PIPE_FORMAT_DXT3_RGBA]          = D3DFMT_DXT3,
 364 /* [PIPE_FORMAT_DXT4_RGBA]          = D3DFMT_DXT4, */
 365    [PIPE_FORMAT_DXT5_RGBA]          = D3DFMT_DXT5,
 366 /* [PIPE_FORMAT_?]                  = D3DFMT_MULTI2_ARGB8, (MET) */
 367    [PIPE_FORMAT_R8G8_B8G8_UNORM]    = D3DFMT_R8G8_B8G8, /* XXX: order */
 368    [PIPE_FORMAT_G8R8_G8B8_UNORM]    = D3DFMT_G8R8_G8B8,
 369
 370    [PIPE_FORMAT_Z16_UNORM]          = D3DFMT_D16_LOCKABLE,
 371    [PIPE_FORMAT_Z32_UNORM]          = D3DFMT_D32,
 372 /* [PIPE_FORMAT_Z15_UNORM_S1_UINT]  = D3DFMT_D15S1, */
 373    [PIPE_FORMAT_S8_UINT_Z24_UNORM]  = D3DFMT_D24S8,
 374    [PIPE_FORMAT_X8Z24_UNORM]        = D3DFMT_D24X8,
 375    [PIPE_FORMAT_L16_UNORM]          = D3DFMT_L16,
 376    [PIPE_FORMAT_Z32_FLOAT]          = D3DFMT_D32F_LOCKABLE,
 377 /* [PIPE_FORMAT_Z24_FLOAT_S8_UINT]  = D3DFMT_D24FS8, */
 378
 379    [PIPE_FORMAT_R16_UINT]           = D3DFMT_INDEX16,
 380    [PIPE_FORMAT_R32_UINT]           = D3DFMT_INDEX32,
 381    [PIPE_FORMAT_R16G16B16A16_SNORM] = D3DFMT_Q16W16V16U16,
 382
 383    [PIPE_FORMAT_R16_FLOAT]          = D3DFMT_R16F,
 384    [PIPE_FORMAT_R32_FLOAT]          = D3DFMT_R32F,
 385    [PIPE_FORMAT_R16G16_FLOAT]       = D3DFMT_G16R16F,
 386    [PIPE_FORMAT_R32G32_FLOAT]       = D3DFMT_G32R32F,
 387    [PIPE_FORMAT_R16G16B16A16_FLOAT] = D3DFMT_A16B16G16R16F,
 388    [PIPE_FORMAT_R32G32B32A32_FLOAT] = D3DFMT_A32B32G32R32F,
 389
 390 /* [PIPE_FORMAT_?]                  = D3DFMT_CxV8U8, */
 391 };