Magellan Linux

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

    Contents 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 - (show annotations) (download)
    Tue May 8 20:52:56 2007 UTC (17 years ago) by niro
    File size: 11609 byte(s) 
    -import
    1 --- ./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