src/mesa/drivers/fbdev/glfbdev.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.1
   4  *
   5  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25
  26 /*
  27  * OpenGL (Mesa) interface for fbdev.
  28  * For info about fbdev:
  29  * http://www.tldp.org/HOWTO/Framebuffer-HOWTO.html
  30  *
  31  * known VGA modes
  32  * Colours   640x400 640x480 800x600 1024x768 1152x864 1280x1024 1600x1200
  33  * --------+--------------------------------------------------------------
  34  *  4 bits |    ?       ?     0x302      ?        ?        ?         ?
  35  *  8 bits |  0x300   0x301   0x303    0x305    0x161    0x307     0x31C
  36  * 15 bits |    ?     0x310   0x313    0x316    0x162    0x319     0x31D
  37  * 16 bits |    ?     0x311   0x314    0x317    0x163    0x31A     0x31E
  38  * 24 bits |    ?     0x312   0x315    0x318      ?      0x31B     0x31F
  39  * 32 bits |    ?       ?       ?        ?      0x164      ?
  40  */
  41
  42 #ifdef USE_GLFBDEV_DRIVER
  43
  44 #include <linux/fb.h>
  45 #include "GL/glfbdev.h"
  46 #include "main/glheader.h"
  47 #include "main/buffers.h"
  48 #include "main/context.h"
  49 #include "main/extensions.h"
  50 #include "main/fbobject.h"
  51 #include "main/framebuffer.h"
  52 #include "main/imports.h"
  53 #include "main/renderbuffer.h"
  54 #include "main/texformat.h"
  55 #include "main/teximage.h"
  56 #include "main/texstore.h"
  57 #include "vbo/vbo.h"
  58 #include "swrast/swrast.h"
  59 #include "swrast_setup/swrast_setup.h"
  60 #include "tnl/tnl.h"
  61 #include "tnl/t_context.h"
  62 #include "tnl/t_pipeline.h"
  63 #include "drivers/common/driverfuncs.h"
  64
  65
  66 /**
  67  * Pixel formats we support:
  68  */
  69 #define PF_B8G8R8     1
  70 #define PF_B8G8R8A8   2
  71 #define PF_B5G6R5     3
  72 #define PF_B5G5R5     4
  73
  74
  75 /**
  76  * Derived from Mesa's GLvisual class.
  77  */
  78 struct GLFBDevVisualRec {
  79    GLvisual glvisual;              /* base class */
  80    struct fb_fix_screeninfo fix;
  81    struct fb_var_screeninfo var;
  82    int pixelFormat;
  83 };
  84
  85 /**
  86  * Derived from Mesa's GLframebuffer class.
  87  */
  88 struct GLFBDevBufferRec {
  89    GLframebuffer glframebuffer;    /* base class */
  90    GLFBDevVisualPtr visual;
  91    struct fb_fix_screeninfo fix;
  92    struct fb_var_screeninfo var;
  93    size_t size;                    /* color buffer size in bytes */
  94    GLuint bytesPerPixel;
  95 };
  96
  97 /**
  98  * Derived from Mesa's GLcontext class.
  99  */
 100 struct GLFBDevContextRec {
 101    GLcontext glcontext;            /* base class */
 102    GLFBDevVisualPtr visual;
 103    GLFBDevBufferPtr drawBuffer;
 104    GLFBDevBufferPtr readBuffer;
 105    GLFBDevBufferPtr curBuffer;
 106 };
 107
 108 /**
 109  * Derived from Mesa's gl_renderbuffer class.
 110  */
 111 struct GLFBDevRenderbufferRec {
 112    struct gl_renderbuffer Base;
 113    GLubyte *bottom;                /* pointer to last row */
 114    GLuint rowStride;               /* in bytes */
 115    GLboolean mallocedBuffer;
 116 };
 117
 118
 119 /**********************************************************************/
 120 /* Internal device driver functions                                   */
 121 /**********************************************************************/
 122
 123
 124 static const GLubyte *
 125 get_string(GLcontext *ctx, GLenum pname)
 126 {
 127    (void) ctx;
 128    switch (pname) {
 129       case GL_RENDERER:
 130          return (const GLubyte *) "Mesa glfbdev";
 131       default:
 132          return NULL;
 133    }
 134 }
 135
 136
 137 static void
 138 update_state( GLcontext *ctx, GLuint new_state )
 139 {
 140    /* not much to do here - pass it on */
 141    _swrast_InvalidateState( ctx, new_state );
 142    _swsetup_InvalidateState( ctx, new_state );
 143    _vbo_InvalidateState( ctx, new_state );
 144    _tnl_InvalidateState( ctx, new_state );
 145 }
 146
 147
 148 static void
 149 get_buffer_size( GLframebuffer *buffer, GLuint *width, GLuint *height )
 150 {
 151    const GLFBDevBufferPtr fbdevbuffer = (GLFBDevBufferPtr) buffer;
 152    *width = fbdevbuffer->var.xres;
 153    *height = fbdevbuffer->var.yres;
 154 }
 155
 156
 157 /**
 158  * We only implement this function as a mechanism to check if the
 159  * framebuffer size has changed (and update corresponding state).
 160  */
 161 static void
 162 viewport(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h)
 163 {
 164    GLuint newWidth, newHeight;
 165    GLframebuffer *buffer;
 166
 167    buffer = ctx->WinSysDrawBuffer;
 168    get_buffer_size( buffer, &newWidth, &newHeight );
 169    if (buffer->Width != newWidth || buffer->Height != newHeight) {
 170       _mesa_resize_framebuffer(ctx, buffer, newWidth, newHeight );
 171    }
 172
 173    buffer = ctx->WinSysReadBuffer;
 174    get_buffer_size( buffer, &newWidth, &newHeight );
 175    if (buffer->Width != newWidth || buffer->Height != newHeight) {
 176       _mesa_resize_framebuffer(ctx, buffer, newWidth, newHeight );
 177    }
 178 }
 179
 180
 181 /*
 182  * Generate code for span functions.
 183  */
 184
 185 /* 24-bit BGR */
 186 #define NAME(PREFIX) PREFIX##_B8G8R8
 187 #define RB_TYPE GLubyte
 188 #define SPAN_VARS \
 189    struct GLFBDevRenderbufferRec *frb = (struct GLFBDevRenderbufferRec *) rb;
 190 #define INIT_PIXEL_PTR(P, X, Y) \
 191    GLubyte *P = frb->bottom - (Y) * frb->rowStride + (X) * 3
 192 #define INC_PIXEL_PTR(P) P += 3
 193 #define STORE_PIXEL(DST, X, Y, VALUE) \
 194    DST[0] = VALUE[BCOMP];  \
 195    DST[1] = VALUE[GCOMP];  \
 196    DST[2] = VALUE[RCOMP]
 197 #define FETCH_PIXEL(DST, SRC) \
 198    DST[RCOMP] = SRC[2];  \
 199    DST[GCOMP] = SRC[1];  \
 200    DST[BCOMP] = SRC[0];  \
 201    DST[ACOMP] = CHAN_MAX
 202
 203 #include "swrast/s_spantemp.h"
 204
 205
 206 /* 32-bit BGRA */
 207 #define NAME(PREFIX) PREFIX##_B8G8R8A8
 208 #define RB_TYPE GLubyte
 209 #define SPAN_VARS \
 210    struct GLFBDevRenderbufferRec *frb = (struct GLFBDevRenderbufferRec *) rb;
 211 #define INIT_PIXEL_PTR(P, X, Y) \
 212    GLubyte *P = frb->bottom - (Y) * frb->rowStride + (X) * 4
 213 #define INC_PIXEL_PTR(P) P += 4
 214 #define STORE_PIXEL(DST, X, Y, VALUE) \
 215    DST[0] = VALUE[BCOMP];  \
 216    DST[1] = VALUE[GCOMP];  \
 217    DST[2] = VALUE[RCOMP];  \
 218    DST[3] = VALUE[ACOMP]
 219 #define FETCH_PIXEL(DST, SRC) \
 220    DST[RCOMP] = SRC[2];  \
 221    DST[GCOMP] = SRC[1];  \
 222    DST[BCOMP] = SRC[0];  \
 223    DST[ACOMP] = SRC[3]
 224
 225 #include "swrast/s_spantemp.h"
 226
 227
 228 /* 16-bit BGR (XXX implement dithering someday) */
 229 #define NAME(PREFIX) PREFIX##_B5G6R5
 230 #define RB_TYPE GLubyte
 231 #define SPAN_VARS \
 232    struct GLFBDevRenderbufferRec *frb = (struct GLFBDevRenderbufferRec *) rb;
 233 #define INIT_PIXEL_PTR(P, X, Y) \
 234    GLushort *P = (GLushort *) (frb->bottom - (Y) * frb->rowStride + (X) * 2)
 235 #define INC_PIXEL_PTR(P) P += 1
 236 #define STORE_PIXEL(DST, X, Y, VALUE) \
 237    DST[0] = ( (((VALUE[RCOMP]) & 0xf8) << 8) | (((VALUE[GCOMP]) & 0xfc) << 3) | ((VALUE[BCOMP]) >> 3) )
 238 #define FETCH_PIXEL(DST, SRC) \
 239    DST[RCOMP] = ( (((SRC[0]) >> 8) & 0xf8) | (((SRC[0]) >> 11) & 0x7) ); \
 240    DST[GCOMP] = ( (((SRC[0]) >> 3) & 0xfc) | (((SRC[0]) >>  5) & 0x3) ); \
 241    DST[BCOMP] = ( (((SRC[0]) << 3) & 0xf8) | (((SRC[0])      ) & 0x7) ); \
 242    DST[ACOMP] = CHAN_MAX
 243
 244 #include "swrast/s_spantemp.h"
 245
 246
 247 /* 15-bit BGR (XXX implement dithering someday) */
 248 #define NAME(PREFIX) PREFIX##_B5G5R5
 249 #define RB_TYPE GLubyte
 250 #define SPAN_VARS \
 251    struct GLFBDevRenderbufferRec *frb = (struct GLFBDevRenderbufferRec *) rb;
 252 #define INIT_PIXEL_PTR(P, X, Y) \
 253    GLushort *P = (GLushort *) (frb->bottom - (Y) * frb->rowStride + (X) * 2)
 254 #define INC_PIXEL_PTR(P) P += 1
 255 #define STORE_PIXEL(DST, X, Y, VALUE) \
 256    DST[0] = ( (((VALUE[RCOMP]) & 0xf8) << 7) | (((VALUE[GCOMP]) & 0xf8) << 2) | ((VALUE[BCOMP]) >> 3) )
 257 #define FETCH_PIXEL(DST, SRC) \
 258    DST[RCOMP] = ( (((SRC[0]) >> 7) & 0xf8) | (((SRC[0]) >> 10) & 0x7) ); \
 259    DST[GCOMP] = ( (((SRC[0]) >> 2) & 0xf8) | (((SRC[0]) >>  5) & 0x7) ); \
 260    DST[BCOMP] = ( (((SRC[0]) << 3) & 0xf8) | (((SRC[0])      ) & 0x7) ); \
 261    DST[ACOMP] = CHAN_MAX
 262
 263 #include "swrast/s_spantemp.h"
 264
 265
 266 /**********************************************************************/
 267 /* Public API functions                                               */
 268 /**********************************************************************/
 269
 270
 271 const char *
 272 glFBDevGetString( int str )
 273 {
 274    switch (str) {
 275    case GLFBDEV_VENDOR:
 276       return "Mesa Project";
 277    case GLFBDEV_VERSION:
 278       return "1.0.1";
 279    default:
 280       return NULL;
 281    }
 282 }
 283
 284
 285 GLFBDevProc
 286 glFBDevGetProcAddress( const char *procName )
 287 {
 288    struct name_address {
 289       const char *name;
 290       const GLFBDevProc func;
 291    };
 292    static const struct name_address functions[] = {
 293       { "glFBDevGetString", (GLFBDevProc) glFBDevGetString },
 294       { "glFBDevGetProcAddress", (GLFBDevProc) glFBDevGetProcAddress },
 295       { "glFBDevCreateVisual", (GLFBDevProc) glFBDevCreateVisual },
 296       { "glFBDevDestroyVisual", (GLFBDevProc) glFBDevDestroyVisual },
 297       { "glFBDevGetVisualAttrib", (GLFBDevProc) glFBDevGetVisualAttrib },
 298       { "glFBDevCreateBuffer", (GLFBDevProc) glFBDevCreateBuffer },
 299       { "glFBDevDestroyBuffer", (GLFBDevProc) glFBDevDestroyBuffer },
 300       { "glFBDevGetBufferAttrib", (GLFBDevProc) glFBDevGetBufferAttrib },
 301       { "glFBDevGetCurrentDrawBuffer", (GLFBDevProc) glFBDevGetCurrentDrawBuffer },
 302       { "glFBDevGetCurrentReadBuffer", (GLFBDevProc) glFBDevGetCurrentReadBuffer },
 303       { "glFBDevSwapBuffers", (GLFBDevProc) glFBDevSwapBuffers },
 304       { "glFBDevCreateContext", (GLFBDevProc) glFBDevCreateContext },
 305       { "glFBDevDestroyContext", (GLFBDevProc) glFBDevDestroyContext },
 306       { "glFBDevGetContextAttrib", (GLFBDevProc) glFBDevGetContextAttrib },
 307       { "glFBDevGetCurrentContext", (GLFBDevProc) glFBDevGetCurrentContext },
 308       { "glFBDevMakeCurrent", (GLFBDevProc) glFBDevMakeCurrent },
 309       { NULL, NULL }
 310    };
 311    const struct name_address *entry;
 312    for (entry = functions; entry->name; entry++) {
 313       if (strcmp(entry->name, procName) == 0) {
 314          return entry->func;
 315       }
 316    }
 317    return _glapi_get_proc_address(procName);
 318 }
 319
 320
 321 GLFBDevVisualPtr
 322 glFBDevCreateVisual( const struct fb_fix_screeninfo *fixInfo,
 323                      const struct fb_var_screeninfo *varInfo,
 324                      const int *attribs )
 325 {
 326    GLFBDevVisualPtr vis;
 327    const int *attrib;
 328    GLboolean dbFlag = GL_FALSE, stereoFlag = GL_FALSE;
 329    GLint redBits = 0, greenBits = 0, blueBits = 0, alphaBits = 0;
 330    GLint depthBits = 0, stencilBits = 0;
 331    GLint accumRedBits = 0, accumGreenBits = 0;
 332    GLint accumBlueBits = 0, accumAlphaBits = 0;
 333    GLint numSamples = 0;
 334
 335    ASSERT(fixInfo);
 336    ASSERT(varInfo);
 337
 338    vis = CALLOC_STRUCT(GLFBDevVisualRec);
 339    if (!vis)
 340       return NULL;
 341
 342    vis->fix = *fixInfo;  /* struct assignment */
 343    vis->var = *varInfo;  /* struct assignment */
 344
 345    for (attrib = attribs; attrib && *attrib != GLFBDEV_NONE; attrib++) {
 346       switch (*attrib) {
 347       case GLFBDEV_DOUBLE_BUFFER:
 348          dbFlag = GL_TRUE;
 349          break;
 350       case GLFBDEV_DEPTH_SIZE:
 351          depthBits = attrib[1];
 352          attrib++;
 353          break;
 354       case GLFBDEV_STENCIL_SIZE:
 355          stencilBits = attrib[1];
 356          attrib++;
 357          break;
 358       case GLFBDEV_ACCUM_SIZE:
 359          accumRedBits = accumGreenBits = accumBlueBits = accumAlphaBits
 360             = attrib[1];
 361          attrib++;
 362          break;
 363       case GLFBDEV_LEVEL:
 364          /* ignored for now */
 365          break;
 366       case GLFBDEV_MULTISAMPLE:
 367          numSamples = attrib[1];
 368          attrib++;
 369          break;
 370       case GLFBDEV_COLOR_INDEX:
 371          /* Mesa no longer supports color-index rendering. */
 372       default:
 373          /* unexpected token */
 374          free(vis);
 375          return NULL;
 376       }
 377    }
 378
 379    redBits   = varInfo->red.length;
 380    greenBits = varInfo->green.length;
 381    blueBits  = varInfo->blue.length;
 382    alphaBits = varInfo->transp.length;
 383
 384    if (fixInfo->visual == FB_VISUAL_TRUECOLOR ||
 385        fixInfo->visual == FB_VISUAL_DIRECTCOLOR) {
 386       if (varInfo->bits_per_pixel == 24
 387           && varInfo->red.offset == 16
 388           && varInfo->green.offset == 8
 389           && varInfo->blue.offset == 0) {
 390          vis->pixelFormat = PF_B8G8R8;
 391       }
 392       else if (varInfo->bits_per_pixel == 32
 393                && varInfo->red.offset == 16
 394                && varInfo->green.offset == 8
 395                && varInfo->blue.offset == 0) {
 396          vis->pixelFormat = PF_B8G8R8A8;
 397       }
 398       else if (varInfo->bits_per_pixel == 16
 399                && varInfo->red.offset == 11
 400                && varInfo->green.offset == 5
 401                && varInfo->blue.offset == 0) {
 402          vis->pixelFormat = PF_B5G6R5;
 403       }
 404       else if (varInfo->bits_per_pixel == 16
 405                && varInfo->red.offset == 10
 406                && varInfo->green.offset == 5
 407                && varInfo->blue.offset == 0) {
 408          vis->pixelFormat = PF_B5G5R5;
 409       }
 410       else {
 411          _mesa_problem(NULL, "Unsupported fbdev RGB visual/bitdepth!\n");
 412          free(vis);
 413          return NULL;
 414       }
 415    }
 416
 417    if (!_mesa_initialize_visual(&vis->glvisual, dbFlag, stereoFlag,
 418                                 redBits, greenBits, blueBits, alphaBits,
 419                                 depthBits, stencilBits,
 420                                 accumRedBits, accumGreenBits,
 421                                 accumBlueBits, accumAlphaBits,
 422                                 numSamples)) {
 423       /* something was invalid */
 424       free(vis);
 425       return NULL;
 426    }
 427
 428    return vis;
 429 }
 430
 431
 432 void
 433 glFBDevDestroyVisual( GLFBDevVisualPtr visual )
 434 {
 435    if (visual)
 436       free(visual);
 437 }
 438
 439
 440 int
 441 glFBDevGetVisualAttrib( const GLFBDevVisualPtr visual, int attrib)
 442 {
 443    /* XXX unfinished */
 444    (void) visual;
 445    (void) attrib;
 446    return -1;
 447 }
 448
 449
 450 static void
 451 delete_renderbuffer(struct gl_renderbuffer *rb)
 452 {
 453    struct GLFBDevRenderbufferRec *frb = (struct GLFBDevRenderbufferRec *) rb;
 454    if (frb->mallocedBuffer) {
 455       free(frb->Base.Data);
 456    }
 457    free(frb);
 458 }
 459
 460
 461 static GLboolean
 462 renderbuffer_storage(GLcontext *ctx, struct gl_renderbuffer *rb,
 463                      GLenum internalFormat, GLuint width, GLuint height)
 464 {
 465    /* no-op: the renderbuffer storage is allocated just once when it's
 466     * created.  Never resized or reallocated.
 467     */
 468    return GL_TRUE;
 469 }
 470
 471
 472 static struct GLFBDevRenderbufferRec *
 473 new_glfbdev_renderbuffer(void *bufferStart, const GLFBDevVisualPtr visual)
 474 {
 475    struct GLFBDevRenderbufferRec *rb = CALLOC_STRUCT(GLFBDevRenderbufferRec);
 476    if (rb) {
 477       GLuint name = 0;
 478       int pixelFormat = visual->pixelFormat;
 479
 480       _mesa_init_renderbuffer(&rb->Base, name);
 481
 482       rb->Base.Delete = delete_renderbuffer;
 483       rb->Base.AllocStorage = renderbuffer_storage;
 484
 485       if (pixelFormat == PF_B8G8R8) {
 486          rb->Base.GetRow = get_row_B8G8R8;
 487          rb->Base.GetValues = get_values_B8G8R8;
 488          rb->Base.PutRow = put_row_B8G8R8;
 489          rb->Base.PutRowRGB = put_row_rgb_B8G8R8;
 490          rb->Base.PutMonoRow = put_mono_row_B8G8R8;
 491          rb->Base.PutValues = put_values_B8G8R8;
 492          rb->Base.PutMonoValues = put_mono_values_B8G8R8;
 493       }
 494       else if (pixelFormat == PF_B8G8R8A8) {
 495          rb->Base.GetRow = get_row_B8G8R8A8;
 496          rb->Base.GetValues = get_values_B8G8R8A8;
 497          rb->Base.PutRow = put_row_B8G8R8A8;
 498          rb->Base.PutRowRGB = put_row_rgb_B8G8R8A8;
 499          rb->Base.PutMonoRow = put_mono_row_B8G8R8A8;
 500          rb->Base.PutValues = put_values_B8G8R8A8;
 501          rb->Base.PutMonoValues = put_mono_values_B8G8R8A8;
 502       }
 503       else if (pixelFormat == PF_B5G6R5) {
 504          rb->Base.GetRow = get_row_B5G6R5;
 505          rb->Base.GetValues = get_values_B5G6R5;
 506          rb->Base.PutRow = put_row_B5G6R5;
 507          rb->Base.PutRowRGB = put_row_rgb_B5G6R5;
 508          rb->Base.PutMonoRow = put_mono_row_B5G6R5;
 509          rb->Base.PutValues = put_values_B5G6R5;
 510          rb->Base.PutMonoValues = put_mono_values_B5G6R5;
 511       }
 512       else if (pixelFormat == PF_B5G5R5) {
 513          rb->Base.GetRow = get_row_B5G5R5;
 514          rb->Base.GetValues = get_values_B5G5R5;
 515          rb->Base.PutRow = put_row_B5G5R5;
 516          rb->Base.PutRowRGB = put_row_rgb_B5G5R5;
 517          rb->Base.PutMonoRow = put_mono_row_B5G5R5;
 518          rb->Base.PutValues = put_values_B5G5R5;
 519          rb->Base.PutMonoValues = put_mono_values_B5G5R5;
 520       }
 521
 522       rb->Base.InternalFormat = GL_RGBA;
 523       rb->Base._BaseFormat = GL_RGBA;
 524       rb->Base.DataType = GL_UNSIGNED_BYTE;
 525       rb->Base.Data = bufferStart;
 526
 527       rb->rowStride = visual->var.xres_virtual * visual->var.bits_per_pixel / 8;
 528       rb->bottom = (GLubyte *) bufferStart
 529                  + (visual->var.yres - 1) * rb->rowStride;
 530
 531       rb->Base.Width = visual->var.xres;
 532       rb->Base.Height = visual->var.yres;
 533
 534       rb->Base.RedBits = visual->var.red.length;
 535       rb->Base.GreenBits = visual->var.green.length;
 536       rb->Base.BlueBits = visual->var.blue.length;
 537       rb->Base.AlphaBits = visual->var.transp.length;
 538
 539       rb->Base.InternalFormat = pixelFormat;
 540    }
 541    return rb;
 542 }
 543
 544 GLFBDevBufferPtr
 545 glFBDevCreateBuffer( const struct fb_fix_screeninfo *fixInfo,
 546                      const struct fb_var_screeninfo *varInfo,
 547                      const GLFBDevVisualPtr visual,
 548                      void *frontBuffer, void *backBuffer, size_t size )
 549 {
 550    struct GLFBDevRenderbufferRec *frontrb, *backrb;
 551    GLFBDevBufferPtr buf;
 552
 553    ASSERT(visual);
 554    ASSERT(frontBuffer);
 555    ASSERT(size > 0);
 556
 557    /* this is to update the visual if there was a resize and the
 558       buffer is created again */
 559    visual->var = *varInfo;
 560    visual->fix = *fixInfo;
 561
 562    if (visual->fix.visual != fixInfo->visual ||
 563        visual->fix.type != fixInfo->type ||
 564        visual->var.bits_per_pixel != varInfo->bits_per_pixel ||
 565        visual->var.grayscale != varInfo->grayscale ||
 566        visual->var.red.offset != varInfo->red.offset ||
 567        visual->var.green.offset != varInfo->green.offset ||
 568        visual->var.blue.offset != varInfo->blue.offset ||
 569        visual->var.transp.offset != varInfo->transp.offset) {
 570       /* visual mismatch! */
 571       return NULL;
 572    }
 573
 574    buf = CALLOC_STRUCT(GLFBDevBufferRec);
 575    if (!buf)
 576       return NULL;
 577
 578    /* basic framebuffer setup */
 579    _mesa_initialize_window_framebuffer(&buf->glframebuffer, &visual->glvisual);
 580    /* add front renderbuffer */
 581    frontrb = new_glfbdev_renderbuffer(frontBuffer, visual);
 582    _mesa_add_renderbuffer(&buf->glframebuffer, BUFFER_FRONT_LEFT,
 583                           &frontrb->Base);
 584    /* add back renderbuffer */
 585    if (visual->glvisual.doubleBufferMode) {
 586       const int malloced = !backBuffer;
 587       if (malloced) {
 588          /* malloc a back buffer */
 589          backBuffer = malloc(size);
 590          if (!backBuffer) {
 591             _mesa_free_framebuffer_data(&buf->glframebuffer);
 592             free(buf);
 593             return NULL;
 594          }
 595       }
 596
 597       backrb = new_glfbdev_renderbuffer(backBuffer, visual);
 598       if (!backrb) {
 599          /* out of mem */
 600          return NULL;
 601       }
 602       backrb->mallocedBuffer = malloced;
 603
 604       _mesa_add_renderbuffer(&buf->glframebuffer, BUFFER_BACK_LEFT,
 605                              &backrb->Base);
 606    }
 607    /* add software renderbuffers */
 608    _mesa_add_soft_renderbuffers(&buf->glframebuffer,
 609                                 GL_FALSE, /* color */
 610                                 visual->glvisual.haveDepthBuffer,
 611                                 visual->glvisual.haveStencilBuffer,
 612                                 visual->glvisual.haveAccumBuffer,
 613                                 GL_FALSE, /* alpha */
 614                                 GL_FALSE /* aux bufs */);
 615
 616    buf->fix = *fixInfo;   /* struct assignment */
 617    buf->var = *varInfo;   /* struct assignment */
 618    buf->visual = visual;  /* ptr assignment */
 619    buf->size = size;
 620    buf->bytesPerPixel = visual->var.bits_per_pixel / 8;
 621
 622    return buf;
 623 }
 624
 625
 626 void
 627 glFBDevDestroyBuffer( GLFBDevBufferPtr buffer )
 628 {
 629    if (buffer) {
 630       /* check if destroying the current buffer */
 631       GLFBDevBufferPtr curDraw = glFBDevGetCurrentDrawBuffer();
 632       GLFBDevBufferPtr curRead = glFBDevGetCurrentReadBuffer();
 633       if (buffer == curDraw || buffer == curRead) {
 634          glFBDevMakeCurrent( NULL, NULL, NULL);
 635       }
 636       {
 637          struct gl_framebuffer *fb = &buffer->glframebuffer;
 638          _mesa_reference_framebuffer(&fb, NULL);
 639       }
 640    }
 641 }
 642
 643
 644 int
 645 glFBDevGetBufferAttrib( const GLFBDevBufferPtr buffer, int attrib)
 646 {
 647    (void) buffer;
 648    (void) attrib;
 649    return -1;
 650 }
 651
 652
 653 GLFBDevBufferPtr
 654 glFBDevGetCurrentDrawBuffer( void )
 655 {
 656    GLFBDevContextPtr fbdevctx = glFBDevGetCurrentContext();
 657    if (fbdevctx)
 658       return fbdevctx->drawBuffer;
 659    else
 660       return NULL;
 661 }
 662
 663
 664 GLFBDevBufferPtr
 665 glFBDevGetCurrentReadBuffer( void )
 666 {
 667    GLFBDevContextPtr fbdevctx = glFBDevGetCurrentContext();
 668    if (fbdevctx)
 669       return fbdevctx->readBuffer;
 670    else
 671       return NULL;
 672 }
 673
 674
 675 void
 676 glFBDevSwapBuffers( GLFBDevBufferPtr buffer )
 677 {
 678    GLFBDevContextPtr fbdevctx = glFBDevGetCurrentContext();
 679    struct GLFBDevRenderbufferRec *frontrb = (struct GLFBDevRenderbufferRec *)
 680       buffer->glframebuffer.Attachment[BUFFER_FRONT_LEFT].Renderbuffer;
 681    struct GLFBDevRenderbufferRec *backrb = (struct GLFBDevRenderbufferRec *)
 682       buffer->glframebuffer.Attachment[BUFFER_BACK_LEFT].Renderbuffer;
 683
 684    if (!buffer || !buffer->visual->glvisual.doubleBufferMode)
 685       return;
 686
 687    /* check if swapping currently bound buffer */
 688    if (fbdevctx->drawBuffer == buffer) {
 689       /* flush pending rendering */
 690       _mesa_notifySwapBuffers(&fbdevctx->glcontext);
 691    }
 692
 693    ASSERT(frontrb->Base.Data);
 694    ASSERT(backrb->Base.Data);
 695    memcpy(frontrb->Base.Data, backrb->Base.Data, buffer->size);
 696 }
 697
 698
 699 GLFBDevContextPtr
 700 glFBDevCreateContext( const GLFBDevVisualPtr visual, GLFBDevContextPtr share )
 701 {
 702    GLFBDevContextPtr ctx;
 703    GLcontext *glctx;
 704    struct dd_function_table functions;
 705
 706    ASSERT(visual);
 707
 708    ctx = CALLOC_STRUCT(GLFBDevContextRec);
 709    if (!ctx)
 710       return NULL;
 711
 712    /* build table of device driver functions */
 713    _mesa_init_driver_functions(&functions);
 714    functions.GetString = get_string;
 715    functions.UpdateState = update_state;
 716    functions.GetBufferSize = get_buffer_size;
 717    functions.Viewport = viewport;
 718
 719    if (!_mesa_initialize_context(&ctx->glcontext, &visual->glvisual,
 720                                  share ? &share->glcontext : NULL,
 721                                  &functions, (void *) ctx)) {
 722       free(ctx);
 723       return NULL;
 724    }
 725
 726    ctx->visual = visual;
 727
 728    /* Create module contexts */
 729    glctx = (GLcontext *) &ctx->glcontext;
 730    _swrast_CreateContext( glctx );
 731    _vbo_CreateContext( glctx );
 732    _tnl_CreateContext( glctx );
 733    _swsetup_CreateContext( glctx );
 734    _swsetup_Wakeup( glctx );
 735
 736    /* use default TCL pipeline */
 737    {
 738       TNLcontext *tnl = TNL_CONTEXT(glctx);
 739       tnl->Driver.RunPipeline = _tnl_run_pipeline;
 740    }
 741
 742    _mesa_enable_sw_extensions(glctx);
 743    _mesa_enable_1_3_extensions(glctx);
 744    _mesa_enable_1_4_extensions(glctx);
 745    _mesa_enable_1_5_extensions(glctx);
 746    _mesa_enable_2_0_extensions(glctx);
 747    _mesa_enable_2_1_extensions(glctx);
 748
 749    return ctx;
 750 }
 751
 752
 753 void
 754 glFBDevDestroyContext( GLFBDevContextPtr context )
 755 {
 756    GLFBDevContextPtr fbdevctx = glFBDevGetCurrentContext();
 757
 758    if (context) {
 759       GLcontext *mesaCtx = &context->glcontext;
 760
 761       _swsetup_DestroyContext( mesaCtx );
 762       _swrast_DestroyContext( mesaCtx );
 763       _tnl_DestroyContext( mesaCtx );
 764       _vbo_DestroyContext( mesaCtx );
 765
 766       if (fbdevctx == context) {
 767          /* destroying current context */
 768          _mesa_make_current(NULL, NULL, NULL);
 769       }
 770       _mesa_free_context_data(&context->glcontext);
 771       free(context);
 772    }
 773 }
 774
 775
 776 int
 777 glFBDevGetContextAttrib( const GLFBDevContextPtr context, int attrib)
 778 {
 779    (void) context;
 780    (void) attrib;
 781    return -1;
 782 }
 783
 784
 785 GLFBDevContextPtr
 786 glFBDevGetCurrentContext( void )
 787 {
 788    GET_CURRENT_CONTEXT(ctx);
 789    return (GLFBDevContextPtr) ctx;
 790 }
 791
 792
 793 int
 794 glFBDevMakeCurrent( GLFBDevContextPtr context,
 795                     GLFBDevBufferPtr drawBuffer,
 796                     GLFBDevBufferPtr readBuffer )
 797 {
 798    if (context && drawBuffer && readBuffer) {
 799       /* Make sure the context's visual and the buffers' visuals match.
 800        * XXX we might do this by comparing specific fields like bits_per_pixel,
 801        * visual, etc. in the future.
 802        */
 803       if (context->visual != drawBuffer->visual ||
 804           context->visual != readBuffer->visual) {
 805          return 0;
 806       }
 807       _mesa_make_current( &context->glcontext,
 808                           &drawBuffer->glframebuffer,
 809                           &readBuffer->glframebuffer );
 810       context->drawBuffer = drawBuffer;
 811       context->readBuffer = readBuffer;
 812       context->curBuffer = drawBuffer;
 813    }
 814    else {
 815       /* unbind */
 816       _mesa_make_current( NULL, NULL, NULL );
 817    }
 818
 819    return 1;
 820 }
 821
 822 #endif /* USE_GLFBDEV_DRIVER */