src/gallium/state_trackers/osmesa/osmesa.c

   1 /*
   2  * Copyright (c) 2013  Brian Paul   All Rights Reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included
  12  * in all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  18  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  19  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  20  */
  21
  22
  23 /*
  24  * Off-Screen rendering into client memory.
  25  * State tracker for gallium (for softpipe and llvmpipe)
  26  *
  27  * Notes:
  28  *
  29  * If Gallium is built with LLVM support we use the llvmpipe driver.
  30  * Otherwise we use softpipe.  The GALLIUM_DRIVER environment variable
  31  * may be set to "softpipe" or "llvmpipe" to override.
  32  *
  33  * With softpipe we could render directly into the user's buffer by using a
  34  * display target resource.  However, softpipe doesn't suport "upside-down"
  35  * rendering which would be needed for the OSMESA_Y_UP=TRUE case.
  36  *
  37  * With llvmpipe we could only render directly into the user's buffer when its
  38  * width and height is a multiple of the tile size (64 pixels).
  39  *
  40  * Because of these constraints we always render into ordinary resources then
  41  * copy the results to the user's buffer in the flush_front() function which
  42  * is called when the app calls glFlush/Finish.
  43  *
  44  * In general, the OSMesa interface is pretty ugly and not a good match
  45  * for Gallium.  But we're interested in doing the best we can to preserve
  46  * application portability.  With a little work we could come up with a
  47  * much nicer, new off-screen Gallium interface...
  48  */
  49
  50
  51 #include "GL/osmesa.h"
  52
  53 #include "glapi/glapi.h"  /* for OSMesaGetProcAddress below */
  54
  55 #include "pipe/p_context.h"
  56 #include "pipe/p_screen.h"
  57 #include "pipe/p_state.h"
  58
  59 #include "util/u_atomic.h"
  60 #include "util/u_box.h"
  61 #include "util/u_format.h"
  62 #include "util/u_memory.h"
  63
  64 #include "state_tracker/st_api.h"
  65 #include "state_tracker/st_gl_api.h"
  66
  67
  68
  69 extern struct pipe_screen *
  70 osmesa_create_screen(void);
  71
  72
  73
  74 struct osmesa_buffer
  75 {
  76    struct st_framebuffer_iface *stfb;
  77    struct st_visual visual;
  78    unsigned width, height;
  79
  80    struct pipe_resource *textures[ST_ATTACHMENT_COUNT];
  81
  82    void *map;
  83
  84    struct osmesa_buffer *next;  /**< next in linked list */
  85 };
  86
  87
  88 struct osmesa_context
  89 {
  90    struct st_context_iface *stctx;
  91
  92    struct osmesa_buffer *current_buffer;
  93
  94    enum pipe_format depth_stencil_format, accum_format;
  95
  96    GLenum format;         /*< User-specified context format */
  97    GLenum type;           /*< Buffer's data type */
  98    GLint user_row_length; /*< user-specified number of pixels per row */
  99    GLboolean y_up;        /*< TRUE  -> Y increases upward */
 100                           /*< FALSE -> Y increases downward */
 101 };
 102
 103
 104 /**
 105  * Linked list of all osmesa_buffers.
 106  * We can re-use an osmesa_buffer from one OSMesaMakeCurrent() call to
 107  * the next unless the color/depth/stencil/accum formats change.
 108  * We have to do this to be compatible with the original OSMesa implementation
 109  * because some apps call OSMesaMakeCurrent() several times during rendering
 110  * a frame.
 111  */
 112 static struct osmesa_buffer *BufferList = NULL;
 113
 114
 115 /**
 116  * Called from the ST manager.
 117  */
 118 static int
 119 osmesa_st_get_param(struct st_manager *smapi, enum st_manager_param param)
 120 {
 121    /* no-op */
 122    return 0;
 123 }
 124
 125
 126 /**
 127  * Create/return singleton st_api object.
 128  */
 129 static struct st_api *
 130 get_st_api(void)
 131 {
 132    static struct st_api *stapi = NULL;
 133    if (!stapi) {
 134       stapi = st_gl_api_create();
 135    }
 136    return stapi;
 137 }
 138
 139
 140 /**
 141  * Create/return a singleton st_manager object.
 142  */
 143 static struct st_manager *
 144 get_st_manager(void)
 145 {
 146    static struct st_manager *stmgr = NULL;
 147    if (!stmgr) {
 148       stmgr = CALLOC_STRUCT(st_manager);
 149       if (stmgr) {
 150          stmgr->screen = osmesa_create_screen();
 151          stmgr->get_param = osmesa_st_get_param;
 152          stmgr->get_egl_image = NULL;
 153       }
 154    }
 155    return stmgr;
 156 }
 157
 158
 159 static INLINE boolean
 160 little_endian(void)
 161 {
 162    const unsigned ui = 1;
 163    return *((const char *) &ui);
 164 }
 165
 166
 167 /**
 168  * Given an OSMESA_x format and a GL_y type, return the best
 169  * matching PIPE_FORMAT_z.
 170  * Note that we can't exactly match all user format/type combinations
 171  * with gallium formats.  If we find this to be a problem, we can
 172  * implement more elaborate format/type conversion in the flush_front()
 173  * function.
 174  */
 175 static enum pipe_format
 176 osmesa_choose_format(GLenum format, GLenum type)
 177 {
 178    switch (format) {
 179    case OSMESA_RGBA:
 180       if (type == GL_UNSIGNED_BYTE) {
 181          if (little_endian())
 182             return PIPE_FORMAT_R8G8B8A8_UNORM;
 183          else
 184             return PIPE_FORMAT_A8B8G8R8_UNORM;
 185       }
 186       else if (type == GL_UNSIGNED_SHORT) {
 187          return PIPE_FORMAT_R16G16B16A16_UNORM;
 188       }
 189       else if (type == GL_FLOAT) {
 190          return PIPE_FORMAT_R32G32B32A32_FLOAT;
 191       }
 192       else {
 193          return PIPE_FORMAT_NONE;
 194       }
 195       break;
 196    case OSMESA_BGRA:
 197       if (type == GL_UNSIGNED_BYTE) {
 198          if (little_endian())
 199             return PIPE_FORMAT_B8G8R8A8_UNORM;
 200          else
 201             return PIPE_FORMAT_A8R8G8B8_UNORM;
 202       }
 203       else if (type == GL_UNSIGNED_SHORT) {
 204          return PIPE_FORMAT_R16G16B16A16_UNORM;
 205       }
 206       else if (type == GL_FLOAT) {
 207          return PIPE_FORMAT_R32G32B32A32_FLOAT;
 208       }
 209       else {
 210          return PIPE_FORMAT_NONE;
 211       }
 212       break;
 213    case OSMESA_ARGB:
 214       if (type == GL_UNSIGNED_BYTE) {
 215          if (little_endian())
 216             return PIPE_FORMAT_A8R8G8B8_UNORM;
 217          else
 218             return PIPE_FORMAT_B8G8R8A8_UNORM;
 219       }
 220       else if (type == GL_UNSIGNED_SHORT) {
 221          return PIPE_FORMAT_R16G16B16A16_UNORM;
 222       }
 223       else if (type == GL_FLOAT) {
 224          return PIPE_FORMAT_R32G32B32A32_FLOAT;
 225       }
 226       else {
 227          return PIPE_FORMAT_NONE;
 228       }
 229       break;
 230    case OSMESA_RGB:
 231       if (type == GL_UNSIGNED_BYTE) {
 232          return PIPE_FORMAT_R8G8B8_UNORM;
 233       }
 234       else if (type == GL_UNSIGNED_SHORT) {
 235          return PIPE_FORMAT_R16G16B16_UNORM;
 236       }
 237       else if (type == GL_FLOAT) {
 238          return PIPE_FORMAT_R32G32B32_FLOAT;
 239       }
 240       else {
 241          return PIPE_FORMAT_NONE;
 242       }
 243       break;
 244    case OSMESA_BGR:
 245       /* No gallium format for this one */
 246       return PIPE_FORMAT_NONE;
 247    case OSMESA_RGB_565:
 248       return PIPE_FORMAT_B5G6R5_UNORM;
 249    default:
 250       ; /* fall-through */
 251    }
 252    return PIPE_FORMAT_NONE;
 253 }
 254
 255
 256 /**
 257  * Initialize an st_visual object.
 258  */
 259 static void
 260 osmesa_init_st_visual(struct st_visual *vis,
 261                       enum pipe_format color_format,
 262                       enum pipe_format ds_format,
 263                       enum pipe_format accum_format)
 264 {
 265    vis->buffer_mask = ST_ATTACHMENT_FRONT_LEFT_MASK;
 266    vis->color_format = color_format;
 267    vis->depth_stencil_format = ds_format;
 268    vis->accum_format = accum_format;
 269    vis->samples = 1;
 270    vis->render_buffer = ST_ATTACHMENT_FRONT_LEFT;
 271 }
 272
 273
 274 /**
 275  * Return the osmesa_buffer that corresponds to an st_framebuffer_iface.
 276  */
 277 static INLINE struct osmesa_buffer *
 278 stfbi_to_osbuffer(struct st_framebuffer_iface *stfbi)
 279 {
 280    return (struct osmesa_buffer *) stfbi->st_manager_private;
 281 }
 282
 283
 284 /**
 285  * Called via glFlush/glFinish.  This is where we copy the contents
 286  * of the driver's color buffer into the user-specified buffer.
 287  */
 288 static boolean
 289 osmesa_st_framebuffer_flush_front(struct st_context_iface *stctx,
 290                                   struct st_framebuffer_iface *stfbi,
 291                                   enum st_attachment_type statt)
 292 {
 293    OSMesaContext osmesa = OSMesaGetCurrentContext();
 294    struct osmesa_buffer *osbuffer = stfbi_to_osbuffer(stfbi);
 295    struct pipe_context *pipe = stctx->pipe;
 296    struct pipe_resource *res = osbuffer->textures[statt];
 297    struct pipe_transfer *transfer = NULL;
 298    struct pipe_box box;
 299    void *map;
 300    ubyte *src, *dst;
 301    unsigned y, bytes, bpp;
 302    int dst_stride;
 303
 304    u_box_2d(0, 0, res->width0, res->height0, &box);
 305
 306    map = pipe->transfer_map(pipe, res, 0, PIPE_TRANSFER_READ, &box,
 307                             &transfer);
 308
 309    /*
 310     * Copy the color buffer from the resource to the user's buffer.
 311     */
 312    bpp = util_format_get_blocksize(osbuffer->visual.color_format);
 313    src = map;
 314    dst = osbuffer->map;
 315    if (osmesa->user_row_length)
 316       dst_stride = bpp * osmesa->user_row_length;
 317    else
 318       dst_stride = bpp * osbuffer->width;
 319    bytes = bpp * res->width0;
 320
 321    if (osmesa->y_up) {
 322       /* need to flip image upside down */
 323       dst = dst + (res->height0 - 1) * dst_stride;
 324       dst_stride = -dst_stride;
 325    }
 326
 327    for (y = 0; y < res->height0; y++) {
 328       memcpy(dst, src, bytes);
 329       dst += dst_stride;
 330       src += transfer->stride;
 331    }
 332
 333    pipe->transfer_unmap(pipe, transfer);
 334
 335    return TRUE;
 336 }
 337
 338
 339 /**
 340  * Called by the st manager to validate the framebuffer (allocate
 341  * its resources).
 342  */
 343 static boolean
 344 osmesa_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
 345                                const enum st_attachment_type *statts,
 346                                unsigned count,
 347                                struct pipe_resource **out)
 348 {
 349    struct pipe_screen *screen = get_st_manager()->screen;
 350    enum st_attachment_type i;
 351    struct osmesa_buffer *osbuffer = stfbi_to_osbuffer(stfbi);
 352    struct pipe_resource templat;
 353
 354    memset(&templat, 0, sizeof(templat));
 355    templat.target = PIPE_TEXTURE_RECT;
 356    templat.format = 0; /* setup below */
 357    templat.last_level = 0;
 358    templat.width0 = osbuffer->width;
 359    templat.height0 = osbuffer->height;
 360    templat.depth0 = 1;
 361    templat.array_size = 1;
 362    templat.usage = PIPE_USAGE_DEFAULT;
 363    templat.bind = 0; /* setup below */
 364    templat.flags = 0;
 365
 366    for (i = 0; i < count; i++) {
 367       enum pipe_format format = PIPE_FORMAT_NONE;
 368       unsigned bind = 0;
 369
 370       /*
 371        * At this time, we really only need to handle the front-left color
 372        * attachment, since that's all we specified for the visual in
 373        * osmesa_init_st_visual().
 374        */
 375       if (statts[i] == ST_ATTACHMENT_FRONT_LEFT) {
 376          format = osbuffer->visual.color_format;
 377          bind = PIPE_BIND_RENDER_TARGET;
 378       }
 379       else if (statts[i] == ST_ATTACHMENT_DEPTH_STENCIL) {
 380          format = osbuffer->visual.depth_stencil_format;
 381          bind = PIPE_BIND_DEPTH_STENCIL;
 382       }
 383       else if (statts[i] == ST_ATTACHMENT_ACCUM) {
 384          format = osbuffer->visual.accum_format;
 385          bind = PIPE_BIND_RENDER_TARGET;
 386       }
 387       else {
 388          debug_warning("Unexpected attachment type in "
 389                        "osmesa_st_framebuffer_validate()");
 390       }
 391
 392       templat.format = format;
 393       templat.bind = bind;
 394       out[i] = osbuffer->textures[i] =
 395          screen->resource_create(screen, &templat);
 396    }
 397
 398    return TRUE;
 399 }
 400
 401
 402 static struct st_framebuffer_iface *
 403 osmesa_create_st_framebuffer(void)
 404 {
 405    struct st_framebuffer_iface *stfbi = CALLOC_STRUCT(st_framebuffer_iface);
 406    if (stfbi) {
 407       stfbi->flush_front = osmesa_st_framebuffer_flush_front;
 408       stfbi->validate = osmesa_st_framebuffer_validate;
 409       p_atomic_set(&stfbi->stamp, 1);
 410    }
 411    return stfbi;
 412 }
 413
 414
 415 /**
 416  * Create new buffer and add to linked list.
 417  */
 418 static struct osmesa_buffer *
 419 osmesa_create_buffer(enum pipe_format color_format,
 420                      enum pipe_format ds_format,
 421                      enum pipe_format accum_format)
 422 {
 423    struct osmesa_buffer *osbuffer = CALLOC_STRUCT(osmesa_buffer);
 424    if (osbuffer) {
 425       osbuffer->stfb = osmesa_create_st_framebuffer();
 426
 427       osbuffer->stfb->st_manager_private = osbuffer;
 428       osbuffer->stfb->visual = &osbuffer->visual;
 429
 430       osmesa_init_st_visual(&osbuffer->visual, color_format,
 431                             ds_format, accum_format);
 432
 433       /* insert into linked list */
 434       osbuffer->next = BufferList;
 435       BufferList = osbuffer;
 436    }
 437
 438    return osbuffer;
 439 }
 440
 441
 442 /**
 443  * Search linked list for a buffer with matching pixel formats.
 444  */
 445 static struct osmesa_buffer *
 446 osmesa_find_buffer(enum pipe_format color_format,
 447                    enum pipe_format ds_format,
 448                    enum pipe_format accum_format)
 449 {
 450    struct osmesa_buffer *b;
 451
 452    /* Check if we already have a suitable buffer for the given formats */
 453    for (b = BufferList; b; b = b->next) {
 454       if (b->visual.color_format == color_format &&
 455           b->visual.depth_stencil_format == ds_format &&
 456           b->visual.accum_format == accum_format) {
 457          return b;
 458       }
 459    }
 460    return NULL;
 461 }
 462
 463
 464 static void
 465 osmesa_destroy_buffer(struct osmesa_buffer *osbuffer)
 466 {
 467    FREE(osbuffer->stfb);
 468    FREE(osbuffer);
 469 }
 470
 471
 472
 473 /**********************************************************************/
 474 /*****                    Public Functions                        *****/
 475 /**********************************************************************/
 476
 477
 478 /**
 479  * Create an Off-Screen Mesa rendering context.  The only attribute needed is
 480  * an RGBA vs Color-Index mode flag.
 481  *
 482  * Input:  format - Must be GL_RGBA
 483  *         sharelist - specifies another OSMesaContext with which to share
 484  *                     display lists.  NULL indicates no sharing.
 485  * Return:  an OSMesaContext or 0 if error
 486  */
 487 GLAPI OSMesaContext GLAPIENTRY
 488 OSMesaCreateContext(GLenum format, OSMesaContext sharelist)
 489 {
 490    return OSMesaCreateContextExt(format, 24, 8, 0, sharelist);
 491 }
 492
 493
 494 /**
 495  * New in Mesa 3.5
 496  *
 497  * Create context and specify size of ancillary buffers.
 498  */
 499 GLAPI OSMesaContext GLAPIENTRY
 500 OSMesaCreateContextExt(GLenum format, GLint depthBits, GLint stencilBits,
 501                        GLint accumBits, OSMesaContext sharelist)
 502 {
 503    OSMesaContext osmesa;
 504    struct st_context_iface *st_shared;
 505    enum st_context_error st_error = 0;
 506    struct st_context_attribs attribs;
 507    struct st_api *stapi = get_st_api();
 508
 509    if (sharelist) {
 510       st_shared = sharelist->stctx;
 511    }
 512    else {
 513       st_shared = NULL;
 514    }
 515
 516    osmesa = (OSMesaContext) CALLOC_STRUCT(osmesa_context);
 517    if (!osmesa)
 518       return NULL;
 519
 520    /* Choose depth/stencil/accum buffer formats */
 521    if (accumBits > 0) {
 522       osmesa->accum_format = PIPE_FORMAT_R16G16B16A16_SNORM;
 523    }
 524    if (depthBits > 0 && stencilBits > 0) {
 525       osmesa->depth_stencil_format = PIPE_FORMAT_Z24_UNORM_S8_UINT;
 526    }
 527    else if (stencilBits > 0) {
 528       osmesa->depth_stencil_format = PIPE_FORMAT_S8_UINT;
 529    }
 530    else if (depthBits >= 24) {
 531       osmesa->depth_stencil_format = PIPE_FORMAT_Z24X8_UNORM;
 532    }
 533    else if (depthBits >= 16) {
 534       osmesa->depth_stencil_format = PIPE_FORMAT_Z16_UNORM;
 535    }
 536
 537    /*
 538     * Create the rendering context
 539     */
 540    attribs.profile = ST_PROFILE_DEFAULT;
 541    attribs.major = 2;
 542    attribs.minor = 1;
 543    attribs.flags = 0;  /* ST_CONTEXT_FLAG_x */
 544    attribs.options.force_glsl_extensions_warn = FALSE;
 545
 546    osmesa_init_st_visual(&attribs.visual,
 547                          PIPE_FORMAT_R8G8B8A8_UNORM,
 548                          osmesa->depth_stencil_format,
 549                          osmesa->accum_format);
 550
 551    osmesa->stctx = stapi->create_context(stapi, get_st_manager(),
 552                                          &attribs, &st_error, st_shared);
 553    if (!osmesa->stctx) {
 554       FREE(osmesa);
 555       return NULL;
 556    }
 557
 558    osmesa->stctx->st_manager_private = osmesa;
 559
 560    osmesa->format = format;
 561    osmesa->user_row_length = 0;
 562    osmesa->y_up = GL_TRUE;
 563
 564    return osmesa;
 565 }
 566
 567
 568 /**
 569  * Destroy an Off-Screen Mesa rendering context.
 570  *
 571  * \param osmesa  the context to destroy
 572  */
 573 GLAPI void GLAPIENTRY
 574 OSMesaDestroyContext(OSMesaContext osmesa)
 575 {
 576    if (osmesa) {
 577       osmesa->stctx->destroy(osmesa->stctx);
 578       FREE(osmesa);
 579    }
 580 }
 581
 582
 583 /**
 584  * Bind an OSMesaContext to an image buffer.  The image buffer is just a
 585  * block of memory which the client provides.  Its size must be at least
 586  * as large as width*height*pixelSize.  Its address should be a multiple
 587  * of 4 if using RGBA mode.
 588  *
 589  * By default, image data is stored in the order of glDrawPixels: row-major
 590  * order with the lower-left image pixel stored in the first array position
 591  * (ie. bottom-to-top).
 592  *
 593  * If the context's viewport hasn't been initialized yet, it will now be
 594  * initialized to (0,0,width,height).
 595  *
 596  * Input:  osmesa - the rendering context
 597  *         buffer - the image buffer memory
 598  *         type - data type for pixel components
 599  *                GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT
 600  *                or GL_FLOAT.
 601  *         width, height - size of image buffer in pixels, at least 1
 602  * Return:  GL_TRUE if success, GL_FALSE if error because of invalid osmesa,
 603  *          invalid type, invalid size, etc.
 604  */
 605 GLAPI GLboolean GLAPIENTRY
 606 OSMesaMakeCurrent(OSMesaContext osmesa, void *buffer, GLenum type,
 607                   GLsizei width, GLsizei height)
 608 {
 609    struct st_api *stapi = get_st_api();
 610    struct osmesa_buffer *osbuffer;
 611    enum pipe_format color_format;
 612
 613    if (osmesa->format == OSMESA_RGB_565 && type != GL_UNSIGNED_SHORT_5_6_5) {
 614       return GL_FALSE;
 615    }
 616    if (width < 1 || height < 1) {
 617       return GL_FALSE;
 618    }
 619
 620    color_format = osmesa_choose_format(osmesa->format, type);
 621    if (color_format == PIPE_FORMAT_NONE) {
 622       fprintf(stderr, "OSMesaMakeCurrent(unsupported format/type)\n");
 623       return GL_FALSE;
 624    }
 625
 626    /* See if we already have a buffer that uses these pixel formats */
 627    osbuffer = osmesa_find_buffer(color_format,
 628                                  osmesa->depth_stencil_format,
 629                                  osmesa->accum_format);
 630    if (!osbuffer) {
 631       /* Existing buffer found, create new buffer */
 632       osbuffer = osmesa_create_buffer(color_format,
 633                                       osmesa->depth_stencil_format,
 634                                       osmesa->accum_format);
 635    }
 636
 637    osbuffer->width = width;
 638    osbuffer->height = height;
 639    osbuffer->map = buffer;
 640
 641    /* XXX unused for now */
 642    (void) osmesa_destroy_buffer;
 643
 644    osmesa->current_buffer = osbuffer;
 645    osmesa->type = type;
 646
 647    stapi->make_current(stapi, osmesa->stctx, osbuffer->stfb, osbuffer->stfb);
 648
 649    return GL_TRUE;
 650 }
 651
 652
 653
 654 GLAPI OSMesaContext GLAPIENTRY
 655 OSMesaGetCurrentContext(void)
 656 {
 657    struct st_api *stapi = get_st_api();
 658    struct st_context_iface *st = stapi->get_current(stapi);
 659    return st ? (OSMesaContext) st->st_manager_private : NULL;
 660 }
 661
 662
 663
 664 GLAPI void GLAPIENTRY
 665 OSMesaPixelStore(GLint pname, GLint value)
 666 {
 667    OSMesaContext osmesa = OSMesaGetCurrentContext();
 668
 669    switch (pname) {
 670    case OSMESA_ROW_LENGTH:
 671       osmesa->user_row_length = value;
 672       break;
 673    case OSMESA_Y_UP:
 674       osmesa->y_up = value ? GL_TRUE : GL_FALSE;
 675       break;
 676    default:
 677       fprintf(stderr, "Invalid pname in OSMesaPixelStore()\n");
 678       return;
 679    }
 680 }
 681
 682
 683 GLAPI void GLAPIENTRY
 684 OSMesaGetIntegerv(GLint pname, GLint *value)
 685 {
 686    OSMesaContext osmesa = OSMesaGetCurrentContext();
 687    struct osmesa_buffer *osbuffer = osmesa ? osmesa->current_buffer : NULL;
 688
 689    switch (pname) {
 690    case OSMESA_WIDTH:
 691       *value = osbuffer ? osbuffer->width : 0;
 692       return;
 693    case OSMESA_HEIGHT:
 694       *value = osbuffer ? osbuffer->height : 0;
 695       return;
 696    case OSMESA_FORMAT:
 697       *value = osmesa->format;
 698       return;
 699    case OSMESA_TYPE:
 700       /* current color buffer's data type */
 701       *value = osmesa->type;
 702       return;
 703    case OSMESA_ROW_LENGTH:
 704       *value = osmesa->user_row_length;
 705       return;
 706    case OSMESA_Y_UP:
 707       *value = osmesa->y_up;
 708       return;
 709    case OSMESA_MAX_WIDTH:
 710       /* fall-through */
 711    case OSMESA_MAX_HEIGHT:
 712       {
 713          struct pipe_screen *screen = get_st_manager()->screen;
 714          int maxLevels = screen->get_param(screen,
 715                                            PIPE_CAP_MAX_TEXTURE_2D_LEVELS);
 716          *value = 1 << (maxLevels - 1);
 717          *value = 8 * 1024;
 718       }
 719       return;
 720    default:
 721       fprintf(stderr, "Invalid pname in OSMesaGetIntegerv()\n");
 722       return;
 723    }
 724 }
 725
 726
 727 /**
 728  * Return information about the depth buffer associated with an OSMesa context.
 729  * Input:  c - the OSMesa context
 730  * Output:  width, height - size of buffer in pixels
 731  *          bytesPerValue - bytes per depth value (2 or 4)
 732  *          buffer - pointer to depth buffer values
 733  * Return:  GL_TRUE or GL_FALSE to indicate success or failure.
 734  */
 735 GLAPI GLboolean GLAPIENTRY
 736 OSMesaGetDepthBuffer(OSMesaContext c, GLint *width, GLint *height,
 737                      GLint *bytesPerValue, void **buffer)
 738 {
 739    struct osmesa_buffer *osbuffer = c->current_buffer;
 740    struct pipe_context *pipe = c->stctx->pipe;
 741    struct pipe_resource *res = osbuffer->textures[ST_ATTACHMENT_DEPTH_STENCIL];
 742    struct pipe_transfer *transfer = NULL;
 743    struct pipe_box box;
 744
 745    /*
 746     * Note: we can't really implement this function with gallium as
 747     * we did for swrast.  We can't just map the resource and leave it
 748     * mapped (and there's no OSMesaUnmapDepthBuffer() function) so
 749     * we unmap the buffer here and return a 'stale' pointer.  This should
 750     * actually be OK in most cases where the caller of this function
 751     * immediately uses the pointer.
 752     */
 753
 754    u_box_2d(0, 0, res->width0, res->height0, &box);
 755
 756    *buffer = pipe->transfer_map(pipe, res, 0, PIPE_TRANSFER_READ, &box,
 757                                 &transfer);
 758    if (!*buffer) {
 759       return GL_FALSE;
 760    }
 761
 762    *width = res->width0;
 763    *height = res->height0;
 764    *bytesPerValue = util_format_get_blocksize(res->format);
 765
 766    pipe->transfer_unmap(pipe, transfer);
 767
 768    return GL_TRUE;
 769 }
 770
 771
 772 /**
 773  * Return the color buffer associated with an OSMesa context.
 774  * Input:  c - the OSMesa context
 775  * Output:  width, height - size of buffer in pixels
 776  *          format - the pixel format (OSMESA_FORMAT)
 777  *          buffer - pointer to color buffer values
 778  * Return:  GL_TRUE or GL_FALSE to indicate success or failure.
 779  */
 780 GLAPI GLboolean GLAPIENTRY
 781 OSMesaGetColorBuffer(OSMesaContext osmesa, GLint *width,
 782                       GLint *height, GLint *format, void **buffer)
 783 {
 784    struct osmesa_buffer *osbuffer = osmesa->current_buffer;
 785
 786    if (osbuffer) {
 787       *width = osbuffer->width;
 788       *height = osbuffer->height;
 789       *format = osmesa->format;
 790       *buffer = osbuffer->map;
 791       return GL_TRUE;
 792    }
 793    else {
 794       *width = 0;
 795       *height = 0;
 796       *format = 0;
 797       *buffer = 0;
 798       return GL_FALSE;
 799    }
 800 }
 801
 802
 803 struct name_function
 804 {
 805    const char *Name;
 806    OSMESAproc Function;
 807 };
 808
 809 static struct name_function functions[] = {
 810    { "OSMesaCreateContext", (OSMESAproc) OSMesaCreateContext },
 811    { "OSMesaCreateContextExt", (OSMESAproc) OSMesaCreateContextExt },
 812    { "OSMesaDestroyContext", (OSMESAproc) OSMesaDestroyContext },
 813    { "OSMesaMakeCurrent", (OSMESAproc) OSMesaMakeCurrent },
 814    { "OSMesaGetCurrentContext", (OSMESAproc) OSMesaGetCurrentContext },
 815    { "OSMesaPixelsStore", (OSMESAproc) OSMesaPixelStore },
 816    { "OSMesaGetIntegerv", (OSMESAproc) OSMesaGetIntegerv },
 817    { "OSMesaGetDepthBuffer", (OSMESAproc) OSMesaGetDepthBuffer },
 818    { "OSMesaGetColorBuffer", (OSMESAproc) OSMesaGetColorBuffer },
 819    { "OSMesaGetProcAddress", (OSMESAproc) OSMesaGetProcAddress },
 820    { "OSMesaColorClamp", (OSMESAproc) OSMesaColorClamp },
 821    { NULL, NULL }
 822 };
 823
 824
 825 GLAPI OSMESAproc GLAPIENTRY
 826 OSMesaGetProcAddress(const char *funcName)
 827 {
 828    int i;
 829    for (i = 0; functions[i].Name; i++) {
 830       if (strcmp(functions[i].Name, funcName) == 0)
 831          return functions[i].Function;
 832    }
 833    return _glapi_get_proc_address(funcName);
 834 }
 835
 836
 837 GLAPI void GLAPIENTRY
 838 OSMesaColorClamp(GLboolean enable)
 839 {
 840    extern void GLAPIENTRY _mesa_ClampColor(GLenum target, GLenum clamp);
 841
 842    _mesa_ClampColor(GL_CLAMP_FRAGMENT_COLOR_ARB,
 843                     enable ? GL_TRUE : GL_FIXED_ONLY_ARB);
 844 }