/**************************************************************************
 *
 * Copyright 2010 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.
 *
 **************************************************************************/

#include "pipe/p_screen.h"
#include "util/u_format.h"
#include "util/u_debug.h"
#include "u_caps.h"

/**
 * Iterates over a list of caps checks as defined in u_caps.h. Should
 * all checks pass returns TRUE and out is set to the last element of
 * the list (TERMINATE). Should any check fail returns FALSE and set
 * out to the index of the start of the first failing check.
 */
boolean
util_check_caps_out(struct pipe_screen *screen, const unsigned *list, int *out)
{
   int i, tmpi;
   float tmpf;

   for (i = 0; list[i];) {
      switch(list[i++]) {
      case UTIL_CAPS_CHECK_CAP:
         if (!screen->get_param(screen, list[i++])) {
            *out = i - 2;
            return FALSE;
         }
         break;
      case UTIL_CAPS_CHECK_INT:
         tmpi = screen->get_param(screen, list[i++]);
         if (tmpi < (int)list[i++]) {
            *out = i - 3;
            return FALSE;
         }
         break;
      case UTIL_CAPS_CHECK_FLOAT:
         tmpf = screen->get_paramf(screen, list[i++]);
         if (tmpf < (float)list[i++]) {
            *out = i - 3;
            return FALSE;
         }
         break;
      case UTIL_CAPS_CHECK_FORMAT:
         if (!screen->is_format_supported(screen,
                                          list[i++],
                                          PIPE_TEXTURE_2D,
                                          0,
                                          PIPE_BIND_SAMPLER_VIEW)) {
            *out = i - 2;
            return FALSE;
         }
         break;
      case UTIL_CAPS_CHECK_SHADER:
         tmpi = screen->get_shader_param(screen, list[i] >> 24, list[i] & ((1 << 24) - 1));
         ++i;
         if (tmpi < (int)list[i++]) {
            *out = i - 3;
            return FALSE;
         }
         break;
      case UTIL_CAPS_CHECK_UNIMPLEMENTED:
         *out = i - 1;
         return FALSE;
      default:
         assert(!"Unsupported check");
         return FALSE;
      }
   }

   *out = i;
   return TRUE;
}

/**
 * Iterates over a list of caps checks as defined in u_caps.h.
 * Returns TRUE if all caps checks pass returns FALSE otherwise.
 */
boolean
util_check_caps(struct pipe_screen *screen, const unsigned *list)
{
   int out;
   return util_check_caps_out(screen, list, &out);
}


/*
 * Below follows some demo lists.
 *
 * None of these lists are exhausting lists of what is
 * actually needed to support said API and more here for
 * as example on how to uses the above functions. Especially
 * for DX10 and DX11 where Gallium is missing features.
 */

/* DX 9_1 */
static unsigned caps_dx_9_1[] = {
   UTIL_CHECK_INT(MAX_RENDER_TARGETS, 1),
   UTIL_CHECK_INT(MAX_TEXTURE_2D_LEVELS, 12),    /* 2048 */
   UTIL_CHECK_INT(MAX_TEXTURE_3D_LEVELS, 9),     /* 256 */
   UTIL_CHECK_INT(MAX_TEXTURE_CUBE_LEVELS, 10),  /* 512 */
   UTIL_CHECK_FLOAT(MAX_TEXTURE_ANISOTROPY, 2),
   UTIL_CHECK_TERMINATE
};

/* DX 9_2 */
static unsigned caps_dx_9_2[] = {
   UTIL_CHECK_CAP(OCCLUSION_QUERY),
   UTIL_CHECK_CAP(BLEND_EQUATION_SEPARATE),
   UTIL_CHECK_INT(MAX_RENDER_TARGETS, 1),
   UTIL_CHECK_INT(MAX_TEXTURE_2D_LEVELS, 12),    /* 2048 */
   UTIL_CHECK_INT(MAX_TEXTURE_3D_LEVELS, 9),     /* 256 */
   UTIL_CHECK_INT(MAX_TEXTURE_CUBE_LEVELS, 10),  /* 512 */
   UTIL_CHECK_FLOAT(MAX_TEXTURE_ANISOTROPY, 16),
   UTIL_CHECK_TERMINATE
};

/* DX 9_3 */
static unsigned caps_dx_9_3[] = {
   UTIL_CHECK_CAP(SM3),
 //UTIL_CHECK_CAP(INSTANCING),
   UTIL_CHECK_CAP(OCCLUSION_QUERY),
   UTIL_CHECK_INT(MAX_RENDER_TARGETS, 4),
   UTIL_CHECK_INT(MAX_TEXTURE_2D_LEVELS, 13),    /* 4096 */
   UTIL_CHECK_INT(MAX_TEXTURE_3D_LEVELS, 9),     /* 256 */
   UTIL_CHECK_INT(MAX_TEXTURE_CUBE_LEVELS, 10),  /* 512 */
   UTIL_CHECK_FLOAT(MAX_TEXTURE_ANISOTROPY, 16),
   UTIL_CHECK_TERMINATE
};

/* DX 10 */
static unsigned caps_dx_10[] = {
   UTIL_CHECK_CAP(SM3),
 //UTIL_CHECK_CAP(INSTANCING),
   UTIL_CHECK_CAP(OCCLUSION_QUERY),
   UTIL_CHECK_INT(MAX_RENDER_TARGETS, 8),
   UTIL_CHECK_INT(MAX_TEXTURE_2D_LEVELS, 14),    /* 8192 */
   UTIL_CHECK_INT(MAX_TEXTURE_3D_LEVELS, 12),    /* 2048 */
   UTIL_CHECK_INT(MAX_TEXTURE_CUBE_LEVELS, 14),  /* 8192 */
   UTIL_CHECK_FLOAT(MAX_TEXTURE_ANISOTROPY, 16),
   UTIL_CHECK_UNIMPLEMENTED, /* XXX Unimplemented features in Gallium */
   UTIL_CHECK_TERMINATE
};

/* DX11 */
static unsigned caps_dx_11[] = {
   UTIL_CHECK_CAP(SM3),
 //UTIL_CHECK_CAP(INSTANCING),
   UTIL_CHECK_CAP(OCCLUSION_QUERY),
   UTIL_CHECK_INT(MAX_RENDER_TARGETS, 8),
   UTIL_CHECK_INT(MAX_TEXTURE_2D_LEVELS, 14),    /* 16384 */
   UTIL_CHECK_INT(MAX_TEXTURE_3D_LEVELS, 12),    /* 2048 */
   UTIL_CHECK_INT(MAX_TEXTURE_CUBE_LEVELS, 14),  /* 16384 */
   UTIL_CHECK_FLOAT(MAX_TEXTURE_ANISOTROPY, 16),
   UTIL_CHECK_FORMAT(B8G8R8A8_UNORM),
   UTIL_CHECK_UNIMPLEMENTED, /* XXX Unimplemented features in Gallium */
   UTIL_CHECK_TERMINATE
};

/* OpenGL 2.1 */
static unsigned caps_opengl_2_1[] = {
   UTIL_CHECK_CAP(OCCLUSION_QUERY),
   UTIL_CHECK_CAP(TWO_SIDED_STENCIL),
   UTIL_CHECK_CAP(BLEND_EQUATION_SEPARATE),
   UTIL_CHECK_INT(MAX_RENDER_TARGETS, 2),
   UTIL_CHECK_TERMINATE
};

/* OpenGL 3.0 */
/* UTIL_CHECK_INT(MAX_RENDER_TARGETS, 8), */

/* Shader Model 3 */
static unsigned caps_sm3[] = {
    UTIL_CHECK_SHADER(FRAGMENT, MAX_INSTRUCTIONS, 512),
    UTIL_CHECK_SHADER(FRAGMENT, MAX_INPUTS, 10),
    UTIL_CHECK_SHADER(FRAGMENT, MAX_TEMPS, 32),
    UTIL_CHECK_SHADER(FRAGMENT, MAX_CONST_BUFFER_SIZE, 224 * 16),

    UTIL_CHECK_SHADER(VERTEX, MAX_INSTRUCTIONS, 512),
    UTIL_CHECK_SHADER(VERTEX, MAX_INPUTS, 16),
    UTIL_CHECK_SHADER(VERTEX, MAX_TEMPS, 32),
    UTIL_CHECK_SHADER(VERTEX, MAX_CONST_BUFFER_SIZE, 256 * 16),

    UTIL_CHECK_TERMINATE
};

/**
 * Demo function which checks against theoretical caps needed for different APIs.
 */
void util_caps_demo_print(struct pipe_screen *screen)
{
   struct {
      char* name;
      unsigned *list;
   } list[] = {
      {"DX 9.1", caps_dx_9_1},
      {"DX 9.2", caps_dx_9_2},
      {"DX 9.3", caps_dx_9_3},
      {"DX 10", caps_dx_10},
      {"DX 11", caps_dx_11},
      {"OpenGL 2.1", caps_opengl_2_1},
/*    {"OpenGL 3.0", caps_opengl_3_0},*/
      {"SM3", caps_sm3},
      {NULL, NULL}
   };
   int i, out = 0;

   for (i = 0; list[i].name; i++) {
      if (util_check_caps_out(screen, list[i].list, &out)) {
         debug_printf("%s: %s yes\n", __FUNCTION__, list[i].name);
         continue;
      }
      switch (list[i].list[out]) {
      case UTIL_CAPS_CHECK_CAP:
         debug_printf("%s: %s no (cap %u not supported)\n", __FUNCTION__,
                      list[i].name,
                      list[i].list[out + 1]);
         break;
      case UTIL_CAPS_CHECK_INT:
         debug_printf("%s: %s no (cap %u less then %u)\n", __FUNCTION__,
                      list[i].name,
                      list[i].list[out + 1],
                      list[i].list[out + 2]);
         break;
      case UTIL_CAPS_CHECK_FLOAT:
         debug_printf("%s: %s no (cap %u less then %f)\n", __FUNCTION__,
                      list[i].name,
                      list[i].list[out + 1],
                      (double)(int)list[i].list[out + 2]);
         break;
      case UTIL_CAPS_CHECK_FORMAT:
         debug_printf("%s: %s no (format %s not supported)\n", __FUNCTION__,
                      list[i].name,
                      util_format_name(list[i].list[out + 1]) + 12);
         break;
      case UTIL_CAPS_CHECK_UNIMPLEMENTED:
         debug_printf("%s: %s no (not implemented in gallium or state tracker)\n",
                      __FUNCTION__, list[i].name);
         break;
      default:
            assert(!"Unsupported check");
      }
   }
}
