Subversion Repositories Kolibri OS

/**************************************************************************

 *

 * Copyright 2009 Marek Olšák 

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the

 * "Software"), to deal in the Software without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sub license, and/or sell copies of the Software, and to

 * permit persons to whom the Software is furnished to do so, subject to

 * the following conditions:

 *

 * The above copyright notice and this permission notice (including the

 * next paragraph) shall be included in all copies or substantial portions

 * of the Software.

 *

 * 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 NON-INFRINGEMENT.

 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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.

 *

 **************************************************************************/

/**

 * @file

 * Blitter utility to facilitate acceleration of the clear, clear_render_target,

 * clear_depth_stencil, resource_copy_region, and blit functions.

 *

 * @author Marek Olšák

 */

#include "pipe/p_context.h"

#include "pipe/p_defines.h"

#include "util/u_inlines.h"

#include "pipe/p_shader_tokens.h"

#include "pipe/p_state.h"

#include "util/u_format.h"

#include "util/u_memory.h"

#include "util/u_math.h"

#include "util/u_blitter.h"

#include "util/u_draw_quad.h"

#include "util/u_sampler.h"

#include "util/u_simple_shaders.h"

#include "util/u_surface.h"

#include "util/u_texture.h"

#include "util/u_upload_mgr.h"

#define INVALID_PTR ((void*)~0)

#define GET_CLEAR_BLEND_STATE_IDX(clear_buffers) \

   ((clear_buffers) / PIPE_CLEAR_COLOR0)

#define NUM_RESOLVE_FRAG_SHADERS 5 /* MSAA 2x, 4x, 8x, 16x, 32x */

#define GET_MSAA_RESOLVE_FS_IDX(nr_samples) (util_logbase2(nr_samples)-1)

struct blitter_context_priv

{

   struct blitter_context base;

   struct u_upload_mgr *upload;

   float vertices[4][2][4];   /**< {pos, color} or {pos, texcoord} */

   /* Templates for various state objects. */

   /* Constant state objects. */

   /* Vertex shaders. */

   void *vs; /**< Vertex shader which passes {pos, generic} to the output.*/

   void *vs_pos_only; /**< Vertex shader which passes pos to the output.*/

   void *vs_layered; /**< Vertex shader which sets LAYER = INSTANCEID. */

   /* Fragment shaders. */

   void *fs_empty;

   void *fs_write_one_cbuf;

   void *fs_write_all_cbufs;

   /* FS which outputs a color from a texture,

      where the index is PIPE_TEXTURE_* to be sampled. */

   void *fs_texfetch_col[PIPE_MAX_TEXTURE_TYPES];

   /* FS which outputs a depth from a texture,

      where the index is PIPE_TEXTURE_* to be sampled. */

   void *fs_texfetch_depth[PIPE_MAX_TEXTURE_TYPES];

   void *fs_texfetch_depthstencil[PIPE_MAX_TEXTURE_TYPES];

   void *fs_texfetch_stencil[PIPE_MAX_TEXTURE_TYPES];

   /* FS which outputs one sample from a multisample texture. */

   void *fs_texfetch_col_msaa[PIPE_MAX_TEXTURE_TYPES];

   void *fs_texfetch_depth_msaa[PIPE_MAX_TEXTURE_TYPES];

   void *fs_texfetch_depthstencil_msaa[PIPE_MAX_TEXTURE_TYPES];

   void *fs_texfetch_stencil_msaa[PIPE_MAX_TEXTURE_TYPES];

   /* FS which outputs an average of all samples. */

   void *fs_resolve[PIPE_MAX_TEXTURE_TYPES][NUM_RESOLVE_FRAG_SHADERS][2];

   void *fs_resolve_sint[PIPE_MAX_TEXTURE_TYPES][NUM_RESOLVE_FRAG_SHADERS][2];

   void *fs_resolve_uint[PIPE_MAX_TEXTURE_TYPES][NUM_RESOLVE_FRAG_SHADERS][2];

   /* Blend state. */

   void *blend[PIPE_MASK_RGBA+1]; /**< blend state with writemask */

   void *blend_clear[GET_CLEAR_BLEND_STATE_IDX(PIPE_CLEAR_COLOR)+1];

   /* Depth stencil alpha state. */

   void *dsa_write_depth_stencil;

   void *dsa_write_depth_keep_stencil;

   void *dsa_keep_depth_stencil;

   void *dsa_keep_depth_write_stencil;

   /* Vertex elements states. */

   void *velem_state;

   void *velem_state_readbuf[4]; /**< X, XY, XYZ, XYZW */

   /* Sampler state. */

   void *sampler_state;

   void *sampler_state_linear;

   void *sampler_state_rect;

   void *sampler_state_rect_linear;

   /* Rasterizer state. */

   void *rs_state, *rs_state_scissor, *rs_discard_state;

   /* Viewport state. */

   struct pipe_viewport_state viewport;

   /* Destination surface dimensions. */

   unsigned dst_width;

   unsigned dst_height;

   boolean has_geometry_shader;

   boolean has_tessellation;

   boolean has_layered;

   boolean has_stream_out;

   boolean has_stencil_export;

   boolean has_texture_multisample;

   boolean cached_all_shaders;

   /* The Draw module overrides these functions.

    * Always create the blitter before Draw. */

   void   (*bind_fs_state)(struct pipe_context *, void *);

   void   (*delete_fs_state)(struct pipe_context *, void *);

};

static struct pipe_surface *

util_blitter_get_next_surface_layer(struct pipe_context *pipe,

                                    struct pipe_surface *surf);

struct blitter_context *util_blitter_create(struct pipe_context *pipe)

{

   struct blitter_context_priv *ctx;

   struct pipe_blend_state blend;

   struct pipe_depth_stencil_alpha_state dsa;

   struct pipe_rasterizer_state rs_state;

   struct pipe_sampler_state sampler_state;

   struct pipe_vertex_element velem[2];

   unsigned i;

   ctx = CALLOC_STRUCT(blitter_context_priv);

   if (!ctx)

      return NULL;

   ctx->base.pipe = pipe;

   ctx->base.draw_rectangle = util_blitter_draw_rectangle;

   ctx->base.get_next_surface_layer = util_blitter_get_next_surface_layer;

   ctx->bind_fs_state = pipe->bind_fs_state;

   ctx->delete_fs_state = pipe->delete_fs_state;

   /* init state objects for them to be considered invalid */

   ctx->base.saved_blend_state = INVALID_PTR;

   ctx->base.saved_dsa_state = INVALID_PTR;

   ctx->base.saved_rs_state = INVALID_PTR;

   ctx->base.saved_fs = INVALID_PTR;

   ctx->base.saved_vs = INVALID_PTR;

   ctx->base.saved_gs = INVALID_PTR;

   ctx->base.saved_velem_state = INVALID_PTR;

   ctx->base.saved_fb_state.nr_cbufs = ~0;

   ctx->base.saved_num_sampler_views = ~0;

   ctx->base.saved_num_sampler_states = ~0;

   ctx->base.saved_num_so_targets = ~0;

   ctx->has_geometry_shader =

      pipe->screen->get_shader_param(pipe->screen, PIPE_SHADER_GEOMETRY,

                                     PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0;

   ctx->has_tessellation =

      pipe->screen->get_shader_param(pipe->screen, PIPE_SHADER_TESS_CTRL,

                                     PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0;

   ctx->has_stream_out =

      pipe->screen->get_param(pipe->screen,

                              PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS) != 0;

   ctx->has_stencil_export =

         pipe->screen->get_param(pipe->screen,

                                 PIPE_CAP_SHADER_STENCIL_EXPORT);

   ctx->has_texture_multisample =

      pipe->screen->get_param(pipe->screen, PIPE_CAP_TEXTURE_MULTISAMPLE);

   /* blend state objects */

   memset(&blend, 0, sizeof(blend));

   for (i = 0; i <= PIPE_MASK_RGBA; i++) {

      blend.rt[0].colormask = i;

      ctx->blend[i] = pipe->create_blend_state(pipe, &blend);

   }

   /* depth stencil alpha state objects */

   memset(&dsa, 0, sizeof(dsa));

   ctx->dsa_keep_depth_stencil =

      pipe->create_depth_stencil_alpha_state(pipe, &dsa);

   dsa.depth.enabled = 1;

   dsa.depth.writemask = 1;

   dsa.depth.func = PIPE_FUNC_ALWAYS;

   ctx->dsa_write_depth_keep_stencil =

      pipe->create_depth_stencil_alpha_state(pipe, &dsa);

   dsa.stencil[0].enabled = 1;

   dsa.stencil[0].func = PIPE_FUNC_ALWAYS;

   dsa.stencil[0].fail_op = PIPE_STENCIL_OP_REPLACE;

   dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_REPLACE;

   dsa.stencil[0].zfail_op = PIPE_STENCIL_OP_REPLACE;

   dsa.stencil[0].valuemask = 0xff;

   dsa.stencil[0].writemask = 0xff;

   ctx->dsa_write_depth_stencil =

      pipe->create_depth_stencil_alpha_state(pipe, &dsa);

   dsa.depth.enabled = 0;

   dsa.depth.writemask = 0;

   ctx->dsa_keep_depth_write_stencil =

      pipe->create_depth_stencil_alpha_state(pipe, &dsa);

   /* sampler state */

   memset(&sampler_state, 0, sizeof(sampler_state));

   sampler_state.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;

   sampler_state.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;

   sampler_state.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;

   sampler_state.normalized_coords = 1;

   ctx->sampler_state = pipe->create_sampler_state(pipe, &sampler_state);

   sampler_state.normalized_coords = 0;

   ctx->sampler_state_rect = pipe->create_sampler_state(pipe, &sampler_state);

   sampler_state.min_img_filter = PIPE_TEX_FILTER_LINEAR;

   sampler_state.mag_img_filter = PIPE_TEX_FILTER_LINEAR;

   sampler_state.normalized_coords = 1;

   ctx->sampler_state_linear = pipe->create_sampler_state(pipe, &sampler_state);

   sampler_state.normalized_coords = 0;

   ctx->sampler_state_rect_linear = pipe->create_sampler_state(pipe, &sampler_state);

   /* rasterizer state */

   memset(&rs_state, 0, sizeof(rs_state));

   rs_state.cull_face = PIPE_FACE_NONE;

   rs_state.half_pixel_center = 1;

   rs_state.bottom_edge_rule = 1;

   rs_state.flatshade = 1;

   rs_state.depth_clip = 1;

   ctx->rs_state = pipe->create_rasterizer_state(pipe, &rs_state);

   rs_state.scissor = 1;

   ctx->rs_state_scissor = pipe->create_rasterizer_state(pipe, &rs_state);

   if (ctx->has_stream_out) {

      rs_state.scissor = 0;

      rs_state.rasterizer_discard = 1;

      ctx->rs_discard_state = pipe->create_rasterizer_state(pipe, &rs_state);

   }

   ctx->base.vb_slot = 0; /* 0 for now */

   /* vertex elements states */

   memset(&velem[0], 0, sizeof(velem[0]) * 2);

   for (i = 0; i < 2; i++) {

      velem[i].src_offset = i * 4 * sizeof(float);

      velem[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;

      velem[i].vertex_buffer_index = ctx->base.vb_slot;

   }

   ctx->velem_state = pipe->create_vertex_elements_state(pipe, 2, &velem[0]);

   if (ctx->has_stream_out) {

      static enum pipe_format formats[4] = {

         PIPE_FORMAT_R32_UINT,

         PIPE_FORMAT_R32G32_UINT,

         PIPE_FORMAT_R32G32B32_UINT,

         PIPE_FORMAT_R32G32B32A32_UINT

      };

      for (i = 0; i < 4; i++) {

         velem[0].src_format = formats[i];

         velem[0].vertex_buffer_index = ctx->base.vb_slot;

         ctx->velem_state_readbuf[i] =

               pipe->create_vertex_elements_state(pipe, 1, &velem[0]);

      }

   }

   ctx->has_layered =

      pipe->screen->get_param(pipe->screen, PIPE_CAP_TGSI_INSTANCEID) &&

      pipe->screen->get_param(pipe->screen, PIPE_CAP_TGSI_VS_LAYER_VIEWPORT);

   /* set invariant vertex coordinates */

   for (i = 0; i < 4; i++)

      ctx->vertices[i][0][3] = 1; /*v.w*/

   ctx->upload = u_upload_create(pipe, 65536, 4, PIPE_BIND_VERTEX_BUFFER);

   return &ctx->base;

}

static void bind_vs_pos_only(struct blitter_context_priv *ctx)

{

   struct pipe_context *pipe = ctx->base.pipe;

   if (!ctx->vs_pos_only) {

      struct pipe_stream_output_info so;

      const uint semantic_names[] = { TGSI_SEMANTIC_POSITION };

      const uint semantic_indices[] = { 0 };

      memset(&so, 0, sizeof(so));

      so.num_outputs = 1;

      so.output[0].num_components = 1;

      so.stride[0] = 1;

      ctx->vs_pos_only =

         util_make_vertex_passthrough_shader_with_so(pipe, 1, semantic_names,

                                                     semantic_indices, FALSE,

                                                     &so);

   }

   pipe->bind_vs_state(pipe, ctx->vs_pos_only);

}

static void bind_vs_passthrough(struct blitter_context_priv *ctx)

{

   struct pipe_context *pipe = ctx->base.pipe;

   if (!ctx->vs) {

      const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,

                                      TGSI_SEMANTIC_GENERIC };

      const uint semantic_indices[] = { 0, 0 };

      ctx->vs =

         util_make_vertex_passthrough_shader(pipe, 2, semantic_names,

                                             semantic_indices, FALSE);

   }

   pipe->bind_vs_state(pipe, ctx->vs);

}

static void bind_vs_layered(struct blitter_context_priv *ctx)

{

   struct pipe_context *pipe = ctx->base.pipe;

   if (!ctx->vs_layered) {

      ctx->vs_layered = util_make_layered_clear_vertex_shader(pipe);

   }

   pipe->bind_vs_state(pipe, ctx->vs_layered);

}

static void bind_fs_empty(struct blitter_context_priv *ctx)

{

   struct pipe_context *pipe = ctx->base.pipe;

   if (!ctx->fs_empty) {

      assert(!ctx->cached_all_shaders);

      ctx->fs_empty = util_make_empty_fragment_shader(pipe);

   }

   ctx->bind_fs_state(pipe, ctx->fs_empty);

}

static void bind_fs_write_one_cbuf(struct blitter_context_priv *ctx)

{

   struct pipe_context *pipe = ctx->base.pipe;

   if (!ctx->fs_write_one_cbuf) {

      assert(!ctx->cached_all_shaders);

      ctx->fs_write_one_cbuf =

         util_make_fragment_passthrough_shader(pipe, TGSI_SEMANTIC_GENERIC,

                                               TGSI_INTERPOLATE_CONSTANT, FALSE);

   }

   ctx->bind_fs_state(pipe, ctx->fs_write_one_cbuf);

}

static void bind_fs_write_all_cbufs(struct blitter_context_priv *ctx)

{

   struct pipe_context *pipe = ctx->base.pipe;

   if (!ctx->fs_write_all_cbufs) {

      assert(!ctx->cached_all_shaders);

      ctx->fs_write_all_cbufs =

         util_make_fragment_passthrough_shader(pipe, TGSI_SEMANTIC_GENERIC,

                                               TGSI_INTERPOLATE_CONSTANT, TRUE);

   }

   ctx->bind_fs_state(pipe, ctx->fs_write_all_cbufs);

}

void util_blitter_destroy(struct blitter_context *blitter)

{

   struct blitter_context_priv *ctx = (struct blitter_context_priv*)blitter;

   struct pipe_context *pipe = blitter->pipe;

   int i, j, f;

   for (i = 0; i <= PIPE_MASK_RGBA; i++) {

      pipe->delete_blend_state(pipe, ctx->blend[i]);

   }

   for (i = 0; i < Elements(ctx->blend_clear); i++) {

      if (ctx->blend_clear[i])

         pipe->delete_blend_state(pipe, ctx->blend_clear[i]);

   }

   pipe->delete_depth_stencil_alpha_state(pipe, ctx->dsa_keep_depth_stencil);

   pipe->delete_depth_stencil_alpha_state(pipe,

                                          ctx->dsa_write_depth_keep_stencil);

   pipe->delete_depth_stencil_alpha_state(pipe, ctx->dsa_write_depth_stencil);

   pipe->delete_depth_stencil_alpha_state(pipe, ctx->dsa_keep_depth_write_stencil);

   pipe->delete_rasterizer_state(pipe, ctx->rs_state);

   pipe->delete_rasterizer_state(pipe, ctx->rs_state_scissor);

   if (ctx->rs_discard_state)

      pipe->delete_rasterizer_state(pipe, ctx->rs_discard_state);

   if (ctx->vs)

      pipe->delete_vs_state(pipe, ctx->vs);

   if (ctx->vs_pos_only)

      pipe->delete_vs_state(pipe, ctx->vs_pos_only);

   if (ctx->vs_layered)

      pipe->delete_vs_state(pipe, ctx->vs_layered);

   pipe->delete_vertex_elements_state(pipe, ctx->velem_state);

   for (i = 0; i < 4; i++) {

      if (ctx->velem_state_readbuf[i]) {

         pipe->delete_vertex_elements_state(pipe, ctx->velem_state_readbuf[i]);

      }

   }

   for (i = 0; i < PIPE_MAX_TEXTURE_TYPES; i++) {

      if (ctx->fs_texfetch_col[i])

         ctx->delete_fs_state(pipe, ctx->fs_texfetch_col[i]);

      if (ctx->fs_texfetch_depth[i])

         ctx->delete_fs_state(pipe, ctx->fs_texfetch_depth[i]);

      if (ctx->fs_texfetch_depthstencil[i])

         ctx->delete_fs_state(pipe, ctx->fs_texfetch_depthstencil[i]);

      if (ctx->fs_texfetch_stencil[i])

         ctx->delete_fs_state(pipe, ctx->fs_texfetch_stencil[i]);

      if (ctx->fs_texfetch_col_msaa[i])

         ctx->delete_fs_state(pipe, ctx->fs_texfetch_col_msaa[i]);

      if (ctx->fs_texfetch_depth_msaa[i])

         ctx->delete_fs_state(pipe, ctx->fs_texfetch_depth_msaa[i]);

      if (ctx->fs_texfetch_depthstencil_msaa[i])

         ctx->delete_fs_state(pipe, ctx->fs_texfetch_depthstencil_msaa[i]);

      if (ctx->fs_texfetch_stencil_msaa[i])

         ctx->delete_fs_state(pipe, ctx->fs_texfetch_stencil_msaa[i]);

      for (j = 0; j< Elements(ctx->fs_resolve[i]); j++)

         for (f = 0; f < 2; f++)

            if (ctx->fs_resolve[i][j][f])

               ctx->delete_fs_state(pipe, ctx->fs_resolve[i][j][f]);

      for (j = 0; j< Elements(ctx->fs_resolve_sint[i]); j++)

         for (f = 0; f < 2; f++)

            if (ctx->fs_resolve_sint[i][j][f])

               ctx->delete_fs_state(pipe, ctx->fs_resolve_sint[i][j][f]);

      for (j = 0; j< Elements(ctx->fs_resolve_uint[i]); j++)

         for (f = 0; f < 2; f++)

            if (ctx->fs_resolve_uint[i][j][f])

               ctx->delete_fs_state(pipe, ctx->fs_resolve_uint[i][j][f]);

   }

   if (ctx->fs_empty)

      ctx->delete_fs_state(pipe, ctx->fs_empty);

   if (ctx->fs_write_one_cbuf)

      ctx->delete_fs_state(pipe, ctx->fs_write_one_cbuf);

   if (ctx->fs_write_all_cbufs)

      ctx->delete_fs_state(pipe, ctx->fs_write_all_cbufs);

   pipe->delete_sampler_state(pipe, ctx->sampler_state_rect_linear);

   pipe->delete_sampler_state(pipe, ctx->sampler_state_rect);

   pipe->delete_sampler_state(pipe, ctx->sampler_state_linear);

   pipe->delete_sampler_state(pipe, ctx->sampler_state);

   u_upload_destroy(ctx->upload);

   FREE(ctx);

}

void util_blitter_set_texture_multisample(struct blitter_context *blitter,

                                          boolean supported)

{

   struct blitter_context_priv *ctx = (struct blitter_context_priv*)blitter;

   ctx->has_texture_multisample = supported;

}

static void blitter_set_running_flag(struct blitter_context_priv *ctx)

{

   if (ctx->base.running) {

      _debug_printf("u_blitter:%i: Caught recursion. This is a driver bug.\n",

                    __LINE__);

   }

   ctx->base.running = TRUE;

}

static void blitter_unset_running_flag(struct blitter_context_priv *ctx)

{

   if (!ctx->base.running) {

      _debug_printf("u_blitter:%i: Caught recursion. This is a driver bug.\n",

                    __LINE__);

   }

   ctx->base.running = FALSE;

}

static void blitter_check_saved_vertex_states(struct blitter_context_priv *ctx)

{

   assert(ctx->base.saved_velem_state != INVALID_PTR);

   assert(ctx->base.saved_vs != INVALID_PTR);

   assert(!ctx->has_geometry_shader || ctx->base.saved_gs != INVALID_PTR);

   assert(!ctx->has_tessellation || ctx->base.saved_tcs != INVALID_PTR);

   assert(!ctx->has_tessellation || ctx->base.saved_tes != INVALID_PTR);

   assert(!ctx->has_stream_out || ctx->base.saved_num_so_targets != ~0);

   assert(ctx->base.saved_rs_state != INVALID_PTR);

}

static void blitter_restore_vertex_states(struct blitter_context_priv *ctx)

{

   struct pipe_context *pipe = ctx->base.pipe;

   unsigned i;

   /* Vertex buffer. */

   pipe->set_vertex_buffers(pipe, ctx->base.vb_slot, 1,

                            &ctx->base.saved_vertex_buffer);

   pipe_resource_reference(&ctx->base.saved_vertex_buffer.buffer, NULL);

   /* Vertex elements. */

   pipe->bind_vertex_elements_state(pipe, ctx->base.saved_velem_state);

   ctx->base.saved_velem_state = INVALID_PTR;

   /* Vertex shader. */

   pipe->bind_vs_state(pipe, ctx->base.saved_vs);

   ctx->base.saved_vs = INVALID_PTR;

   /* Geometry shader. */

   if (ctx->has_geometry_shader) {

      pipe->bind_gs_state(pipe, ctx->base.saved_gs);

      ctx->base.saved_gs = INVALID_PTR;

   }

   if (ctx->has_tessellation) {

      pipe->bind_tcs_state(pipe, ctx->base.saved_tcs);

      pipe->bind_tes_state(pipe, ctx->base.saved_tes);

      ctx->base.saved_tcs = INVALID_PTR;

      ctx->base.saved_tes = INVALID_PTR;

   }

   /* Stream outputs. */

   if (ctx->has_stream_out) {

      unsigned offsets[PIPE_MAX_SO_BUFFERS];

      for (i = 0; i < ctx->base.saved_num_so_targets; i++)

         offsets[i] = (unsigned)-1;

      pipe->set_stream_output_targets(pipe,

                                      ctx->base.saved_num_so_targets,

                                      ctx->base.saved_so_targets, offsets);

      for (i = 0; i < ctx->base.saved_num_so_targets; i++)

         pipe_so_target_reference(&ctx->base.saved_so_targets[i], NULL);

      ctx->base.saved_num_so_targets = ~0;

   }

   /* Rasterizer. */

   pipe->bind_rasterizer_state(pipe, ctx->base.saved_rs_state);

   ctx->base.saved_rs_state = INVALID_PTR;

}

static void blitter_check_saved_fragment_states(struct blitter_context_priv *ctx)

{

   assert(ctx->base.saved_fs != INVALID_PTR);

   assert(ctx->base.saved_dsa_state != INVALID_PTR);

   assert(ctx->base.saved_blend_state != INVALID_PTR);

}

static void blitter_restore_fragment_states(struct blitter_context_priv *ctx)

{

   struct pipe_context *pipe = ctx->base.pipe;

   /* Fragment shader. */

   ctx->bind_fs_state(pipe, ctx->base.saved_fs);

   ctx->base.saved_fs = INVALID_PTR;

   /* Depth, stencil, alpha. */

   pipe->bind_depth_stencil_alpha_state(pipe, ctx->base.saved_dsa_state);

   ctx->base.saved_dsa_state = INVALID_PTR;

   /* Blend state. */

   pipe->bind_blend_state(pipe, ctx->base.saved_blend_state);

   ctx->base.saved_blend_state = INVALID_PTR;

   /* Sample mask. */

   if (ctx->base.is_sample_mask_saved) {

      pipe->set_sample_mask(pipe, ctx->base.saved_sample_mask);

      ctx->base.is_sample_mask_saved = FALSE;

   }

   /* Miscellaneous states. */

   /* XXX check whether these are saved and whether they need to be restored

    * (depending on the operation) */

   pipe->set_stencil_ref(pipe, &ctx->base.saved_stencil_ref);

   pipe->set_viewport_states(pipe, 0, 1, &ctx->base.saved_viewport);

}

static void blitter_check_saved_fb_state(struct blitter_context_priv *ctx)

{

   assert(ctx->base.saved_fb_state.nr_cbufs != ~0);

}

static void blitter_disable_render_cond(struct blitter_context_priv *ctx)

{

   struct pipe_context *pipe = ctx->base.pipe;

   if (ctx->base.saved_render_cond_query) {

      pipe->render_condition(pipe, NULL, FALSE, 0);

   }

}

static void blitter_restore_render_cond(struct blitter_context_priv *ctx)

{

   struct pipe_context *pipe = ctx->base.pipe;

   if (ctx->base.saved_render_cond_query) {

      pipe->render_condition(pipe, ctx->base.saved_render_cond_query,

                             ctx->base.saved_render_cond_cond,

                             ctx->base.saved_render_cond_mode);

      ctx->base.saved_render_cond_query = NULL;

   }

}

static void blitter_restore_fb_state(struct blitter_context_priv *ctx)

{

   struct pipe_context *pipe = ctx->base.pipe;

   pipe->set_framebuffer_state(pipe, &ctx->base.saved_fb_state);

   util_unreference_framebuffer_state(&ctx->base.saved_fb_state);

}

static void blitter_check_saved_textures(struct blitter_context_priv *ctx)

{

   assert(ctx->base.saved_num_sampler_states != ~0);

   assert(ctx->base.saved_num_sampler_views != ~0);

}

static void blitter_restore_textures(struct blitter_context_priv *ctx)

{

   struct pipe_context *pipe = ctx->base.pipe;

   unsigned i;

   /* Fragment sampler states. */

   pipe->bind_sampler_states(pipe, PIPE_SHADER_FRAGMENT, 0,

                             ctx->base.saved_num_sampler_states,

                             ctx->base.saved_sampler_states);

   ctx->base.saved_num_sampler_states = ~0;

   /* Fragment sampler views. */

   pipe->set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0,

                           ctx->base.saved_num_sampler_views,

                           ctx->base.saved_sampler_views);

   for (i = 0; i < ctx->base.saved_num_sampler_views; i++)

      pipe_sampler_view_reference(&ctx->base.saved_sampler_views[i], NULL);

   ctx->base.saved_num_sampler_views = ~0;

}

static void blitter_set_rectangle(struct blitter_context_priv *ctx,

                                  int x1, int y1, int x2, int y2,

                                  float depth)

{

   int i;

   /* set vertex positions */

   ctx->vertices[0][0][0] = (float)x1 / ctx->dst_width * 2.0f - 1.0f; /*v0.x*/

   ctx->vertices[0][0][1] = (float)y1 / ctx->dst_height * 2.0f - 1.0f; /*v0.y*/

   ctx->vertices[1][0][0] = (float)x2 / ctx->dst_width * 2.0f - 1.0f; /*v1.x*/

   ctx->vertices[1][0][1] = (float)y1 / ctx->dst_height * 2.0f - 1.0f; /*v1.y*/

   ctx->vertices[2][0][0] = (float)x2 / ctx->dst_width * 2.0f - 1.0f; /*v2.x*/

   ctx->vertices[2][0][1] = (float)y2 / ctx->dst_height * 2.0f - 1.0f; /*v2.y*/

   ctx->vertices[3][0][0] = (float)x1 / ctx->dst_width * 2.0f - 1.0f; /*v3.x*/

   ctx->vertices[3][0][1] = (float)y2 / ctx->dst_height * 2.0f - 1.0f; /*v3.y*/

   for (i = 0; i < 4; i++)

      ctx->vertices[i][0][2] = depth; /*z*/

   /* viewport */

   ctx->viewport.scale[0] = 0.5f * ctx->dst_width;

   ctx->viewport.scale[1] = 0.5f * ctx->dst_height;

   ctx->viewport.scale[2] = 1.0f;

   ctx->viewport.translate[0] = 0.5f * ctx->dst_width;

   ctx->viewport.translate[1] = 0.5f * ctx->dst_height;

   ctx->viewport.translate[2] = 0.0f;

   ctx->base.pipe->set_viewport_states(ctx->base.pipe, 0, 1, &ctx->viewport);

}

static void blitter_set_clear_color(struct blitter_context_priv *ctx,

                                    const union pipe_color_union *color)

{

   int i;

   if (color) {

      for (i = 0; i < 4; i++) {

         uint32_t *uiverts = (uint32_t *)ctx->vertices[i][1];

         uiverts[0] = color->ui[0];

         uiverts[1] = color->ui[1];

         uiverts[2] = color->ui[2];

         uiverts[3] = color->ui[3];

      }

   } else {

      for (i = 0; i < 4; i++) {

         ctx->vertices[i][1][0] = 0;

         ctx->vertices[i][1][1] = 0;

         ctx->vertices[i][1][2] = 0;

         ctx->vertices[i][1][3] = 0;

      }

   }

}

static void get_texcoords(struct pipe_sampler_view *src,

                          unsigned src_width0, unsigned src_height0,

                          int x1, int y1, int x2, int y2,

                          float out[4])

{

   struct pipe_resource *tex = src->texture;

   unsigned level = src->u.tex.first_level;

   boolean normalized = tex->target != PIPE_TEXTURE_RECT &&

                        tex->nr_samples <= 1;

   if (normalized) {

      out[0] = x1 / (float)u_minify(src_width0,  level);

      out[1] = y1 / (float)u_minify(src_height0, level);

      out[2] = x2 / (float)u_minify(src_width0,  level);

      out[3] = y2 / (float)u_minify(src_height0, level);

   } else {

      out[0] = (float) x1;

      out[1] = (float) y1;

      out[2] = (float) x2;

      out[3] = (float) y2;

   }

}

static void set_texcoords_in_vertices(const float coord[4],

                                      float *out, unsigned stride)

{

   out[0] = coord[0]; /*t0.s*/

   out[1] = coord[1]; /*t0.t*/

   out += stride;

   out[0] = coord[2]; /*t1.s*/

   out[1] = coord[1]; /*t1.t*/

   out += stride;

   out[0] = coord[2]; /*t2.s*/

   out[1] = coord[3]; /*t2.t*/

   out += stride;

   out[0] = coord[0]; /*t3.s*/

   out[1] = coord[3]; /*t3.t*/

}

static void blitter_set_texcoords(struct blitter_context_priv *ctx,

                                  struct pipe_sampler_view *src,

                                  unsigned src_width0, unsigned src_height0,

                                  float layer, unsigned sample,

                                  int x1, int y1, int x2, int y2)

{

   unsigned i;

   float coord[4];

   float face_coord[4][2];

   get_texcoords(src, src_width0, src_height0, x1, y1, x2, y2, coord);

   if (src->texture->target == PIPE_TEXTURE_CUBE ||

       src->texture->target == PIPE_TEXTURE_CUBE_ARRAY) {

      set_texcoords_in_vertices(coord, &face_coord[0][0], 2);

      util_map_texcoords2d_onto_cubemap((unsigned)layer % 6,

                                        /* pointer, stride in floats */

                                        &face_coord[0][0], 2,

                                        &ctx->vertices[0][1][0], 8,

                                        FALSE);

   } else {

      set_texcoords_in_vertices(coord, &ctx->vertices[0][1][0], 8);

   }

   /* Set the layer. */

   switch (src->texture->target) {

   case PIPE_TEXTURE_3D:

      {

         float r = layer / (float)u_minify(src->texture->depth0,

                                           src->u.tex.first_level);

         for (i = 0; i < 4; i++)

            ctx->vertices[i][1][2] = r; /*r*/

      }

      break;

   case PIPE_TEXTURE_1D_ARRAY:

      for (i = 0; i < 4; i++)

         ctx->vertices[i][1][1] = (float) layer; /*t*/

      break;

   case PIPE_TEXTURE_2D_ARRAY:

      for (i = 0; i < 4; i++) {

         ctx->vertices[i][1][2] = (float) layer;  /*r*/

         ctx->vertices[i][1][3] = (float) sample; /*q*/

      }

      break;

   case PIPE_TEXTURE_CUBE_ARRAY:

      for (i = 0; i < 4; i++)

         ctx->vertices[i][1][3] = (float) ((unsigned)layer / 6); /*w*/

      break;

   case PIPE_TEXTURE_2D:

      for (i = 0; i < 4; i++) {

         ctx->vertices[i][1][3] = (float) sample; /*r*/

      }

      break;

   default:;

   }

}

static void blitter_set_dst_dimensions(struct blitter_context_priv *ctx,

                                       unsigned width, unsigned height)

{

   ctx->dst_width = width;

   ctx->dst_height = height;

}

static void *blitter_get_fs_texfetch_col(struct blitter_context_priv *ctx,

                                         enum pipe_format format,

                                         enum pipe_texture_target target,

                                         unsigned src_nr_samples,

                                         unsigned dst_nr_samples,

                                         unsigned filter)

{

   struct pipe_context *pipe = ctx->base.pipe;

   unsigned tgsi_tex = util_pipe_tex_to_tgsi_tex(target, src_nr_samples);

   assert(target < PIPE_MAX_TEXTURE_TYPES);

   if (src_nr_samples > 1) {

      void **shader;

      if (dst_nr_samples <= 1) {

         /* The destination has one sample, so we'll do color resolve. */

         boolean is_uint, is_sint;

         unsigned index = GET_MSAA_RESOLVE_FS_IDX(src_nr_samples);

         is_uint = util_format_is_pure_uint(format);

         is_sint = util_format_is_pure_sint(format);

         assert(filter < 2);

         if (is_uint)

            shader = &ctx->fs_resolve_uint[target][index][filter];

         else if (is_sint)

            shader = &ctx->fs_resolve_sint[target][index][filter];

         else

            shader = &ctx->fs_resolve[target][index][filter];

         if (!*shader) {

            assert(!ctx->cached_all_shaders);

            if (filter == PIPE_TEX_FILTER_LINEAR) {

               *shader = util_make_fs_msaa_resolve_bilinear(pipe, tgsi_tex,

                                                   src_nr_samples,

                                                   is_uint, is_sint);

            }

            else {

               *shader = util_make_fs_msaa_resolve(pipe, tgsi_tex,

                                                   src_nr_samples,

                                                   is_uint, is_sint);

            }

         }

      }

      else {

         /* The destination has multiple samples, we'll do

          * an MSAA->MSAA copy.

          */

         shader = &ctx->fs_texfetch_col_msaa[target];

         /* Create the fragment shader on-demand. */

         if (!*shader) {

            assert(!ctx->cached_all_shaders);

            *shader = util_make_fs_blit_msaa_color(pipe, tgsi_tex);

         }

      }

      return *shader;

   } else {

      void **shader = &ctx->fs_texfetch_col[target];

      /* Create the fragment shader on-demand. */

      if (!*shader) {

         assert(!ctx->cached_all_shaders);

         *shader = util_make_fragment_tex_shader(pipe, tgsi_tex,

                                                 TGSI_INTERPOLATE_LINEAR);

      }

      return *shader;

   }

}

static INLINE

void *blitter_get_fs_texfetch_depth(struct blitter_context_priv *ctx,

                                    enum pipe_texture_target target,

                                    unsigned nr_samples)

{

   struct pipe_context *pipe = ctx->base.pipe;

   assert(target < PIPE_MAX_TEXTURE_TYPES);

   if (nr_samples > 1) {

      void **shader = &ctx->fs_texfetch_depth_msaa[target];

      /* Create the fragment shader on-demand. */

      if (!*shader) {

         unsigned tgsi_tex;

         assert(!ctx->cached_all_shaders);

         tgsi_tex = util_pipe_tex_to_tgsi_tex(target, nr_samples);

         *shader = util_make_fs_blit_msaa_depth(pipe, tgsi_tex);

      }

      return *shader;

   } else {

      void **shader = &ctx->fs_texfetch_depth[target];

      /* Create the fragment shader on-demand. */

      if (!*shader) {

         unsigned tgsi_tex;

         assert(!ctx->cached_all_shaders);

         tgsi_tex = util_pipe_tex_to_tgsi_tex(target, 0);

         *shader =

            util_make_fragment_tex_shader_writedepth(pipe, tgsi_tex,

                                                     TGSI_INTERPOLATE_LINEAR);

      }

      return *shader;

   }

}

static INLINE

void *blitter_get_fs_texfetch_depthstencil(struct blitter_context_priv *ctx,

                                           enum pipe_texture_target target,

                                           unsigned nr_samples)

{

   struct pipe_context *pipe = ctx->base.pipe;

   assert(target < PIPE_MAX_TEXTURE_TYPES);

   if (nr_samples > 1) {

      void **shader = &ctx->fs_texfetch_depthstencil_msaa[target];

      /* Create the fragment shader on-demand. */

      if (!*shader) {

         unsigned tgsi_tex;

         assert(!ctx->cached_all_shaders);

         tgsi_tex = util_pipe_tex_to_tgsi_tex(target, nr_samples);

         *shader = util_make_fs_blit_msaa_depthstencil(pipe, tgsi_tex);

      }

      return *shader;

   } else {

      void **shader = &ctx->fs_texfetch_depthstencil[target];

      /* Create the fragment shader on-demand. */

      if (!*shader) {

         unsigned tgsi_tex;

         assert(!ctx->cached_all_shaders);

         tgsi_tex = util_pipe_tex_to_tgsi_tex(target, 0);

         *shader =

            util_make_fragment_tex_shader_writedepthstencil(pipe, tgsi_tex,

                                                     TGSI_INTERPOLATE_LINEAR);

      }

      return *shader;

   }

}

static INLINE

void *blitter_get_fs_texfetch_stencil(struct blitter_context_priv *ctx,

                                      enum pipe_texture_target target,

                                      unsigned nr_samples)

{

   struct pipe_context *pipe = ctx->base.pipe;

   assert(target < PIPE_MAX_TEXTURE_TYPES);

   if (nr_samples > 1) {

      void **shader = &ctx->fs_texfetch_stencil_msaa[target];

      /* Create the fragment shader on-demand. */

      if (!*shader) {

         unsigned tgsi_tex;

         assert(!ctx->cached_all_shaders);

         tgsi_tex = util_pipe_tex_to_tgsi_tex(target, nr_samples);

         *shader = util_make_fs_blit_msaa_stencil(pipe, tgsi_tex);

      }

      return *shader;

   } else {

      void **shader = &ctx->fs_texfetch_stencil[target];

      /* Create the fragment shader on-demand. */

      if (!*shader) {

         unsigned tgsi_tex;

         assert(!ctx->cached_all_shaders);

         tgsi_tex = util_pipe_tex_to_tgsi_tex(target, 0);

         *shader =

            util_make_fragment_tex_shader_writestencil(pipe, tgsi_tex,

                                                       TGSI_INTERPOLATE_LINEAR);

      }

      return *shader;

   }

}

/**

 * Generate and save all fragment shaders that we will ever need for

 * blitting.  Drivers which use the 'draw' fallbacks will typically use

 * this to make sure we generate/use shaders that don't go through the

 * draw module's wrapper functions.

 */

void util_blitter_cache_all_shaders(struct blitter_context *blitter)

{

   struct blitter_context_priv *ctx = (struct blitter_context_priv*)blitter;

   struct pipe_context *pipe = blitter->pipe;

   struct pipe_screen *screen = pipe->screen;

   unsigned samples, j, f, target, max_samples;

   boolean has_arraytex, has_cubearraytex;

   max_samples = ctx->has_texture_multisample ? 2 : 1;

   has_arraytex = screen->get_param(screen,

                                    PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS) != 0;

   has_cubearraytex = screen->get_param(screen,

                                    PIPE_CAP_CUBE_MAP_ARRAY) != 0;

   /* It only matters if i <= 1 or > 1. */

   for (samples = 1; samples <= max_samples; samples++) {

      for (target = PIPE_TEXTURE_1D; target < PIPE_MAX_TEXTURE_TYPES; target++) {

         if (!has_arraytex &&

             (target == PIPE_TEXTURE_1D_ARRAY ||

              target == PIPE_TEXTURE_2D_ARRAY)) {

            continue;

         }

         if (!has_cubearraytex &&

             (target == PIPE_TEXTURE_CUBE_ARRAY))

            continue;

	 if (samples > 1 &&

	     (target != PIPE_TEXTURE_2D &&

	      target != PIPE_TEXTURE_2D_ARRAY))

	    continue;

         /* If samples == 1, the shaders read one texel. If samples >= 1,

          * they read one sample.

          */

         blitter_get_fs_texfetch_col(ctx, PIPE_FORMAT_R32_FLOAT, target,

                                     samples, samples, 0);

         blitter_get_fs_texfetch_depth(ctx, target, samples);

         if (ctx->has_stencil_export) {

            blitter_get_fs_texfetch_depthstencil(ctx, target, samples);

            blitter_get_fs_texfetch_stencil(ctx, target, samples);

         }

         if (samples == 1)

            continue;

         /* MSAA resolve shaders. */

         for (j = 2; j < 32; j++) {

            if (!screen->is_format_supported(screen, PIPE_FORMAT_R32_FLOAT,

                                             target, j,

                                             PIPE_BIND_SAMPLER_VIEW)) {

               continue;

            }

            for (f = 0; f < 2; f++) {

               blitter_get_fs_texfetch_col(ctx, PIPE_FORMAT_R32_FLOAT, target,

                                           j, 1, f);

               blitter_get_fs_texfetch_col(ctx, PIPE_FORMAT_R32_UINT, target,

                                           j, 1, f);

               blitter_get_fs_texfetch_col(ctx, PIPE_FORMAT_R32_SINT, target,

                                           j, 1, f);

            }

         }

      }

   }

   ctx->fs_empty = util_make_empty_fragment_shader(pipe);

   ctx->fs_write_one_cbuf =

      util_make_fragment_passthrough_shader(pipe, TGSI_SEMANTIC_GENERIC,

                                            TGSI_INTERPOLATE_CONSTANT, FALSE);

   ctx->fs_write_all_cbufs =

      util_make_fragment_passthrough_shader(pipe, TGSI_SEMANTIC_GENERIC,

                                            TGSI_INTERPOLATE_CONSTANT, TRUE);

   ctx->cached_all_shaders = TRUE;

}

static void blitter_set_common_draw_rect_state(struct blitter_context_priv *ctx,

                                               boolean scissor,

                                               boolean vs_layered)

{

   struct pipe_context *pipe = ctx->base.pipe;

   pipe->bind_rasterizer_state(pipe, scissor ? ctx->rs_state_scissor

                                             : ctx->rs_state);

   if (vs_layered)

      bind_vs_layered(ctx);

   else

      bind_vs_passthrough(ctx);

   if (ctx->has_geometry_shader)

      pipe->bind_gs_state(pipe, NULL);

   if (ctx->has_tessellation) {

      pipe->bind_tcs_state(pipe, NULL);

      pipe->bind_tes_state(pipe, NULL);

   }