src/mesa/main/pipelineobj.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright © 2013 Gregory Hainaut <gregory.hainaut@gmail.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the next
  14  * paragraph) shall be included in all copies or substantial portions of the
  15  * Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  22  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  23  * IN THE SOFTWARE.
  24  */
  25
  26 /**
  27  * \file pipelineobj.c
  28  * \author Hainaut Gregory <gregory.hainaut@gmail.com>
  29  *
  30  * Implementation of pipeline object related API functions. Based on
  31  * GL_ARB_separate_shader_objects extension.
  32  */
  33
  34 #include "main/glheader.h"
  35 #include "main/context.h"
  36 #include "main/dispatch.h"
  37 #include "main/enums.h"
  38 #include "main/hash.h"
  39 #include "main/mtypes.h"
  40 #include "main/pipelineobj.h"
  41 #include "main/shaderapi.h"
  42 #include "main/shaderobj.h"
  43 #include "main/transformfeedback.h"
  44 #include "main/uniforms.h"
  45 #include "program/program.h"
  46 #include "program/prog_parameter.h"
  47 #include "ralloc.h"
  48 #include <stdbool.h>
  49 #include "../glsl/glsl_parser_extras.h"
  50 #include "../glsl/ir_uniform.h"
  51
  52 /**
  53  * Delete a pipeline object.
  54  */
  55 void
  56 _mesa_delete_pipeline_object(struct gl_context *ctx,
  57                              struct gl_pipeline_object *obj)
  58 {
  59    unsigned i;
  60
  61    _mesa_reference_shader_program(ctx, &obj->_CurrentFragmentProgram, NULL);
  62
  63    for (i = 0; i < MESA_SHADER_STAGES; i++)
  64       _mesa_reference_shader_program(ctx, &obj->CurrentProgram[i], NULL);
  65
  66    _mesa_reference_shader_program(ctx, &obj->ActiveProgram, NULL);
  67    _glthread_DESTROY_MUTEX(obj->Mutex);
  68    ralloc_free(obj);
  69 }
  70
  71 /**
  72  * Allocate and initialize a new pipeline object.
  73  */
  74 static struct gl_pipeline_object *
  75 _mesa_new_pipeline_object(struct gl_context *ctx, GLuint name)
  76 {
  77    struct gl_pipeline_object *obj = rzalloc(NULL, struct gl_pipeline_object);
  78    if (obj) {
  79       obj->Name = name;
  80       _glthread_INIT_MUTEX(obj->Mutex);
  81       obj->RefCount = 1;
  82       obj->Flags = _mesa_get_shader_flags();
  83    }
  84
  85    return obj;
  86 }
  87
  88 /**
  89  * Initialize pipeline object state for given context.
  90  */
  91 void
  92 _mesa_init_pipeline(struct gl_context *ctx)
  93 {
  94    ctx->Pipeline.Objects = _mesa_NewHashTable();
  95
  96    ctx->Pipeline.Current = NULL;
  97 }
  98
  99
 100 /**
 101  * Callback for deleting a pipeline object.  Called by _mesa_HashDeleteAll().
 102  */
 103 static void
 104 delete_pipelineobj_cb(GLuint id, void *data, void *userData)
 105 {
 106    struct gl_pipeline_object *obj = (struct gl_pipeline_object *) data;
 107    struct gl_context *ctx = (struct gl_context *) userData;
 108    _mesa_delete_pipeline_object(ctx, obj);
 109 }
 110
 111
 112 /**
 113  * Free pipeline state for given context.
 114  */
 115 void
 116 _mesa_free_pipeline_data(struct gl_context *ctx)
 117 {
 118    _mesa_HashDeleteAll(ctx->Pipeline.Objects, delete_pipelineobj_cb, ctx);
 119    _mesa_DeleteHashTable(ctx->Pipeline.Objects);
 120 }
 121
 122 /**
 123  * Look up the pipeline object for the given ID.
 124  *
 125  * \returns
 126  * Either a pointer to the pipeline object with the specified ID or \c NULL for
 127  * a non-existent ID.  The spec defines ID 0 as being technically
 128  * non-existent.
 129  */
 130 static inline struct gl_pipeline_object *
 131 lookup_pipeline_object(struct gl_context *ctx, GLuint id)
 132 {
 133    if (id == 0)
 134       return NULL;
 135    else
 136       return (struct gl_pipeline_object *)
 137          _mesa_HashLookup(ctx->Pipeline.Objects, id);
 138 }
 139
 140 /**
 141  * Add the given pipeline object to the pipeline object pool.
 142  */
 143 static void
 144 save_pipeline_object(struct gl_context *ctx, struct gl_pipeline_object *obj)
 145 {
 146    if (obj->Name > 0) {
 147       _mesa_HashInsert(ctx->Pipeline.Objects, obj->Name, obj);
 148    }
 149 }
 150
 151 /**
 152  * Remove the given pipeline object from the pipeline object pool.
 153  * Do not deallocate the pipeline object though.
 154  */
 155 static void
 156 remove_pipeline_object(struct gl_context *ctx, struct gl_pipeline_object *obj)
 157 {
 158    if (obj->Name > 0) {
 159       _mesa_HashRemove(ctx->Pipeline.Objects, obj->Name);
 160    }
 161 }
 162
 163 /**
 164  * Set ptr to obj w/ reference counting.
 165  * Note: this should only be called from the _mesa_reference_pipeline_object()
 166  * inline function.
 167  */
 168 void
 169 _mesa_reference_pipeline_object_(struct gl_context *ctx,
 170                                  struct gl_pipeline_object **ptr,
 171                                  struct gl_pipeline_object *obj)
 172 {
 173    assert(*ptr != obj);
 174
 175    if (*ptr) {
 176       /* Unreference the old pipeline object */
 177       GLboolean deleteFlag = GL_FALSE;
 178       struct gl_pipeline_object *oldObj = *ptr;
 179
 180       _glthread_LOCK_MUTEX(oldObj->Mutex);
 181       ASSERT(oldObj->RefCount > 0);
 182       oldObj->RefCount--;
 183       deleteFlag = (oldObj->RefCount == 0);
 184       _glthread_UNLOCK_MUTEX(oldObj->Mutex);
 185
 186       if (deleteFlag) {
 187          _mesa_delete_pipeline_object(ctx, oldObj);
 188       }
 189
 190       *ptr = NULL;
 191    }
 192    ASSERT(!*ptr);
 193
 194    if (obj) {
 195       /* reference new pipeline object */
 196       _glthread_LOCK_MUTEX(obj->Mutex);
 197       if (obj->RefCount == 0) {
 198          /* this pipeline's being deleted (look just above) */
 199          /* Not sure this can ever really happen.  Warn if it does. */
 200          _mesa_problem(NULL, "referencing deleted pipeline object");
 201          *ptr = NULL;
 202       }
 203       else {
 204          obj->RefCount++;
 205          *ptr = obj;
 206       }
 207       _glthread_UNLOCK_MUTEX(obj->Mutex);
 208    }
 209 }
 210
 211 /**
 212  * Bound program to severals stages of the pipeline
 213  */
 214 void GLAPIENTRY
 215 _mesa_UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
 216 {
 217 }
 218
 219 /**
 220  * Use the named shader program for subsequent glUniform calls (if pipeline
 221  * bound)
 222  */
 223 void GLAPIENTRY
 224 _mesa_ActiveShaderProgram(GLuint pipeline, GLuint program)
 225 {
 226    GET_CURRENT_CONTEXT(ctx);
 227    struct gl_shader_program *shProg = NULL;
 228    struct gl_pipeline_object *pipe = lookup_pipeline_object(ctx, pipeline);
 229
 230    if (program != 0) {
 231       shProg = _mesa_lookup_shader_program_err(ctx, program,
 232                                                "glActiveShaderProgram(program)");
 233       if (shProg == NULL)
 234          return;
 235    }
 236
 237    if (!pipe) {
 238       _mesa_error(ctx, GL_INVALID_OPERATION, "glActiveShaderProgram(pipeline)");
 239       return;
 240    }
 241
 242    /* Object is created by any Pipeline call but glGenProgramPipelines,
 243     * glIsProgramPipeline and GetProgramPipelineInfoLog
 244     */
 245    pipe->EverBound = GL_TRUE;
 246
 247    if ((shProg != NULL) && !shProg->LinkStatus) {
 248       _mesa_error(ctx, GL_INVALID_OPERATION,
 249             "glActiveShaderProgram(program %u not linked)", shProg->Name);
 250       return;
 251    }
 252
 253    _mesa_reference_shader_program(ctx, &pipe->ActiveProgram, shProg);
 254 }
 255
 256 /**
 257  * Make program of the pipeline current
 258  */
 259 void GLAPIENTRY
 260 _mesa_BindProgramPipeline(GLuint pipeline)
 261 {
 262 }
 263
 264 /**
 265  * Delete a set of pipeline objects.
 266  *
 267  * \param n      Number of pipeline objects to delete.
 268  * \param ids    pipeline of \c n pipeline object IDs.
 269  */
 270 void GLAPIENTRY
 271 _mesa_DeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
 272 {
 273    GET_CURRENT_CONTEXT(ctx);
 274    GLsizei i;
 275
 276    if (n < 0) {
 277       _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteProgramPipelines(n<0)");
 278       return;
 279    }
 280
 281    for (i = 0; i < n; i++) {
 282       struct gl_pipeline_object *obj =
 283          lookup_pipeline_object(ctx, pipelines[i]);
 284
 285       if (obj) {
 286          ASSERT(obj->Name == pipelines[i]);
 287
 288          /* If the pipeline object is currently bound, the spec says "If an
 289           * object that is currently bound is deleted, the binding for that
 290           * object reverts to zero and no program pipeline object becomes
 291           * current."
 292           */
 293          if (obj == ctx->Pipeline.Current) {
 294             _mesa_BindProgramPipeline(0);
 295          }
 296
 297          /* The ID is immediately freed for re-use */
 298          remove_pipeline_object(ctx, obj);
 299
 300          /* Unreference the pipeline object.
 301           * If refcount hits zero, the object will be deleted.
 302           */
 303          _mesa_reference_pipeline_object(ctx, &obj, NULL);
 304       }
 305    }
 306 }
 307
 308 /**
 309  * Generate a set of unique pipeline object IDs and store them in \c pipelines.
 310  * \param n       Number of IDs to generate.
 311  * \param pipelines  pipeline of \c n locations to store the IDs.
 312  */
 313 void GLAPIENTRY
 314 _mesa_GenProgramPipelines(GLsizei n, GLuint *pipelines)
 315 {
 316    GET_CURRENT_CONTEXT(ctx);
 317
 318    GLuint first;
 319    GLint i;
 320
 321    if (n < 0) {
 322       _mesa_error(ctx, GL_INVALID_VALUE, "glGenProgramPipelines(n<0)");
 323       return;
 324    }
 325
 326    if (!pipelines) {
 327       return;
 328    }
 329
 330    first = _mesa_HashFindFreeKeyBlock(ctx->Pipeline.Objects, n);
 331
 332    for (i = 0; i < n; i++) {
 333       struct gl_pipeline_object *obj;
 334       GLuint name = first + i;
 335
 336       obj = _mesa_new_pipeline_object(ctx, name);
 337       if (!obj) {
 338          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenProgramPipelines");
 339          return;
 340       }
 341
 342       save_pipeline_object(ctx, obj);
 343       pipelines[i] = first + i;
 344    }
 345
 346 }
 347
 348 /**
 349  * Determine if ID is the name of an pipeline object.
 350  *
 351  * \param id  ID of the potential pipeline object.
 352  * \return  \c GL_TRUE if \c id is the name of a pipeline object,
 353  *          \c GL_FALSE otherwise.
 354  */
 355 GLboolean GLAPIENTRY
 356 _mesa_IsProgramPipeline(GLuint pipeline)
 357 {
 358    GET_CURRENT_CONTEXT(ctx);
 359
 360    struct gl_pipeline_object *obj = lookup_pipeline_object(ctx, pipeline);
 361    if (obj == NULL)
 362       return GL_FALSE;
 363
 364    return obj->EverBound;
 365 }
 366
 367 /**
 368  * glGetProgramPipelineiv() - get pipeline shader state.
 369  */
 370 void GLAPIENTRY
 371 _mesa_GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
 372 {
 373    GET_CURRENT_CONTEXT(ctx);
 374    struct gl_pipeline_object *pipe = lookup_pipeline_object(ctx, pipeline);
 375
 376    /* Are geometry shaders available in this context?
 377     */
 378    const bool has_gs = _mesa_has_geometry_shaders(ctx);
 379
 380    if (!pipe) {
 381       _mesa_error(ctx, GL_INVALID_OPERATION,
 382                   "glGetProgramPipelineiv(pipeline)");
 383       return;
 384    }
 385
 386    /* Object is created by any Pipeline call but glGenProgramPipelines,
 387     * glIsProgramPipeline and GetProgramPipelineInfoLog
 388     */
 389    pipe->EverBound = GL_TRUE;
 390
 391    switch (pname) {
 392    case GL_ACTIVE_PROGRAM:
 393       *params = pipe->ActiveProgram ? pipe->ActiveProgram->Name : 0;
 394       return;
 395    case GL_INFO_LOG_LENGTH:
 396       /* FINISHME: Implement the info log.
 397        */
 398       *params = 0;
 399       return;
 400    case GL_VALIDATE_STATUS:
 401       /* FINISHME: Implement validation status.
 402        */
 403       *params = 0;
 404       return;
 405    case GL_VERTEX_SHADER:
 406       *params = pipe->CurrentProgram[MESA_SHADER_VERTEX]
 407          ? pipe->CurrentProgram[MESA_SHADER_VERTEX]->Name : 0;
 408       return;
 409    case GL_TESS_EVALUATION_SHADER:
 410       /* NOT YET SUPPORTED */
 411       break;
 412    case GL_TESS_CONTROL_SHADER:
 413       /* NOT YET SUPPORTED */
 414       break;
 415    case GL_GEOMETRY_SHADER:
 416       if (!has_gs)
 417          break;
 418       *params = pipe->CurrentProgram[MESA_SHADER_GEOMETRY]
 419          ? pipe->CurrentProgram[MESA_SHADER_GEOMETRY]->Name : 0;
 420       return;
 421    case GL_FRAGMENT_SHADER:
 422       *params = pipe->CurrentProgram[MESA_SHADER_FRAGMENT]
 423          ? pipe->CurrentProgram[MESA_SHADER_FRAGMENT]->Name : 0;
 424       return;
 425    default:
 426       break;
 427    }
 428
 429    _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramPipelineiv(pname=%s)",
 430                _mesa_lookup_enum_by_nr(pname));
 431 }
 432
 433 /**
 434  * Check compatibility of pipeline's program
 435  */
 436 void GLAPIENTRY
 437 _mesa_ValidateProgramPipeline(GLuint pipeline)
 438 {
 439 }
 440
 441 void GLAPIENTRY
 442 _mesa_GetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize,
 443                                 GLsizei *length, GLchar *infoLog)
 444 {
 445 }