text: /**************************************************************************
   *
   * Copyright 2009 VMware, Inc.
   * All Rights Reserved.
   *
   * 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
   * Blend LLVM IR generation -- AoS layout.
   *
   * AoS blending is in general much slower than SoA, but there are some cases
   * where it might be faster. In particular, if a pixel is rendered only once
   * then the overhead of tiling and untiling will dominate over the speedup that
   * SoA gives. So we might want to detect such cases and fallback to AoS in the
   * future, but for now this function is here for historical/benchmarking
   * purposes.
   *
   * Run lp_blend_test after any change to this file.
   *
   * @author Jose Fonseca <jfonseca@vmware.com>
   */
  
  
  #include "pipe/p_state.h"
  #include "util/u_debug.h"
  #include "util/u_format.h"
  
  #include "gallivm/lp_bld_type.h"
  #include "gallivm/lp_bld_const.h"
  #include "gallivm/lp_bld_arit.h"
  #include "gallivm/lp_bld_logic.h"
  #include "gallivm/lp_bld_swizzle.h"
  #include "gallivm/lp_bld_bitarit.h"
  #include "gallivm/lp_bld_debug.h"
  
  #include "lp_bld_blend.h"
  
  
  /**
   * We may the same values several times, so we keep them here to avoid
   * recomputing them. Also reusing the values allows us to do simplifications
   * that LLVM optimization passes wouldn't normally be able to do.
   */
  struct lp_build_blend_aos_context
  {
     struct lp_build_context base;
     
     LLVMValueRef src;
     LLVMValueRef dst;
     LLVMValueRef const_;
  
     LLVMValueRef inv_src;
     LLVMValueRef inv_dst;
     LLVMValueRef inv_const;
     LLVMValueRef saturate;
  
     LLVMValueRef rgb_src_factor;
     LLVMValueRef alpha_src_factor;
     LLVMValueRef rgb_dst_factor;
     LLVMValueRef alpha_dst_factor;
  };
  
  
  static LLVMValueRef
  lp_build_blend_factor_unswizzled(struct lp_build_blend_aos_context *bld,
                                   unsigned factor,
                                   boolean alpha)
  {
     switch (factor) {
     case PIPE_BLENDFACTOR_ZERO:
        return bld->base.zero;
     case PIPE_BLENDFACTOR_ONE:
        return bld->base.one;
     case PIPE_BLENDFACTOR_SRC_COLOR:
     case PIPE_BLENDFACTOR_SRC_ALPHA:
        return bld->src;
     case PIPE_BLENDFACTOR_DST_COLOR:
     case PIPE_BLENDFACTOR_DST_ALPHA:
        return bld->dst;
     case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
        if(alpha)
           return bld->base.one;
        else {
           if(!bld->inv_dst)
              bld->inv_dst = lp_build_comp(&bld->base, bld->dst);
           if(!bld->saturate)
              bld->saturate = lp_build_min(&bld->base, bld->src, bld->inv_dst);
           return bld->saturate;
        }
     case PIPE_BLENDFACTOR_CONST_COLOR:
     case PIPE_BLENDFACTOR_CONST_ALPHA:
        return bld->const_;
     case PIPE_BLENDFACTOR_SRC1_COLOR:
     case PIPE_BLENDFACTOR_SRC1_ALPHA:
        /* TODO */
        assert(0);
        return bld->base.zero;
     case PIPE_BLENDFACTOR_INV_SRC_COLOR:
     case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
        if(!bld->inv_src)
           bld->inv_src = lp_build_comp(&bld->base, bld->src);
        return bld->inv_src;
     case PIPE_BLENDFACTOR_INV_DST_COLOR:
     case PIPE_BLENDFACTOR_INV_DST_ALPHA:
        if(!bld->inv_dst)
           bld->inv_dst = lp_build_comp(&bld->base, bld->dst);
        return bld->inv_dst;
     case PIPE_BLENDFACTOR_INV_CONST_COLOR:
     case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
        if(!bld->inv_const)
           bld->inv_const = lp_build_comp(&bld->base, bld->const_);
        return bld->inv_const;
     case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
     case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
        /* TODO */
        assert(0);
        return bld->base.zero;
     default:
        assert(0);
        return bld->base.zero;
     }
  }
  
  
  enum lp_build_blend_swizzle {
     LP_BUILD_BLEND_SWIZZLE_RGBA = 0,
     LP_BUILD_BLEND_SWIZZLE_AAAA = 1
  };
  
  
  /**
   * How should we shuffle the base factor.
   */
  static enum lp_build_blend_swizzle
  lp_build_blend_factor_swizzle(unsigned factor)
  {
     switch (factor) {
     case PIPE_BLENDFACTOR_ONE:
     case PIPE_BLENDFACTOR_ZERO:
     case PIPE_BLENDFACTOR_SRC_COLOR:
     case PIPE_BLENDFACTOR_DST_COLOR:
     case PIPE_BLENDFACTOR_CONST_COLOR:
     case PIPE_BLENDFACTOR_SRC1_COLOR:
     case PIPE_BLENDFACTOR_INV_SRC_COLOR:
     case PIPE_BLENDFACTOR_INV_DST_COLOR:
     case PIPE_BLENDFACTOR_INV_CONST_COLOR:
     case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
        return LP_BUILD_BLEND_SWIZZLE_RGBA;
     case PIPE_BLENDFACTOR_SRC_ALPHA:
     case PIPE_BLENDFACTOR_DST_ALPHA:
     case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
     case PIPE_BLENDFACTOR_SRC1_ALPHA:
     case PIPE_BLENDFACTOR_CONST_ALPHA:
     case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
     case PIPE_BLENDFACTOR_INV_DST_ALPHA:
     case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
     case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
        return LP_BUILD_BLEND_SWIZZLE_AAAA;
     default:
        assert(0);
        return LP_BUILD_BLEND_SWIZZLE_RGBA;
     }
  }
  
  
  static LLVMValueRef
  lp_build_blend_swizzle(struct lp_build_blend_aos_context *bld,
                         LLVMValueRef rgb, 
                         LLVMValueRef alpha, 
                         enum lp_build_blend_swizzle rgb_swizzle,
                         unsigned alpha_swizzle)
  {
     LLVMValueRef swizzled_rgb;
  
     switch (rgb_swizzle) {
     case LP_BUILD_BLEND_SWIZZLE_RGBA:
        swizzled_rgb = rgb;
        break;
     case LP_BUILD_BLEND_SWIZZLE_AAAA:
        swizzled_rgb = lp_build_swizzle_scalar_aos(&bld->base, rgb, alpha_swizzle);
        break;
     default:
        assert(0);
        swizzled_rgb = bld->base.undef;
     }
  
     if (rgb != alpha) {
        swizzled_rgb = lp_build_select_aos(&bld->base, 1 << alpha_swizzle,
                                           alpha, swizzled_rgb);
     }
  
     return swizzled_rgb;
  }
  
  
  /**
   * @sa http://www.opengl.org/sdk/docs/man/xhtml/glBlendFuncSeparate.xml
   */
  static LLVMValueRef
  lp_build_blend_factor(struct lp_build_blend_aos_context *bld,
                        unsigned rgb_factor,
                        unsigned alpha_factor,
                        unsigned alpha_swizzle)
  {
     LLVMValueRef rgb_factor_, alpha_factor_;
     enum lp_build_blend_swizzle rgb_swizzle;
  
     rgb_factor_ = lp_build_blend_factor_unswizzled(bld, rgb_factor, FALSE);
  
     if (alpha_swizzle != UTIL_FORMAT_SWIZZLE_NONE) {
        rgb_swizzle   = lp_build_blend_factor_swizzle(rgb_factor);
        alpha_factor_ = lp_build_blend_factor_unswizzled(bld, alpha_factor, TRUE);
        return lp_build_blend_swizzle(bld, rgb_factor_, alpha_factor_, rgb_swizzle, alpha_swizzle);
     } else {
        return rgb_factor_;
     }
  }
  
  
  /**
   * Performs blending of src and dst pixels
   *
   * @param blend         the blend state of the shader variant
   * @param cbuf_format   format of the colour buffer
   * @param type          data type of the pixel vector
   * @param rt            rt number
   * @param src           blend src
   * @param dst           blend dst
   * @param mask          optional mask to apply to the blending result
   * @param const_        const blend color
   * @param swizzle       swizzle values for RGBA
   *
   * @return the result of blending src and dst
   */
  LLVMValueRef
  lp_build_blend_aos(struct gallivm_state *gallivm,
                     const struct pipe_blend_state *blend,
                     const enum pipe_format *cbuf_format,
                     struct lp_type type,
                     unsigned rt,
                     LLVMValueRef src,
                     LLVMValueRef dst,
                     LLVMValueRef mask,
                     LLVMValueRef const_,
                     const unsigned char swizzle[4])
  {
     const struct pipe_rt_blend_state * state = &blend->rt[rt];
     struct lp_build_blend_aos_context bld;
     LLVMValueRef src_factor, dst_factor;
     LLVMValueRef result;
     unsigned alpha_swizzle = swizzle[3];
     boolean fullcolormask;
  
     /* Setup build context */
     memset(&bld, 0, sizeof bld);
     lp_build_context_init(&bld.base, gallivm, type);
     bld.src = src;
     bld.dst = dst;
     bld.const_ = const_;
  
     if (swizzle[3] > UTIL_FORMAT_SWIZZLE_W || swizzle[3] == swizzle[0])
        alpha_swizzle = UTIL_FORMAT_SWIZZLE_NONE;
  
     if (!state->blend_enable) {
        result = src;
     } else {
        boolean rgb_alpha_same = state->rgb_src_factor == state->rgb_dst_factor && state->alpha_src_factor == state->alpha_dst_factor;
        assert(rgb_alpha_same || alpha_swizzle != UTIL_FORMAT_SWIZZLE_NONE);
  
        src_factor = lp_build_blend_factor(&bld, state->rgb_src_factor,
                                           state->alpha_src_factor, alpha_swizzle);
        dst_factor = lp_build_blend_factor(&bld, state->rgb_dst_factor,
                                           state->alpha_dst_factor, alpha_swizzle);
  
        result = lp_build_blend(&bld.base,
                                state->rgb_func,
                                state->rgb_src_factor,
                                state->rgb_dst_factor,
                                src,
                                dst,
                                src_factor,
                                dst_factor,
                                rgb_alpha_same,
                                false);
  
        if(state->rgb_func != state->alpha_func && alpha_swizzle != UTIL_FORMAT_SWIZZLE_NONE) {
           LLVMValueRef alpha;
  
           alpha = lp_build_blend(&bld.base,
                                  state->alpha_func,
                                  state->alpha_src_factor,
                                  state->alpha_dst_factor,
                                  src,
                                  dst,
                                  src_factor,
                                  dst_factor,
                                  rgb_alpha_same,
                                  false);
  
           result = lp_build_blend_swizzle(&bld,
                                           result,
                                           alpha,
                                           LP_BUILD_BLEND_SWIZZLE_RGBA,
                                           alpha_swizzle);
        }
     }
  
     /* Check if color mask is necessary */
     fullcolormask = util_format_colormask_full(util_format_description(cbuf_format[rt]), state->colormask);
  
     if (!fullcolormask) {
        LLVMValueRef color_mask;
  
        color_mask = lp_build_const_mask_aos_swizzled(gallivm, bld.base.type, state->colormask, swizzle);
        lp_build_name(color_mask, "color_mask");
  
        /* Combine with input mask if necessary */
        if (mask) {
           mask = lp_build_and(&bld.base, color_mask, mask);
        } else {
           mask = color_mask;
        }
     }
  
     /* Apply mask, if one exists */
     if (mask) {
        result = lp_build_select(&bld.base, mask, result, dst);
     }
  
     return result;
  }
  