Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/xorg-server/patches/xorg-server-1.1.1-aiglx-mesa-copy-sub-buffer.patch

    Annotation of /trunk/xorg-server/patches/xorg-server-1.1.1-aiglx-mesa-copy-sub-buffer.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 153 - (hide annotations) (download)
    Tue May 8 20:52:56 2007 UTC (17 years ago) by niro
    File size: 11609 byte(s) 
    -import
    1 niro 153 --- ./GL/glx/glxdrawable.h.mesa-copy-sub-buffer 2006-07-06 21:40:41.000000000 -0400
    2     +++ ./GL/glx/glxdrawable.h 2006-07-06 21:56:33.000000000 -0400
    3     @@ -58,6 +58,8 @@
    4     void (*destroy)(__GLXdrawable *private);
    5     GLboolean (*resize)(__GLXdrawable *private);
    6     GLboolean (*swapBuffers)(__GLXdrawable *);
    7     + void (*copySubBuffer)(__GLXdrawable *drawable,
    8     + int x, int y, int w, int h);
    9    
    10     /*
    11     ** list of drawable private structs
    12     --- ./GL/glx/glxcmds.c.mesa-copy-sub-buffer 2006-07-06 21:40:41.000000000 -0400
    13     +++ ./GL/glx/glxcmds.c 2006-07-06 22:30:01.000000000 -0400
    14     @@ -1331,21 +1331,14 @@
    15    
    16     /*****************************************************************************/
    17    
    18     -/*
    19     -** NOTE: There is no portable implementation for swap buffers as of
    20     -** this time that is of value. Consequently, this code must be
    21     -** implemented by somebody other than SGI.
    22     -*/
    23     -int __glXSwapBuffers(__GLXclientState *cl, GLbyte *pc)
    24     +static __GLXdrawable *
    25     +SyncContextGetDrawable (__GLXclientState *cl, GLXContextTag tag,
    26     + XID drawId, int *status)
    27     {
    28     ClientPtr client = cl->client;
    29     DrawablePtr pDraw;
    30     - xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
    31     - GLXContextTag tag = req->contextTag;
    32     - XID drawId = req->drawable;
    33     __GLXpixmap *pGlxPixmap;
    34     __GLXcontext *glxc = NULL;
    35     - int error;
    36    
    37     /*
    38     ** Check that the GLX drawable is valid.
    39     @@ -1361,11 +1354,11 @@
    40     ** Drawable is an X pixmap, which is not allowed.
    41     */
    42     client->errorValue = drawId;
    43     - return __glXBadDrawable;
    44     + *status = __glXBadDrawable;
    45     + return NULL;
    46     }
    47     } else {
    48     - pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId,
    49     - __glXPixmapRes);
    50     + pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId, __glXPixmapRes);
    51     if (pGlxPixmap) {
    52     /*
    53     ** Drawable is a GLX pixmap.
    54     @@ -1375,21 +1368,23 @@
    55     ** Drawable is neither a X window nor a GLX pixmap.
    56     */
    57     client->errorValue = drawId;
    58     - return __glXBadDrawable;
    59     + *status = __glXBadDrawable;
    60     + return NULL;
    61     }
    62     }
    63    
    64     if (tag) {
    65     glxc = __glXLookupContextByTag(cl, tag);
    66     if (!glxc) {
    67     - return __glXBadContextTag;
    68     + *status = __glXBadContextTag;
    69     + return NULL;
    70     }
    71     /*
    72     ** The calling thread is swapping its current drawable. In this case,
    73     ** glxSwapBuffers is in both GL and X streams, in terms of
    74     ** sequentiality.
    75     */
    76     - if (__glXForceCurrent(cl, tag, &error)) {
    77     + if (__glXForceCurrent(cl, tag, status)) {
    78     /*
    79     ** Do whatever is needed to make sure that all preceding requests
    80     ** in both streams are completed before the swap is executed.
    81     @@ -1397,33 +1392,53 @@
    82     CALL_Finish( GET_DISPATCH(), () );
    83     __GLX_NOTE_FLUSHED_CMDS(glxc);
    84     } else {
    85     - return error;
    86     + return NULL;
    87     }
    88     }
    89    
    90     + *status = Success;
    91     if (pDraw) {
    92     - __GLXdrawable *glxPriv;
    93     + __GLXdrawable *glxPriv;
    94    
    95     if (glxc) {
    96     glxPriv = __glXGetDrawable(glxc, pDraw, drawId);
    97     if (glxPriv == NULL) {
    98     - return __glXBadDrawable;
    99     + *status = __glXBadDrawable;
    100     + return NULL;
    101     }
    102     }
    103     else {
    104     glxPriv = __glXFindDrawable(drawId);
    105     if (glxPriv == NULL) {
    106     /* This is a window we've never seen before, do nothing */
    107     - return Success;
    108     + return NULL;
    109     }
    110     }
    111    
    112     - if ((*glxPriv->swapBuffers)(glxPriv) == GL_FALSE) {
    113     - return __glXBadDrawable;
    114     - }
    115     + return glxPriv;
    116     }
    117    
    118     - return Success;
    119     + return NULL;
    120     +}
    121     +
    122     +/*
    123     +** NOTE: There is no portable implementation for swap buffers as of
    124     +** this time that is of value. Consequently, this code must be
    125     +** implemented by somebody other than SGI.
    126     +*/
    127     +int __glXSwapBuffers(__GLXclientState *cl, GLbyte *pc)
    128     +{
    129     + xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
    130     + GLXContextTag tag = req->contextTag;
    131     + __GLXdrawable *glxPriv;
    132     + int status;
    133     +
    134     + glxPriv = SyncContextGetDrawable (cl, tag, req->drawable, &status);
    135     + if (glxPriv && (*glxPriv->swapBuffers)(glxPriv) == GL_FALSE) {
    136     + return __glXBadDrawable;
    137     + }
    138     +
    139     + return status;
    140     }
    141    
    142    
    143     @@ -1544,6 +1559,30 @@
    144     pGlxPixmap);
    145     }
    146    
    147     +int __glXCopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
    148     +{
    149     + xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
    150     + GLXContextTag tag = req->contextTag;
    151     + __GLXdrawable *glxPriv;
    152     + GLXDrawable drawId;
    153     + int x, y, width, height;
    154     + int status;
    155     +
    156     + pc += __GLX_VENDPRIV_HDR_SIZE;
    157     +
    158     + drawId = *((CARD32 *) (pc));
    159     + x = *((INT32 *) (pc + 4));
    160     + y = *((INT32 *) (pc + 8));
    161     + width = *((INT32 *) (pc + 12));
    162     + height = *((INT32 *) (pc + 16));
    163     +
    164     + glxPriv = SyncContextGetDrawable (cl, tag, drawId, &status);
    165     + if (glxPriv)
    166     + (*glxPriv->copySubBuffer)(glxPriv, x, y, width, height);
    167     +
    168     + return status;
    169     +}
    170     +
    171     /*
    172     ** Get drawable attributes
    173     */
    174     @@ -2173,7 +2212,9 @@
    175     case X_GLXvop_BindTexImageEXT:
    176     return __glXBindTexImageEXT(cl, pc);
    177     case X_GLXvop_ReleaseTexImageEXT:
    178     - return __glXReleaseTexImageEXT(cl, pc);
    179     + return __glXReleaseTexImageEXT(cl, pc);
    180     + case X_GLXvop_CopySubBufferMESA:
    181     + return __glXCopySubBufferMESA(cl, pc);
    182     }
    183     #endif
    184    
    185     --- ./GL/glx/glxdri.c.mesa-copy-sub-buffer 2006-07-06 21:40:41.000000000 -0400
    186     +++ ./GL/glx/glxdri.c 2006-07-06 21:59:38.000000000 -0400
    187     @@ -112,12 +112,28 @@
    188     * months ago. :(
    189     * 20050727 - Gut all the old interfaces. This breaks compatability with
    190     * any DRI driver built to any previous version.
    191     + * 20060314 - Added support for GLX_MESA_copy_sub_buffer.
    192     */
    193     +
    194     #define INTERNAL_VERSION 20050727
    195    
    196     static const char CREATE_NEW_SCREEN_FUNC[] =
    197     "__driCreateNewScreen_" STRINGIFY (INTERNAL_VERSION);
    198    
    199     +/* The DRI driver entry point version wasn't bumped when the
    200     + * copySubBuffer functionality was added to the DRI drivers, but the
    201     + * functionality is still conditional on the value of the
    202     + * internal_api_version passed to __driCreateNewScreen. However, the
    203     + * screen constructor doesn't fail for a DRI driver that's older than
    204     + * the passed in version number, so there's no way we can know for
    205     + * sure that we can actually use the copySubBuffer functionality. But
    206     + * since the earliest (and at this point only) released mesa version
    207     + * (6.5) that uses the 20050727 entry point does have copySubBuffer,
    208     + * we'll just settle for that. We still have to pass in a higher to
    209     + * the screen constructor to enable the functionality.
    210     + */
    211     +#define COPY_SUB_BUFFER_INTERNAL_VERSION 20060314
    212     +
    213     static void
    214     __glXDRIleaveServer(void)
    215     {
    216     @@ -177,6 +193,27 @@
    217     return TRUE;
    218     }
    219    
    220     +static void
    221     +__glXDRIdrawableCopySubBuffer(__GLXdrawable *basePrivate,
    222     + int x, int y, int w, int h)
    223     +{
    224     + __GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
    225     + __GLXDRIscreen *screen;
    226     +
    227     + /* FIXME: We're jumping through hoops here to get the DRIdrawable
    228     + * which the dri driver tries to keep to it self... cf. FIXME in
    229     + * createDrawable. */
    230     +
    231     + screen = (__GLXDRIscreen *) __glXgetActiveScreen(private->base.pDraw->pScreen->myNum);
    232     + private->driDrawable = (screen->driScreen.getDrawable)(NULL,
    233     + private->base.drawId,
    234     + screen->driScreen.private);
    235     +
    236     + (*private->driDrawable->copySubBuffer)(NULL,
    237     + private->driDrawable->private,
    238     + x, y, w, h);
    239     +}
    240     +
    241     static __GLXdrawable *
    242     __glXDRIcontextCreateDrawable(__GLXcontext *context,
    243     DrawablePtr pDraw,
    244     @@ -195,10 +232,11 @@
    245     return NULL;
    246     }
    247    
    248     - private->base.destroy = __glXDRIdrawableDestroy;
    249     - private->base.resize = __glXDRIdrawableResize;
    250     - private->base.swapBuffers = __glXDRIdrawableSwapBuffers;
    251     -
    252     + private->base.destroy = __glXDRIdrawableDestroy;
    253     + private->base.resize = __glXDRIdrawableResize;
    254     + private->base.swapBuffers = __glXDRIdrawableSwapBuffers;
    255     + private->base.copySubBuffer = __glXDRIdrawableCopySubBuffer;
    256     +
    257     #if 0
    258     /* FIXME: It would only be natural that we called
    259     * driScreen->createNewDrawable here but the DRI drivers manage
    260     @@ -218,7 +256,6 @@
    261     return &private->base;
    262     }
    263    
    264     -
    265     static void
    266     __glXDRIcontextDestroy(__GLXcontext *baseContext)
    267     {
    268     @@ -770,7 +807,7 @@
    269     __DRIframebuffer framebuffer;
    270     int fd = -1;
    271     int status;
    272     - int api_ver = INTERNAL_VERSION;
    273     + int api_ver = COPY_SUB_BUFFER_INTERNAL_VERSION;
    274     drm_magic_t magic;
    275     drmVersionPtr version;
    276     char *driverName;
    277     --- ./GL/glx/g_disptab.h.mesa-copy-sub-buffer 2006-03-11 19:11:33.000000000 -0500
    278     +++ ./GL/glx/g_disptab.h 2006-07-06 21:56:33.000000000 -0400
    279     @@ -48,6 +48,7 @@
    280     extern int __glXSwapBuffers(__GLXclientState*, GLbyte*);
    281     extern int __glXBindTexImageEXT(__GLXclientState *cl, GLbyte *pc);
    282     extern int __glXReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc);
    283     +extern int __glXCopySubBufferMESA(__GLXclientState *cl, GLbyte *pc);
    284     extern int __glXGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
    285     extern int __glXUseXFont(__GLXclientState*, GLbyte*);
    286     extern int __glXCreateGLXPixmap(__GLXclientState*, GLbyte*);
    287     @@ -76,6 +77,7 @@
    288     extern int __glXSwapSwapBuffers(__GLXclientState*, GLbyte*);
    289     extern int __glXSwapBindTexImageEXT(__GLXclientState *cl, GLbyte *pc);
    290     extern int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc);
    291     +extern int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc);
    292     extern int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
    293     extern int __glXSwapUseXFont(__GLXclientState*, GLbyte*);
    294     extern int __glXSwapCreateGLXPixmap(__GLXclientState*, GLbyte*);
    295     @@ -105,4 +107,11 @@
    296     extern __GLXdispatchSingleProcPtr __glXSingleTable[__GLX_SINGLE_TABLE_SIZE];
    297     extern __GLXdispatchRenderProcPtr __glXSwapRenderTable[__GLX_RENDER_TABLE_SIZE];
    298     extern __GLXdispatchSingleProcPtr __glXSwapSingleTable[__GLX_SINGLE_TABLE_SIZE];
    299     +
    300     +/* Copied from mesa src/glx/x11/glxcmds.c
    301     + *
    302     + * Apparently there's no standardized opcode for this extension.
    303     + */
    304     +#define X_GLXvop_CopySubBufferMESA 5154 /* temporary */
    305     +
    306     #endif /* _GLX_g_disptab_h_ */
    307     --- ./GL/glx/glxscreens.c.mesa-copy-sub-buffer 2006-03-20 15:10:29.000000000 -0500
    308     +++ ./GL/glx/glxscreens.c 2006-07-06 21:56:33.000000000 -0400
    309     @@ -139,6 +139,7 @@
    310     "GLX_SGIX_swap_barrier "
    311     #endif
    312     "GLX_SGIX_fbconfig "
    313     + "GLX_MESA_copy_sub_buffer "
    314     ;
    315    
    316     __GLXscreen **__glXActiveScreens;
    317     --- ./GL/glx/glxcmdsswap.c.mesa-copy-sub-buffer 2006-04-02 22:09:15.000000000 -0400
    318     +++ ./GL/glx/glxcmdsswap.c 2006-07-06 21:56:33.000000000 -0400
    319     @@ -432,6 +432,31 @@
    320     return __glXReleaseTexImageEXT(cl, (GLbyte *)pc);
    321     }
    322    
    323     +int __glXSwapCopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
    324     +{
    325     + xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
    326     + GLXDrawable *drawId;
    327     + int *buffer;
    328     +
    329     + (void) drawId;
    330     + (void) buffer;
    331     +
    332     + __GLX_DECLARE_SWAP_VARIABLES;
    333     +
    334     + pc += __GLX_VENDPRIV_HDR_SIZE;
    335     +
    336     + __GLX_SWAP_SHORT(&req->length);
    337     + __GLX_SWAP_INT(&req->contextTag);
    338     + __GLX_SWAP_INT(pc);
    339     + __GLX_SWAP_INT(pc + 4);
    340     + __GLX_SWAP_INT(pc + 8);
    341     + __GLX_SWAP_INT(pc + 12);
    342     + __GLX_SWAP_INT(pc + 16);
    343     +
    344     + return __glXCopySubBufferMESA(cl, pc);
    345     +
    346     +}
    347     +
    348     int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
    349     {
    350     xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *)pc;
    351     @@ -899,7 +924,9 @@
    352     case X_GLXvop_BindTexImageEXT:
    353     return __glXSwapBindTexImageEXT(cl, pc);
    354     case X_GLXvop_ReleaseTexImageEXT:
    355     - return __glXSwapReleaseTexImageEXT(cl, pc);
    356     + return __glXSwapReleaseTexImageEXT(cl, pc);
    357     + case X_GLXvop_CopySubBufferMESA:
    358     + return __glXSwapCopySubBufferMESA(cl, pc);
    359     }
    360     #endif
    361