tizen/src/hw/opengl_exec.c

   1 /*
   2  *  Host-side implementation of GL/GLX API
   3  *
   4  *  Copyright (c) 2006,2007 Even Rouault
   5  *
   6  *  modified by:
   7  *    Gordon Williams <gordon.williams@collabora.co.uk>
   8  *    Ian Molton <ian.molton@collabora.co.uk>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  23  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISiNG FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  26  * THE SOFTWARE.
  27  */
  28
  29 #include <stdlib.h>
  30 #include <assert.h>
  31 #include <string.h>
  32 #include <sys/types.h> // for pid_t
  33
  34 #include "qemu-common.h"
  35
  36 /* GW: dyngen-exec.h defines its own version of stuff that is in stdio.h -
  37    only it misses things and is mildly different to stdio \o/. Hence
  38    don't include stdio and make our own defines. */
  39
  40 /*
  41 #ifdef DEBUG_GL
  42 #ifdef _WIN32
  43 #define DEBUGF(...) printf(__VA_ARGS__)
  44 #else
  45 #define DEBUGF(...) fprintf(stderr, __VA_ARGS__)
  46 #endif
  47 #else
  48 #define DEBUGF(...) while(0) {printf(__VA_ARGS__); }
  49 #endif
  50 */
  51 #include "tizen/src/debug_ch.h"
  52 MULTI_DEBUG_CHANNEL(qemu, opengl);
  53 #define DEBUGF          TRACE
  54
  55 #define GL_GLEXT_PROTOTYPES
  56 #define GLX_GLXEXT_PROTOTYPES
  57 #include <mesa_gl.h>
  58
  59 #include "qemu-queue.h"
  60 #include "opengl_func.h"
  61 #include "mesa_mipmap.h"
  62 #include "opengl_process.h"
  63 #include "range_alloc.h"
  64 #include "gloffscreen.h"
  65
  66
  67 /** Misc X11/GLX defines - we don't want to include the whole files for these
  68  * as we need them on Windows too */
  69 typedef int Bool;
  70 const Bool True = 1;
  71 const Bool False = 0;
  72 typedef struct __GLXFBConfigRec GLXFBConfig;
  73 struct __GLXFBConfigRec {
  74   int formatFlags;
  75 };
  76
  77 // #defines from glx.h
  78 #define GLX_VENDOR              1
  79 #define GLX_VERSION             2
  80 #define GLX_EXTENSIONS          3
  81
  82 /* We'll say the XVisual Id is actually just an index into here */
  83 const GLXFBConfig FBCONFIGS[] = {
  84     {GLO_FF_ALPHA|GLO_FF_BITS_32},
  85     {GLO_FF_ALPHA|GLO_FF_BITS_32|GLO_FF_DEPTH_24},
  86     {GLO_FF_ALPHA|GLO_FF_BITS_32|GLO_FF_DEPTH_24|GLO_FF_STENCIL_8},
  87 /*
  88     {GLO_FF_BITS_32},
  89     {GLO_FF_BITS_32|GLO_FF_DEPTH_24},
  90     {GLO_FF_BITS_32|GLO_FF_DEPTH_24|GLO_FF_STENCIL_8},
  91
  92     {GLO_FF_BITS_24},
  93     {GLO_FF_BITS_24|GLO_FF_DEPTH_24},
  94     {GLO_FF_BITS_24|GLO_FF_DEPTH_24|GLO_FF_STENCIL_8},
  95 */
  96 /*
  97     {GLO_FF_BITS_16},
  98     {GLO_FF_BITS_16|GLO_FF_DEPTH_24},
  99     {GLO_FF_BITS_16|GLO_FF_DEPTH_24|GLO_FF_STENCIL_8},*/
 100 };
 101
 102 #define FAKE_GL_VENDOR     "Qemu"
 103 #define FAKE_GL_RENDERER   "VMGL Passthrough"
 104 #define FAKE_GL_VERSION    "1.4"
 105 #define FAKE_GL_MAJOR      1
 106
 107
 108 #define FAKE_GLX_VENDOR     "Qemu"
 109 #define FAKE_GLX_VERSION_STRING "1.2"
 110 #define FAKE_GLX_VERSION_MAJOR 1
 111 #define FAKE_GLX_VERSION_MINOR 2
 112
 113 void *g_malloc(size_t size);
 114 void *g_realloc(void *ptr, size_t size);
 115 void g_free(void *ptr);
 116
 117 /*#define glGetError() 0*/
 118
 119 #define GET_EXT_PTR(type, funcname, args_decl) \
 120     static int detect_##funcname = 0; \
 121     static type(*ptr_func_##funcname)args_decl = NULL; \
 122     if (detect_##funcname == 0) \
 123     { \
 124         detect_##funcname = 1; \
 125         ptr_func_##funcname = (type(*)args_decl)glo_getprocaddress((const char*)#funcname); \
 126         assert (ptr_func_##funcname); \
 127     }
 128
 129 #define GET_EXT_PTR_NO_FAIL(type, funcname, args_decl) \
 130     static int detect_##funcname = 0; \
 131     static type(*ptr_func_##funcname)args_decl = NULL; \
 132     if (detect_##funcname == 0) \
 133     { \
 134         detect_##funcname = 1; \
 135         ptr_func_##funcname = (type(*)args_decl)glo_getprocaddress((const char*)#funcname); \
 136     }
 137
 138 #ifndef WIN32
 139 #include <dlfcn.h>
 140 #endif
 141
 142 static void *get_glu_ptr(const char *name)
 143 {
 144     static void *handle = (void *) -1;
 145
 146     if (handle == (void *) -1) {
 147 #ifndef WIN32
 148         handle = dlopen("libGLU.so", RTLD_LAZY);
 149         if (!handle)
 150             DEBUGF("can't load libGLU.so : %s\n", dlerror());
 151 #else
 152         handle = (void *) LoadLibrary("glu32.dll");
 153         if (!handle)
 154             DEBUGF("can't load glu32.dll\n");
 155 #endif
 156     }
 157     if (handle) {
 158 #ifndef WIN32
 159         return dlsym(handle, name);
 160 #else
 161         return GetProcAddress(handle, name);
 162 #endif
 163     }
 164     return NULL;
 165 }
 166
 167 #define GET_GLU_PTR(type, funcname, args_decl) \
 168     static int detect_##funcname = 0; \
 169     static type(*ptr_func_##funcname)args_decl = NULL; \
 170     if (detect_##funcname == 0) \
 171     { \
 172         detect_##funcname = 1; \
 173         ptr_func_##funcname = (type(*)args_decl)get_glu_ptr(#funcname); \
 174     }
 175
 176 int display_function_call = 0;
 177 extern int kill_process;
 178
 179 typedef struct {
 180     void *key;
 181     void *value;
 182 } Assoc;
 183
 184 #define MAX_HANDLED_PROCESS 100
 185 #define MAX_ASSOC_SIZE 100
 186
 187 #define MAX_FBCONFIG 10
 188
 189 #define MAX_PENDING_DRAWABLE 8
 190
 191 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
 192 #define DIM(X) (sizeof(X) / sizeof(X[0]))
 193
 194 typedef struct {
 195     GLbitfield mask;
 196     int activeTextureIndex;
 197 } ClientState;
 198
 199 #define MAX_CLIENT_STATE_STACK_SIZE 16
 200
 201 typedef void *ClientGLXDrawable;
 202
 203 typedef struct GLState GLState;
 204
 205 enum {
 206     SURFACE_WINDOW,
 207     SURFACE_PIXMAP,
 208     SURFACE_PBUFFER,
 209 };
 210
 211 enum {
 212         SURFACE_PENDING,    /* Created with light-weight context */
 213         SURFACE_ACTIVE,     /* Ready after MakeCurrent */
 214 };
 215
 216 typedef struct QGloSurface {
 217     GLState *glstate;
 218     GloSurface *surface;
 219     ClientGLXDrawable *client_drawable;
 220     int type; /* window, pixmap or pbuffer */
 221     int ready;
 222         int status;
 223     int ref;
 224     QTAILQ_ENTRY(QGloSurface) next;
 225 } QGloSurface;
 226
 227 #define MAX_PIXMAP_TEXTURE 32
 228 typedef struct PixmapTexture {
 229     unsigned int used;
 230     unsigned int texture;
 231     ClientGLXDrawable drawable;
 232 } PixmapTexture;
 233
 234 struct GLState {
 235     int ref;
 236     int fake_ctxt;
 237     int fake_shareList;
 238
 239     GloContext *context; // context (owned by this)
 240     QGloSurface *current_qsurface; // current rendering surface/drawable
 241     QTAILQ_HEAD(, QGloSurface) qsurfaces; // list of surfaces/drawables for
 242                                           // this context
 243
 244     void *vertexPointer;
 245     void *normalPointer;
 246     void *colorPointer;
 247     void *secondaryColorPointer;
 248     void *indexPointer;
 249     void *texCoordPointer[NB_MAX_TEXTURES];
 250     void *edgeFlagPointer;
 251     void *vertexAttribPointer[MY_GL_MAX_VERTEX_ATTRIBS_ARB];
 252     void *vertexAttribPointerNV[MY_GL_MAX_VERTEX_ATTRIBS_NV];
 253     void *weightPointer;
 254     void *matrixIndexPointer;
 255     void *fogCoordPointer;
 256     void *variantPointerEXT[MY_GL_MAX_VARIANT_POINTER_EXT];
 257     void *interleavedArrays;
 258     void *elementPointerATI;
 259
 260     int vertexPointerSize;
 261     int normalPointerSize;
 262     int colorPointerSize;
 263     int secondaryColorPointerSize;
 264     int indexPointerSize;
 265     int texCoordPointerSize[NB_MAX_TEXTURES];
 266     int edgeFlagPointerSize;
 267     int vertexAttribPointerSize[MY_GL_MAX_VERTEX_ATTRIBS_ARB];
 268     int vertexAttribPointerNVSize[MY_GL_MAX_VERTEX_ATTRIBS_NV];
 269     int weightPointerSize;
 270     int matrixIndexPointerSize;
 271     int fogCoordPointerSize;
 272     int variantPointerEXTSize[MY_GL_MAX_VARIANT_POINTER_EXT];
 273     int interleavedArraysSize;
 274     int elementPointerATISize;
 275
 276     int selectBufferSize;
 277     void *selectBufferPtr;
 278     int feedbackBufferSize;
 279     void *feedbackBufferPtr;
 280
 281     ClientState clientStateStack[MAX_CLIENT_STATE_STACK_SIZE];
 282     int clientStateSp;
 283     int activeTextureIndex;
 284
 285     unsigned int ownTabTextures[32768];
 286     unsigned int *tabTextures;
 287     /* The mapping between the texture and pixmap used as texture */
 288     PixmapTexture pixmapTextures[MAX_PIXMAP_TEXTURE];
 289     unsigned int bindTexture2D;
 290     RangeAllocator ownTextureAllocator;
 291     RangeAllocator *textureAllocator;
 292
 293     unsigned int ownTabBuffers[32768];
 294     unsigned int *tabBuffers;
 295     RangeAllocator ownBufferAllocator;
 296     RangeAllocator *bufferAllocator;
 297
 298     unsigned int ownTabLists[32768];
 299     unsigned int *tabLists;
 300     RangeAllocator ownListAllocator;
 301     RangeAllocator *listAllocator;
 302
 303 };
 304
 305 typedef struct {
 306     ProcessStruct p;
 307
 308     int next_available_context_number;
 309
 310     int nb_states;
 311     GLState default_state;
 312     GLState **glstates;
 313     GLState *current_state;
 314
 315     /* Pending drawables that will be used as texture  */
 316     ClientGLXDrawable pending_drawables[MAX_PENDING_DRAWABLE];
 317
 318     /* Created Pixmap surfaces, will link to context in MakeCurrent */
 319     QGloSurface **pending_qsurfaces;
 320     int nb_qsurf;
 321
 322     int nfbconfig;
 323     const GLXFBConfig *fbconfigs[MAX_FBCONFIG];
 324     int fbconfigs_max[MAX_FBCONFIG];
 325     int nfbconfig_total;
 326
 327     int primitive;
 328     int bufsize;
 329     int bufstart;
 330     arg_t *cmdbuf;
 331 } ProcessState;
 332
 333 static ProcessState processes[MAX_HANDLED_PROCESS];
 334
 335 static char *strip_extensions(const char *avail, const char *ext[]) {
 336     char *pos, *supported, *srcp;
 337
 338     supported = (char *)g_malloc(strlen(avail) + 2);
 339
 340     pos = supported;
 341     while(*ext) {
 342         srcp = (char*)avail;
 343         while((srcp = strstr(srcp, *ext))) {
 344             int len = strlen(*ext);
 345             if(*(srcp+len) == ' ' || *(srcp+len) == '\0') {
 346                 strcpy(pos, *ext);
 347                 pos += len;
 348                 if(*(srcp+len) == ' ') {
 349                     *pos = ' ';
 350                     pos++;
 351                 }
 352                 break;
 353             }
 354             srcp += len;
 355         }
 356         ext++;
 357     }
 358     *pos = ' ';
 359     *pos = '\0';
 360
 361   return supported;
 362 }
 363
 364 static const char *glx_ext_supported[] = {
 365     "GLX_ARB_multisample",
 366     0
 367 };
 368
 369 static char *supported_glx_extensions() {
 370     static char *supported;
 371
 372     if(!supported)
 373       supported = strip_extensions(glo_glXQueryExtensionsString(),
 374                                    glx_ext_supported);
 375
 376     return supported;
 377 }
 378
 379 static const char *gl_ext_supported[] = {
 380 // Mandatory OpenGL 1.4 Extensions
 381     "GL_ARB_depth_texture",
 382     "GL_ARB_multisample",
 383     "GL_ARB_multitexture",
 384     "GL_ARB_point_parameters",
 385     "GL_ARB_shadow",
 386     "GL_ARB_texture_border_clamp",
 387     "GL_ARB_texture_compression",
 388     "GL_ARB_texture_cube_map",
 389     "GL_ARB_texture_env_add",
 390     "GL_ARB_texture_env_combine",
 391     "GL_ARB_texture_env_crossbar",
 392     "GL_ARB_texture_env_dot3",
 393     "GL_ARB_texture_mirrored_repeat",
 394     "GL_ARB_transpose_matrix",
 395     "GL_ARB_window_pos",
 396     "GL_EXT_bgra",
 397     "GL_EXT_blend_color",
 398     "GL_EXT_blend_func_separate",
 399     "GL_EXT_blend_logic_op",
 400     "GL_EXT_blend_minmax",
 401     "GL_EXT_blend_subtract",
 402     "GL_EXT_copy_texture",
 403     "GL_EXT_draw_range_elements",
 404     "GL_EXT_fog_coord",
 405     "GL_EXT_multi_draw_arrays",
 406     "GL_EXT_packed_pixels",
 407     "GL_EXT_point_parameters",
 408     "GL_EXT_polygon_offset",
 409     "GL_EXT_rescale_normal",
 410     "GL_EXT_secondary_color",
 411     "GL_EXT_separate_specular_color",
 412     "GL_EXT_stencil_wrap",
 413     "GL_EXT_subtexture",
 414     "GL_EXT_texture",
 415     "GL_EXT_texture3D",
 416     "GL_EXT_texture_edge_clamp",
 417     "GL_EXT_texture_env_add",
 418     "GL_EXT_texture_env_combine",
 419     "GL_EXT_texture_lod",
 420     "GL_EXT_texture_lod_bias",
 421     "GL_EXT_texture_object",
 422     "GL_APPLE_packed_pixels",
 423     "GL_NV_blend_square",
 424     "GL_SGIS_generate_mipmap",
 425     "GL_SGIS_texture_border_clamp",
 426     "GL_SGIS_texture_edge_clamp",
 427     "GL_SGIS_texture_lod",
 428 // Optional extensions. If you get problems try disabling the below.
 429     "GL_EXT_compiled_vertex_array",
 430     "GL_ARB_copy_buffer",
 431     "GL_ARB_depth_clamp",
 432     "GL_ARB_draw_buffers ",
 433     "GL_ARB_draw_elements_base_vertex",
 434     "GL_ARB_fragment_program",
 435     "GL_ARB_fragment_program_shadow",
 436     "GL_ARB_fragment_shader",
 437     "GL_ARB_framebuffer_object",
 438     "GL_ARB_half_float_pixel",
 439     "GL_ARB_map_buffer_range",
 440     "GL_ARB_occlusion_query",
 441     "GL_ARB_pixel_buffer_object",
 442     "GL_ARB_point_sprite",
 443     "GL_ARB_provoking_vertex",
 444     "GL_ARB_seamless_cube_map",
 445     "GL_ARB_shader_objects",
 446     "GL_ARB_shading_language_100",
 447     "GL_ARB_shading_language_120",
 448     "GL_ARB_sync",
 449     "GL_ARB_texture_non_power_of_two",
 450     "GL_ARB_texture_rectangle",
 451     "GL_ARB_vertex_array_bgra",
 452     "GL_ARB_vertex_array_object",
 453     "GL_ARB_vertex_buffer_object",
 454     "GL_ARB_vertex_program",
 455     "GL_ARB_vertex_shader,"
 456     "GL_EXT_abgr",
 457     "GL_EXT_blend_equation_separate",
 458     "GL_EXT_cull_vertex",
 459     "GL_EXT_framebuffer_blit",
 460     "GL_EXT_framebuffer_object",
 461     "GL_EXT_gpu_program_parameters",
 462     "GL_EXT_packed_depth_stencil",
 463     "GL_EXT_pixel_buffer_object",
 464     "GL_EXT_provoking_vertex",
 465     "GL_EXT_shadow_funcs",
 466     "GL_EXT_stencil_two_side",
 467     "GL_EXT_texture_cube_map",
 468     "GL_EXT_texture_env_dot3",
 469     "GL_EXT_texture_filter_anisotropic",
 470     "GL_EXT_texture_rectangle",
 471     "GL_EXT_texture_sRGB",
 472     "GL_EXT_texture_swizzle",
 473     "GL_EXT_vertex_array",
 474     "GL_EXT_vertex_array_bgra",
 475     "GL_3DFX_texture_compression_FXT1",
 476     "GL_APPLE_client_storage",
 477     "GL_APPLE_vertex_array_object",
 478     "GL_ATI_blend_equation_separate",
 479     "GL_ATI_envmap_bumpmap",
 480     "GL_ATI_texture_env_combine3",
 481     "GL_ATI_separate_stencil",
 482     "GL_IBM_multimode_draw_arrays",
 483     "GL_IBM_rasterpos_clip",
 484     "GL_IBM_texture_mirrored_repeat",
 485     "GL_INGR_blend_func_separate",
 486     "GL_MESA_pack_invert",
 487     "GL_MESA_texture_signed_rgba",
 488     "GL_MESA_ycbcr_texture",
 489     "GL_MESA_window_pos",
 490     "GL_NV_depth_clamp",
 491     "GL_NV_light_max_exponent",
 492     "GL_NV_packed_depth_stencil",
 493     "GL_NV_texture_env_combine4",
 494     "GL_NV_texture_rectangle",
 495     "GL_NV_texgen_reflection",
 496     "GL_NV_vertex_program",
 497     "GL_NV_vertex_program1_1",
 498     "GL_OES_read_format",
 499     "GL_SUN_multi_draw_arrays",
 500     0
 501 };
 502
 503 static char *compute_gl_extensions() {
 504     static char *supported;
 505
 506     if(!supported)
 507         supported = strip_extensions((const char *)glGetString(GL_EXTENSIONS),
 508                                      gl_ext_supported);
 509
 510     return supported;
 511 }
 512
 513 static inline QGloSurface *get_qsurface_from_client_drawable(GLState *state, ClientGLXDrawable client_drawable) {
 514     QGloSurface *qsurface;
 515
 516     if(state->current_qsurface->client_drawable == client_drawable)
 517         return state->current_qsurface;
 518
 519     QTAILQ_FOREACH(qsurface, &state->qsurfaces, next) {
 520         if (qsurface->client_drawable == client_drawable)
 521             return qsurface;
 522     }
 523
 524     return NULL;
 525 }
 526
 527 // This must always be called only on surfaces belonging to the current context
 528 static inline void render_surface(QGloSurface *qsurface, int bpp, int stride, char *buffer)
 529 {
 530     int w, h;
 531     if(!qsurface->ready)
 532         return;
 533
 534     glo_surface_get_size(qsurface->surface, &w, &h);
 535
 536     glo_surface_getcontents(qsurface->surface, stride, bpp, buffer);
 537 }
 538
 539 // This must always be called only on surfaces belonging to the current context
 540 static inline void resize_surface(ProcessState *process, QGloSurface *qsurface,
 541                                   int w, int h) {
 542     GLState *glstate = qsurface->glstate;
 543     GloSurface *old_surface = qsurface->surface;
 544     GloSurface *surface;
 545
 546     DEBUGF("resize_start\n");
 547
 548     glo_surface_destroy(old_surface);
 549
 550     surface = glo_surface_create(w, h, glstate->context);
 551     qsurface->surface = surface;
 552
 553     // Client doesnt know surface is new - need to MakeCurrent
 554     if(process->current_state == qsurface->glstate) {
 555         glo_surface_makecurrent(qsurface->surface);
 556         // set the viewport while the window size is changed. It is needed
 557         // especially for the case that glViewport is not explicitly called
 558         // in program. In this case, the viewport is set to incorrectly
 559         // in the first MakeCurrent when the window size is not known.
 560         // It will not impact normal GL programs with glViewport set as
 561         // programmers want.
 562         glViewport (0, 0, w, h);
 563     }
 564     else {
 565         DEBUGF("Error: Surface is not current! %p %p\n",
 566                process->current_state,
 567                process->current_state->current_qsurface);
 568         exit(1);
 569     }
 570
 571     glstate->current_qsurface->ready = 1;
 572     DEBUGF( "resize_done\n");
 573 }
 574
 575
 576 void init_process_tab()
 577 {
 578     memset(processes, 0, sizeof(processes));
 579 }
 580
 581 #define ARG_TO_CHAR(x)                (char)(x)
 582 #define ARG_TO_UNSIGNED_CHAR(x)       (unsigned char)(x)
 583 #define ARG_TO_SHORT(x)               (short)(x)
 584 #define ARG_TO_UNSIGNED_SHORT(x)      (unsigned short)(x)
 585 #define ARG_TO_INT(x)                 (int)(x)
 586 #define ARG_TO_UNSIGNED_INT(x)        (unsigned int)(x)
 587 #define ARG_TO_FLOAT(x)               (*(float*)&(x))
 588 #define ARG_TO_DOUBLE(x)              (*(double*)(x))
 589
 590 #include "server_stub.c"
 591
 592 //typedef void *ClientGLXDrawable;
 593 static inline ClientGLXDrawable to_drawable(arg_t arg)
 594 {
 595 #ifdef TARGET_X86_64
 596     if (arg > (unsigned long) -1) {
 597         DEBUGF( "GLXDrawable too big for this implementation\n");
 598         exit(-1);
 599     }
 600 #endif
 601     return (void *) (unsigned long) arg;
 602 }
 603
 604 /* ---- */
 605
 606 /* Bind a qsurface to a context (GLState) */
 607 static void bind_qsurface(GLState *state,
 608                           QGloSurface *qsurface)
 609 {
 610     qsurface->glstate = state;
 611
 612         if ( qsurface->type == SURFACE_WINDOW )
 613                 QTAILQ_INSERT_HEAD(&state->qsurfaces, qsurface, next);
 614
 615     state->current_qsurface = qsurface;
 616 }
 617
 618 /* Unbind a qsurface from a context (GLState) */
 619 static void unbind_qsurface(GLState *state,
 620                           QGloSurface *qsurface)
 621 {
 622     qsurface->glstate = NULL;
 623
 624         if ( qsurface->type == SURFACE_WINDOW )
 625                 QTAILQ_REMOVE(&state->qsurfaces, qsurface, next);
 626
 627         if ( state->current_qsurface == qsurface )
 628                 state->current_qsurface = NULL;
 629 }
 630
 631 /* Find the qsurface with required drawable in active & pending qsurfaces */
 632 QGloSurface* find_qsurface_from_client_drawable(ProcessState *process, ClientGLXDrawable client_drawable)
 633 {
 634     /* search for surfaces in current conetxt */
 635     int i;
 636     QGloSurface *qsurface = get_qsurface_from_client_drawable(process->current_state, client_drawable);
 637
 638     if (qsurface)
 639         return qsurface;
 640
 641     /* search the pending surfaces */
 642     for ( i = 0; i < process->nb_qsurf; i++ )
 643     {
 644         qsurface = process->pending_qsurfaces[i];
 645         if ( qsurface && qsurface->client_drawable == client_drawable )
 646             return qsurface;
 647     }
 648
 649     return NULL;
 650 }
 651
 652 /* Make the appropriate qsurface current for a given client_drawable */
 653 static int set_current_qsurface(GLState *state,
 654                                 ClientGLXDrawable client_drawable)
 655 {
 656     QGloSurface *qsurface;
 657
 658     if(state->current_qsurface && state->current_qsurface->client_drawable == client_drawable)
 659         return 1;
 660
 661     QTAILQ_FOREACH(qsurface, &state->qsurfaces, next) {
 662         if(qsurface->client_drawable == client_drawable) {
 663             state->current_qsurface = qsurface;
 664                         qsurface->glstate = state;
 665             return 1;
 666         }
 667     }
 668
 669     state->current_qsurface = NULL;
 670
 671     return 0;
 672 }
 673
 674 /* */
 675 static int keep_drawable(ProcessState *process, ClientGLXDrawable drawable)
 676 {
 677     int i;
 678     for ( i = 0; i < MAX_PENDING_DRAWABLE; i++)
 679     {
 680         if ( process->pending_drawables[i] == 0 )
 681         {
 682             process->pending_drawables[i] = drawable;
 683             return 1;
 684         }
 685     }
 686     return 0;
 687 }
 688
 689 static int link_drawable(ProcessState *process, ClientGLXDrawable drawable)
 690 {
 691     int i;
 692     for ( i = 0; i < MAX_PENDING_DRAWABLE; i++ )
 693     {
 694         if ( process->pending_drawables[i] == drawable )
 695         {
 696             process->pending_drawables[i] = 0;
 697             return 1;
 698         }
 699     }
 700     return 0;
 701 }
 702
 703 /* Need to create pixmap surface when guest do so, as guest may use it before
 704  * MakeCurrent. As no context available at this point, we do the follwoing:
 705  * 1. Create one light-weight context just for surface creation.
 706  * 2. Store this qsurface, and link it with right context when MakeCurrent
 707  */
 708 static void keep_qsurface(ProcessState *process, QGloSurface *qsurface)
 709 {
 710     int i;
 711     process->pending_qsurfaces =
 712         g_realloc(process->pending_qsurfaces,
 713                   (process->nb_qsurf + 1) * sizeof(QGloSurface*));
 714
 715     process->pending_qsurfaces[process->nb_qsurf] = qsurface;
 716
 717     process->nb_qsurf++;
 718 }
 719
 720 static int link_qsurface(ProcessState *process, GLState *glstate, ClientGLXDrawable client_drawable)
 721 {
 722     int i;
 723     QGloSurface *qsurface;
 724     for ( i = 0; i < process->nb_qsurf; i++ )
 725     {
 726         qsurface = process->pending_qsurfaces[i];
 727         if ( qsurface && qsurface->client_drawable == client_drawable )
 728         {
 729             /* XXX:Current limitation is that each surface is binded to one
 730              * context, and not accessible from another context. It's hard for
 731              * glEGLImageTargetTexture2DOES implementation, in which we need
 732              * find a pixmap surface from another context that is not owner of
 733              * this pixmap. So do not move this pending pixmap surface into
 734              * current context. In future need decople of surface and context.
 735              * */
 736 #if 0
 737             memmove(&process->pending_qsurfaces[i],
 738                     &process->pending_qsurfaces[i+1],
 739                     (process->nb_qsurf - i - 1) * sizeof(QGloSurface*));
 740 #endif
 741
 742             qsurface->ref = 1;
 743                         if(qsurface->status == SURFACE_PENDING)
 744                         {
 745                                 glo_surface_update_context(qsurface->surface, glstate->context, 1);
 746                                 qsurface->status = SURFACE_ACTIVE;
 747                         }
 748                         else
 749                         {
 750                                 unbind_qsurface(qsurface->glstate, qsurface);
 751                                 glo_surface_update_context(qsurface->surface, glstate->context, 0);
 752
 753                         }
 754
 755             bind_qsurface(glstate, qsurface);
 756             return 1;
 757         }
 758     }
 759
 760     return 0;
 761 }
 762
 763 /* Pixmap can be used as texture via glEGLImageTargetTexture2DOES, so need keep
 764  * the mapping between them to add proper action when bind the texture again
 765  */
 766 static void del_pixmap_texture_mapping(GLState *state,
 767         unsigned int texture)
 768 {
 769     int i;
 770     for ( i = 0; i < MAX_PIXMAP_TEXTURE; i++ )
 771     {
 772         if ( state->pixmapTextures[i].used &&
 773              state->pixmapTextures[i].texture == texture )
 774         {
 775             state->pixmapTextures[i].used = 0;
 776             state->pixmapTextures[i].texture = 0;
 777             state->pixmapTextures[i].drawable = 0;
 778             return;
 779         }
 780     }
 781 }
 782
 783 static int add_pixmap_texture_mapping(GLState *state,
 784         unsigned int texture, ClientGLXDrawable drawable)
 785 {
 786     int i;
 787     for ( i = 0; i < MAX_PIXMAP_TEXTURE; i++ )
 788     {
 789         if (  state->pixmapTextures[i].texture == texture ||
 790              !state->pixmapTextures[i].used )
 791         {
 792             state->pixmapTextures[i].used = 1;
 793             state->pixmapTextures[i].texture = texture;
 794             state->pixmapTextures[i].drawable = drawable;
 795             return 1;
 796         }
 797     }
 798
 799     if ( i >= MAX_PIXMAP_TEXTURE )
 800         return 0;
 801 }
 802
 803 static ClientGLXDrawable find_pixmap_texture(GLState *state,
 804         unsigned int texture)
 805 {
 806     int i;
 807     for ( i = 0; i < MAX_PIXMAP_TEXTURE; i++ )
 808     {
 809         if ( state->pixmapTextures[i].used &&
 810              state->pixmapTextures[i].texture == texture )
 811             return state->pixmapTextures[i].drawable;
 812     }
 813
 814     return 0;
 815 }
 816
 817 static int get_server_texture(ProcessState *process,
 818                               unsigned int client_texture)
 819 {
 820     unsigned int server_texture = 0;
 821
 822     if (client_texture < 32768) {
 823         server_texture = process->current_state->tabTextures[client_texture];
 824     } else {
 825         DEBUGF( "invalid texture name %d\n", client_texture);
 826     }
 827     return server_texture;
 828 }
 829
 830 static int get_server_buffer(ProcessState *process,
 831                              unsigned int client_buffer)
 832 {
 833     unsigned int server_buffer = 0;
 834
 835     if (client_buffer < 32768) {
 836         server_buffer = process->current_state->tabBuffers[client_buffer];
 837     } else {
 838         DEBUGF( "invalid buffer name %d\n", client_buffer);
 839     }
 840     return server_buffer;
 841 }
 842
 843
 844 static int get_server_list(ProcessState *process, unsigned int client_list)
 845 {
 846     unsigned int server_list = 0;
 847
 848     if (client_list < 32768) {
 849         server_list = process->current_state->tabLists[client_list];
 850     } else {
 851         DEBUGF( "invalid list name %d\n", client_list);
 852     }
 853     return server_list;
 854 }
 855
 856 const GLXFBConfig *get_fbconfig(ProcessState *process, int client_fbconfig)
 857 {
 858     int i;
 859     int nbtotal = 0;
 860
 861     for (i = 0; i < process->nfbconfig; i++) {
 862         assert(client_fbconfig >= 1 + nbtotal);
 863         if (client_fbconfig <= nbtotal + process->fbconfigs_max[i]) {
 864             return &process->fbconfigs[i][client_fbconfig - 1 - nbtotal];
 865         }
 866         nbtotal += process->fbconfigs_max[i];
 867     }
 868     return 0;
 869 }
 870
 871 static int glXChooseVisualFunc(const int *attrib_list)
 872 {
 873     if (attrib_list == NULL)
 874         return 0;
 875
 876     int formatFlags = glo_flags_get_from_glx(attrib_list, True);
 877     int i;
 878     int bestConfig = 0;
 879     int bestScore = -1;
 880
 881     for (i=0;i<DIM(FBCONFIGS);i++) {
 882         int score = glo_flags_score(formatFlags, FBCONFIGS[i].formatFlags);
 883         if (bestScore < 0 || score<=bestScore) {
 884             bestScore = score;
 885             bestConfig = i;
 886         }
 887     }
 888
 889     if (bestScore > 0)
 890         DEBUGF( "Got format flags %d but we couldn't find an exactly matching config, chose %d\n", formatFlags, bestConfig);
 891
 892     return bestConfig;
 893 }
 894
 895 static int glXGetConfigFunc(int visualid, int attrib, int *value) {
 896     const GLXFBConfig *config = &FBCONFIGS[0]; // default
 897     int v;
 898
 899     if (visualid>=0 && visualid<DIM(FBCONFIGS))
 900         config = &FBCONFIGS[visualid];
 901     else
 902         DEBUGF( "Unknown visual ID %d\n", visualid);
 903
 904     v = glo_get_glx_from_flags(config->formatFlags, attrib);
 905     if (value)
 906        *value = v;
 907     return 0;
 908 }
 909
 910 static const GLXFBConfig * glXGetFBConfigsFunc(int screen, int *nelements) {
 911     *nelements = DIM(FBCONFIGS);
 912     return &FBCONFIGS[0];
 913 }
 914
 915 static int glXGetFBConfigAttribFunc(const GLXFBConfig *fbconfig, int attrib, int *value) {
 916     // TODO other enums - see http://www.opengl.org/sdk/docs/man/xhtml/glXGetFBConfigAttrib.xml
 917
 918     int v = glo_get_glx_from_flags(fbconfig->formatFlags, attrib);
 919     if (value) *value = v;
 920     return 0;
 921 }
 922
 923 static const GLXFBConfig *glXChooseFBConfigFunc(int screen, const int *attrib_list, int *nelements) {
 924     if (attrib_list != NULL) {
 925         int formatFlags = glo_flags_get_from_glx(attrib_list, False);
 926         int i;
 927         int bestConfig = 0;
 928         int bestScore = -1;
 929
 930         for (i=0;i<DIM(FBCONFIGS);i++) {
 931             int score = glo_flags_score(formatFlags, FBCONFIGS[i].formatFlags);
 932             if (bestScore < 0 || score<=bestScore) {
 933                 bestScore = score;
 934                 bestConfig = i;
 935             }
 936         }
 937
 938         if (bestScore > 0) {
 939             DEBUGF( "Got format flags %d but we couldn't find an exactly matching config, chose %d\n", formatFlags, bestConfig);
 940         }
 941
 942         if (nelements)
 943             *nelements=1;
 944
 945         return &FBCONFIGS[bestConfig];
 946     }
 947
 948     if (nelements)
 949         *nelements=0;
 950
 951     return 0;
 952 }
 953
 954 static void do_glClientActiveTextureARB(int texture)
 955 {
 956     GET_EXT_PTR_NO_FAIL(void, glClientActiveTextureARB, (int));
 957
 958     if (ptr_func_glClientActiveTextureARB) {
 959         ptr_func_glClientActiveTextureARB(texture);
 960     }
 961 }
 962
 963 static void destroy_gl_state(GLState *state)
 964 {
 965     int i;
 966
 967     QGloSurface *qsurface, *tmp;
 968
 969     QTAILQ_FOREACH_SAFE(qsurface, &state->qsurfaces, next, tmp) {
 970         glo_surface_destroy(qsurface->surface);
 971         QTAILQ_REMOVE(&state->qsurfaces, qsurface, next);
 972         g_free(qsurface);
 973     }
 974
 975     if (state->context)
 976       glo_context_destroy(state->context);
 977
 978     if (state->vertexPointer)
 979         g_free(state->vertexPointer);
 980     if (state->normalPointer)
 981         g_free(state->normalPointer);
 982     if (state->indexPointer)
 983         g_free(state->indexPointer);
 984     if (state->colorPointer)
 985         g_free(state->colorPointer);
 986     if (state->secondaryColorPointer)
 987         g_free(state->secondaryColorPointer);
 988     for (i = 0; i < NB_MAX_TEXTURES; i++) {
 989         if (state->texCoordPointer[i])
 990             g_free(state->texCoordPointer[i]);
 991     }
 992     for (i = 0; i < MY_GL_MAX_VERTEX_ATTRIBS_ARB; i++) {
 993         if (state->vertexAttribPointer[i])
 994             g_free(state->vertexAttribPointer[i]);
 995     }
 996     for (i = 0; i < MY_GL_MAX_VERTEX_ATTRIBS_NV; i++) {
 997         if (state->vertexAttribPointerNV[i])
 998             g_free(state->vertexAttribPointerNV[i]);
 999     }
1000     if (state->weightPointer)
1001         g_free(state->weightPointer);
1002     if (state->matrixIndexPointer)
1003         g_free(state->matrixIndexPointer);
1004     if (state->fogCoordPointer)
1005         g_free(state->fogCoordPointer);
1006     for (i = 0; i < MY_GL_MAX_VARIANT_POINTER_EXT; i++) {
1007         if (state->variantPointerEXT[i])
1008             g_free(state->variantPointerEXT[i]);
1009     }
1010     if (state->interleavedArrays)
1011         g_free(state->interleavedArrays);
1012     if (state->elementPointerATI)
1013         g_free(state->elementPointerATI);
1014 }
1015
1016 static void init_gl_state(GLState *state)
1017 {
1018     state->textureAllocator = &state->ownTextureAllocator;
1019     state->tabTextures = state->ownTabTextures;
1020     state->bufferAllocator = &state->ownBufferAllocator;
1021     state->tabBuffers = state->ownTabBuffers;
1022     state->listAllocator = &state->ownListAllocator;
1023     state->tabLists = state->ownTabLists;
1024 }
1025
1026 /*
1027  * Translate the nth element of list from type to GLuint.
1028  */
1029 static GLuint translate_id(GLsizei n, GLenum type, const GLvoid *list)
1030 {
1031     GLbyte *bptr;
1032     GLubyte *ubptr;
1033     GLshort *sptr;
1034     GLushort *usptr;
1035     GLint *iptr;
1036     GLuint *uiptr;
1037     GLfloat *fptr;
1038
1039     switch (type) {
1040     case GL_BYTE:
1041         bptr = (GLbyte *) list;
1042         return (GLuint) *(bptr + n);
1043     case GL_UNSIGNED_BYTE:
1044         ubptr = (GLubyte *) list;
1045         return (GLuint) *(ubptr + n);
1046     case GL_SHORT:
1047         sptr = (GLshort *) list;
1048         return (GLuint) *(sptr + n);
1049     case GL_UNSIGNED_SHORT:
1050         usptr = (GLushort *) list;
1051         return (GLuint) *(usptr + n);
1052     case GL_INT:
1053         iptr = (GLint *) list;
1054         return (GLuint) *(iptr + n);
1055     case GL_UNSIGNED_INT:
1056         uiptr = (GLuint *) list;
1057         return (GLuint) *(uiptr + n);
1058     case GL_FLOAT:
1059         fptr = (GLfloat *) list;
1060         return (GLuint) *(fptr + n);
1061     case GL_2_BYTES:
1062         ubptr = ((GLubyte *) list) + 2 * n;
1063         return (GLuint) (*ubptr << 8) + (GLuint) *(ubptr + 1);
1064     case GL_3_BYTES:
1065         ubptr = ((GLubyte *) list) + 3 * n;
1066         return (GLuint) (*ubptr << 16) + (GLuint) (*(ubptr + 1) << 8) +
1067             (GLuint) *(ubptr + 2);
1068     case GL_4_BYTES:
1069         ubptr = ((GLubyte *) list) + 4 * n;
1070         return (GLuint) (*ubptr << 24) + (GLuint) (*(ubptr + 1) << 16) +
1071             (GLuint) (*(ubptr + 2) << 8) + (GLuint) *(ubptr + 3);
1072     default:
1073         return 0;
1074     }
1075 }
1076
1077 GLState *_create_context(ProcessState *process, int fake_ctxt, int fake_shareList)
1078 {
1079     // FIXMEIM - realloc? really?
1080     process->glstates = g_realloc(process->glstates,
1081                                   (process->nb_states + 1) * sizeof(GLState *));
1082
1083     process->glstates[process->nb_states] = g_malloc(sizeof(GLState));
1084     memset(process->glstates[process->nb_states], 0, sizeof(GLState));
1085
1086     process->glstates[process->nb_states]->ref = 1;
1087     process->glstates[process->nb_states]->fake_ctxt = fake_ctxt;
1088     process->glstates[process->nb_states]->fake_shareList = fake_shareList;
1089
1090     init_gl_state(process->glstates[process->nb_states]);
1091
1092     if (fake_shareList) {
1093         int i;
1094
1095         for (i = 0; i < process->nb_states; i++) {
1096             if (process->glstates[i]->fake_ctxt == fake_shareList) {
1097                 process->glstates[i]->ref++;
1098                 process->glstates[process->nb_states]->textureAllocator =
1099                     process->glstates[i]->textureAllocator;
1100                 process->glstates[process->nb_states]->tabTextures =
1101                     process->glstates[i]->tabTextures;
1102                 process->glstates[process->nb_states]->bufferAllocator =
1103                     process->glstates[i]->bufferAllocator;
1104                 process->glstates[process->nb_states]->tabBuffers =
1105                     process->glstates[i]->tabBuffers;
1106                 process->glstates[process->nb_states]->listAllocator =
1107                     process->glstates[i]->listAllocator;
1108                 process->glstates[process->nb_states]->tabLists =
1109                     process->glstates[i]->tabLists;
1110                 break;
1111             }
1112         }
1113     }
1114     process->nb_states++;
1115
1116     return process->glstates[process->nb_states-1];
1117 }
1118
1119 GLState *get_glstate_for_fake_ctxt(ProcessState *process, int fake_ctxt)
1120 {
1121     int i;
1122     for (i = 0; i < process->nb_states; i++) {
1123         if (process->glstates[i]->fake_ctxt == fake_ctxt)
1124             return process->glstates[i];
1125         }
1126
1127     return 0;
1128 }
1129
1130 void gl_disconnect(ProcessState *process)
1131 {
1132     int i;
1133     for (i = 0; i < process->nb_states; i++) {
1134         destroy_gl_state(process->glstates[i]);
1135         g_free(process->glstates[i]);
1136     }
1137     destroy_gl_state(&process->default_state);
1138     g_free(process->glstates);
1139
1140     if (process->cmdbuf)
1141         g_free(process->cmdbuf);
1142
1143     for (i = 0; &processes[i] != process; i ++) {
1144                 ; // do nothing
1145         }
1146
1147         memmove(&processes[i], &processes[i + 1],
1148                         (MAX_HANDLED_PROCESS - 1 - i) * sizeof(ProcessState));
1149 }
1150
1151 static const int beginend_allowed[GL_N_CALLS] = {
1152 #undef MAGIC_MACRO
1153 #define MAGIC_MACRO(name) [name ## _func] = 1,
1154 #include "gl_beginend.h"
1155 };
1156
1157 ProcessStruct *vmgl_get_process(pid_t pid)
1158 {
1159     ProcessState *process = NULL;
1160     static int first;
1161     int i;
1162
1163     if(!first) {
1164         first = 1;
1165         init_process_tab();
1166     }
1167
1168     /* Lookup a process stuct. If there isnt one associated with this pid
1169      * then we create one.
1170      * process->current_state contains info on which of the guests contexts is
1171      * current.
1172      */
1173     for (i = 0; i < MAX_HANDLED_PROCESS; i ++) {
1174         if (processes[i].p.process_id == pid) {
1175             process = &processes[i];
1176             break;
1177         } else if (processes[i].p.process_id == 0) {
1178             process = &processes[i];
1179             memset(process, 0, sizeof(ProcessState));
1180             process->p.process_id = pid;
1181             init_gl_state(&process->default_state);
1182             process->current_state = &process->default_state;
1183             break;
1184         }
1185         }
1186
1187     if (process == NULL) {
1188         DEBUGF( "Too many processes !\n");
1189         exit(-1);
1190     }
1191
1192     return (ProcessStruct *)process; // Cast is ok due to struct defn.
1193 }
1194
1195 void vmgl_context_switch(ProcessStruct *p, int switch_gl_context)
1196 {
1197     ProcessState *process = (ProcessState *)p;
1198     if(switch_gl_context) {
1199         if(process->current_state->current_qsurface)
1200             glo_surface_makecurrent(process->current_state->current_qsurface->surface);
1201         else
1202             glo_surface_makecurrent(0); // should never happen
1203     }
1204 }
1205
1206 static const char *opengl_strtok(const char *s, int *n, char **saveptr, char *prevbuf)
1207 {
1208         char *start;
1209         char *ret;
1210         char *p;
1211         int retlen;
1212     static const char *delim = " \t\n\r/";
1213
1214         if (prevbuf)
1215                 free(prevbuf);
1216
1217     if (s) {
1218         *saveptr = s;
1219     } else {
1220         if (!(*saveptr) || !(*n))
1221             return NULL;
1222         s = *saveptr;
1223     }
1224
1225     for (; *n && strchr(delim, *s); s++, (*n)--) {
1226         if (*s == '/' && *n > 1) {
1227             if (s[1] == '/') {
1228                 do {
1229                     s++, (*n)--;
1230                 } while (*n > 1 && s[1] != '\n' && s[1] != '\r');
1231             } else if (s[1] == '*') {
1232                 do {
1233                     s++, (*n)--;
1234                 } while (*n > 2 && (s[1] != '*' || s[2] != '/'));
1235                 s++, (*n)--;
1236                                 s++, (*n)--;
1237                                 if (*n == 0) {
1238                                         break;
1239                                 }
1240                         } else {
1241                                 break;
1242             }
1243         }
1244     }
1245
1246         start = s;
1247     for (; *n && *s && !strchr(delim, *s); s++, (*n)--) {
1248                 ; // do nothing
1249         }
1250
1251         if (*n > 0)
1252                 s++, (*n)--;
1253
1254         *saveptr = s;
1255
1256         retlen = s - start;
1257         ret = malloc(retlen + 1);
1258         p = ret;
1259
1260         if (retlen == 0) {
1261                 *p = 0;
1262                 return;
1263         }
1264
1265         while (retlen > 0) {
1266         if (*start == '/' && retlen > 1) {
1267             if (start[1] == '/') {
1268                 do {
1269                     start++, retlen--;
1270                 } while (retlen > 1 && start[1] != '\n' && start[1] != '\r');
1271                                 start++, retlen--;
1272                                 continue;
1273             } else if (start[1] == '*') {
1274                 do {
1275                     start++, retlen--;
1276                 } while (retlen > 2 && (start[1] != '*' || start[2] != '/'));
1277                 start += 3, retlen -= 3;
1278                                 continue;
1279             }
1280         }
1281                 *(p++) = *(start++), retlen--;
1282         }
1283
1284         *p = 0;
1285         return ret;
1286 }
1287
1288 static char *do_eglShaderPatch(const char *source, int length, int *patched_len)
1289 {
1290         char *saveptr = NULL;
1291         char *sp;
1292         char *p = NULL;
1293
1294     if (!length)
1295         length = strlen(source);
1296
1297     *patched_len = 0;
1298     int patched_size = length;
1299     char *patched = malloc(patched_size + 1);
1300
1301     if (!patched)
1302         return NULL;
1303
1304     p = opengl_strtok(source, &length, &saveptr, NULL);
1305     for (; p; p = opengl_strtok(0, &length, &saveptr, p)) {
1306         if (!strncmp(p, "lowp", 4) || !strncmp(p, "mediump", 7) || !strncmp(p, "highp", 5)) {
1307             continue;
1308         } else if (!strncmp(p, "precision", 9)) {
1309             while ((p = opengl_strtok(0, &length, &saveptr, p)) && !strchr(p, ';')) {
1310                                 // do nothing
1311                                 ;
1312                         }
1313         } else {
1314             if (!strncmp(p, "gl_MaxVertexUniformVectors", 26)) {
1315                 p = "(gl_MaxVertexUniformComponents / 4)";
1316             } else if (!strncmp(p, "gl_MaxFragmentUniformVectors", 28)) {
1317                 p = "(gl_MaxFragmentUniformComponents / 4)";
1318             } else if (!strncmp(p, "gl_MaxVaryingVectors", 20)) {
1319                 p = "(gl_MaxVaryingFloats / 4)";
1320             }
1321
1322             int new_len = strlen(p);
1323             if (*patched_len + new_len > patched_size) {
1324                 patched_size *= 2;
1325                 patched = realloc(patched, patched_size + 1);
1326
1327                 if (!patched)
1328                     return NULL;
1329             }
1330
1331             memcpy(patched + *patched_len, p, new_len);
1332             *patched_len += new_len;
1333         }
1334     }
1335
1336     patched[*patched_len] = 0;
1337     /* check that we don't leave dummy preprocessor lines */
1338     for (sp = patched; *sp;) {
1339         for (; *sp == ' ' || *sp == '\t'; sp++) {
1340                         ; // do nothing
1341                 }
1342         if (!strncmp(sp, "#define", 7)) {
1343             for (p = sp + 7; *p == ' ' || *p == '\t'; p++) {
1344                                 ; // do nothing
1345                         }
1346             if (*p == '\n' || *p == '\r' || *p == '/') {
1347                 memset(sp, 0x20, 7);
1348             }
1349         }
1350         for (; *sp && *sp != '\n' && *sp != '\r'; sp++) {
1351                         ; // do nothing
1352                 }
1353         for (; *sp == '\n' || *sp == '\r'; sp++) {
1354                         ; // do nothing
1355                 }
1356     }
1357     return patched;
1358 }
1359
1360 static int
1361 shadersrc_gles_to_gl(GLsizei count, const char** string, char **s, const GLint* length, GLint *l)
1362 {
1363         int i;
1364
1365         for(i = 0; i < count; ++i) {
1366                 GLint len;
1367                 if(length) {
1368                         len = length[i];
1369                         if (len < 0)
1370                                 len = string[i] ? strlen(string[i]) : 0;
1371                 } else
1372                         len = string[i] ? strlen(string[i]) : 0;
1373
1374                 if(string[i]) {
1375                         s[i] = do_eglShaderPatch(string[i], len, &l[i]);
1376                         if(!s[i]) {
1377                                 while(i) {
1378                                         free(s[--i]);
1379                                 }
1380
1381                                 free(l);
1382                                 free(s);
1383                                 return -1;
1384                         }
1385                 } else {
1386                         s[i] = NULL;
1387                         l[i] = 0;
1388                 }
1389         }
1390
1391         return 0;
1392 }
1393
1394 #ifdef __APPLE__
1395 /* XXX:This is work around fix Mac host GL driver's bug that cause webapp
1396  * screen crash. When one context use textures from other sharing context, some
1397  * textures are not initialized or shared successfully. So use glGetTexImage to
1398  * read texture back right after glTexSubImage2D, thus guarantee a
1399  * synchronization.
1400  */
1401 static void mac_dump_texture()
1402 {
1403         int w, h;
1404         unsigned char *buf;
1405
1406         /* only handle target=GL_TEXTURE_2D, level=0, format=GL_RGBA, type=GL_UNSIGNED_BYTE */
1407         glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
1408         glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &h);
1409
1410         if ( w == 0 && h == 0 )
1411                 return;
1412
1413         buf = g_malloc( (w*4) * h); /* XXX:need allignment? */
1414
1415         glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, buf);
1416
1417         g_free(buf);
1418 }
1419 #endif
1420
1421 int do_function_call(ProcessState *process, int func_number, unsigned long *args, char *ret_string)
1422 {
1423     union gl_ret_type ret;
1424
1425     Signature *signature = (Signature *) tab_opengl_calls[func_number];
1426     int ret_type = signature->ret_type;
1427
1428     ret.s = NULL;
1429
1430     if (display_function_call) {
1431         DEBUGF( "[%d]> %s\n", process->p.process_id,
1432                 tab_opengl_calls_name[func_number]);
1433     }
1434         TRACE( "[%d]> %s\n", process->p.process_id,
1435                         tab_opengl_calls_name[func_number]);
1436
1437     switch (func_number) {
1438     case -1:
1439         break;
1440
1441     case _resize_surface_func:
1442         {
1443             ClientGLXDrawable client_drawable = to_drawable(args[0]);
1444             QGloSurface *qsurface = get_qsurface_from_client_drawable(
1445                                         process->current_state, client_drawable);
1446
1447             // We have to assume the current context here
1448             // since we assume that a drawable must belong to a specific context
1449             resize_surface(process, qsurface, (int)args[1], (int)args[2]);
1450             break;
1451
1452         }
1453
1454     case _render_surface_func:
1455         {
1456             ClientGLXDrawable client_drawable = to_drawable(args[0]);
1457             QGloSurface *qsurface = get_qsurface_from_client_drawable(
1458                                         process->current_state, client_drawable);
1459             int bpp    = (int)args[1];
1460             int stride = (int)args[2];
1461             char *render_buffer = (char*)args[3];
1462
1463 //            DEBUGF( "win: %08x stride: %d buf: %08x cl_dr: %08x qsurf: %08x\n", args[0], args[1], args[2], client_drawable, qsurface);
1464
1465             // We have to assume the current context here
1466             // since we assume that a drawable must belong to a specific context
1467             render_surface(qsurface, bpp, stride, render_buffer);
1468             break;
1469
1470         }
1471
1472     case glXWaitGL_func:
1473         {
1474             glFinish(); //glXWaitGL();
1475             ret.i = 0;
1476             break;
1477         }
1478
1479     case glXWaitX_func:
1480         {
1481             // FIXME GW Maybe we should just do this on the server?
1482             //glXWaitX();
1483             ret.i = 0;
1484             break;
1485         }
1486
1487     case glXChooseVisual_func:
1488         {
1489             ret.i = glXChooseVisualFunc((int *) &args[2]);
1490             break;
1491         }
1492
1493     case glXQueryExtensionsString_func:
1494         {
1495             ret.s = supported_glx_extensions();//glXQueryExtensionsString(dpy, 0);
1496             break;
1497         }
1498
1499     case glXQueryServerString_func:
1500         {
1501             switch (args[2]) {
1502             case GLX_VENDOR : ret.s = FAKE_GLX_VENDOR; break;
1503             case GLX_VERSION : ret.s = FAKE_GLX_VERSION_STRING; break;
1504             case GLX_EXTENSIONS : ret.s = supported_glx_extensions(); break;
1505             default: ret.s = 0;
1506             }
1507             break;
1508         }
1509
1510     case glXGetClientString_func:
1511         {
1512             switch (args[1]) {
1513             case GLX_VENDOR : ret.s = FAKE_GLX_VENDOR; break;
1514             case GLX_VERSION : ret.s = FAKE_GLX_VERSION_STRING; break;
1515             case GLX_EXTENSIONS : ret.s = "GLX_ARB_get_proc_address "; break;
1516             default: ret.s = 0;
1517             }
1518             break;
1519         }
1520
1521     case glXGetScreenDriver_func:
1522         {
1523             // FIXME GW What is this? not documented anywhere!!
1524             //GET_EXT_PTR(const char *, glXGetScreenDriver, (Display *, int));
1525             //ret.s = ptr_func_glXGetScreenDriver(dpy, 0);
1526             ret.s = "";
1527             break;
1528         }
1529
1530     case glXGetDriverConfig_func:
1531         {
1532             // FIXME GW What is this? not documented anywhere!!
1533             //GET_EXT_PTR(const char *, glXGetDriverConfig, (const char *));
1534             //ret.s = ptr_func_glXGetDriverConfig((const char *) args[0]);
1535             ret.s = "";
1536             break;
1537         }
1538
1539     case glXCreateContext_func:
1540         {
1541             int visualid = (int) args[1];
1542             int fake_shareList = (int) args[2];
1543
1544             if (display_function_call)
1545                 DEBUGF( "visualid=%d, fake_shareList=%d\n", visualid,
1546                         fake_shareList);
1547
1548             GLState *shareListState = get_glstate_for_fake_ctxt(process, fake_shareList);
1549             int fake_ctxt = ++process->next_available_context_number;
1550
1551             ret.i = fake_ctxt;
1552
1553             // Work out format flags from visual id
1554             int formatFlags = GLO_FF_DEFAULT;
1555             if (visualid>=0 && visualid<DIM(FBCONFIGS))
1556               formatFlags = FBCONFIGS[visualid].formatFlags;
1557
1558             GLState *state = _create_context(process, fake_ctxt, fake_shareList);
1559             state->context = glo_context_create(formatFlags,
1560                                                 (GloContext*)shareListState?shareListState->context:0);
1561
1562             DEBUGF( " created context %p for %08x\n", state, fake_ctxt);
1563             break;
1564         }
1565
1566
1567     case glXCreateNewContext_func:
1568         {
1569             int client_fbconfig = args[1];
1570
1571             ret.i = 0;
1572             const GLXFBConfig *fbconfig = get_fbconfig(process, client_fbconfig);
1573
1574             if (fbconfig) {
1575                 int fake_shareList = args[3];
1576                 GLState *shareListState = get_glstate_for_fake_ctxt(process, fake_shareList);
1577
1578                 process->next_available_context_number++;
1579                 int fake_ctxt = process->next_available_context_number;
1580                 ret.i = fake_ctxt;
1581
1582                 GLState *state = _create_context(process, fake_ctxt, fake_shareList);
1583                 state->context = glo_context_create(fbconfig->formatFlags,
1584                                                     shareListState?shareListState->context:0); // FIXME GW get from fbconfig
1585             }
1586             break;
1587         }
1588
1589     case glXCopyContext_func:
1590         {
1591           DEBUGF( " glXCopyContext not supported (does anything use it?)\n");
1592             break;
1593         }
1594
1595     case glXDestroyContext_func:
1596         {
1597             int fake_ctxt = (int) args[1];
1598
1599             if (display_function_call)
1600                 DEBUGF( "fake_ctxt=%d\n", fake_ctxt);
1601
1602             int i;
1603             for (i = 0; i < process->nb_states; i ++) {
1604                 if (process->glstates[i]->fake_ctxt == fake_ctxt) {
1605                      /*XXX: DestroyContext should not switch current context, or
1606                      * else guest still try to access it and cause qemu
1607                      * segfalt. But not sure if any corner case, so comment it
1608                      * for now and will remove it completely in future.
1609                      */
1610                     // this was our GLState...
1611                     // process->current_state = &process->default_state;
1612
1613                     int fake_shareList =
1614                         process->glstates[i]->fake_shareList;
1615                     process->glstates[i]->ref--;
1616                     if (process->glstates[i]->ref == 0) {
1617                         DEBUGF(
1618                                 "destroy_gl_state fake_ctxt = %d\n",
1619                                 process->glstates[i]->fake_ctxt);
1620                         destroy_gl_state(process->glstates[i]);
1621                         g_free(process->glstates[i]);
1622                         memmove(&process->glstates[i],
1623                                 &process->glstates[i + 1],
1624                                 (process->nb_states - i - 1) *
1625                                 sizeof(GLState *));
1626                         process->nb_states --;
1627                     }
1628
1629                     if (fake_shareList) {
1630                         for (i = 0; i < process->nb_states; i++) {
1631                             if (process->glstates[i]->fake_ctxt ==
1632                                 fake_shareList) {
1633                                 process->glstates[i]->ref--;
1634                                 if (process->glstates[i]->ref == 0) {
1635                                     DEBUGF(
1636                                             "destroy_gl_state fake_ctxt = %d\n",
1637                                             process->glstates[i]->
1638                                             fake_ctxt);
1639                                     destroy_gl_state(process->
1640                                                      glstates[i]);
1641                                     g_free(process->glstates[i]);
1642                                     memmove(&process->glstates[i],
1643                                             &process->glstates[i + 1],
1644                                             (process->nb_states - i - 1) *
1645                                             sizeof(GLState *));
1646                                     process->nb_states --;
1647                                 }
1648                                 break;
1649                             }
1650                         }
1651                     }
1652
1653                     break;
1654                 }
1655             }
1656             break;
1657         }
1658
1659     case glXQueryVersion_func:
1660         {
1661             int *major = (int *) args[1];
1662             int *minor = (int *) args[2];
1663             //ret.i = glXQueryVersion(dpy, (int *) args[1], (int *) args[2]);
1664             if (major) *major=FAKE_GLX_VERSION_MAJOR;
1665             if (minor) *minor=FAKE_GLX_VERSION_MINOR;
1666             ret.i = True;
1667             break;
1668         }
1669
1670     case glGetString_func:
1671         {
1672             switch (args[0]) {
1673               case GL_VENDOR:
1674                 ret.s = FAKE_GL_VENDOR;
1675               break;
1676               case GL_RENDERER:
1677                 ret.s = FAKE_GL_RENDERER;
1678               break;
1679               case GL_VERSION:
1680                 ret.s = FAKE_GL_VERSION;
1681               break;
1682               case GL_EXTENSIONS:
1683                 ret.s = compute_gl_extensions();
1684               break;
1685               case GL_SHADING_LANGUAGE_VERSION:
1686                 if(FAKE_GL_MAJOR < 2) {
1687                   ret.s = "";
1688                   break;
1689                 }
1690               // Fall through.
1691               default:
1692                 ret.s = (char *) glGetString(args[0]);
1693               break;
1694             }
1695             break;
1696         }
1697
1698     case glXMakeCurrent_func:
1699         {
1700             ClientGLXDrawable client_drawable = to_drawable(args[1]);
1701             int fake_ctxt = (int) args[2];
1702             GLState *glstate = NULL;
1703
1704 //            DEBUGF( "Makecurrent: fake_ctx=%d client_drawable=%08x\n", fake_ctxt, client_drawable);
1705
1706             if (client_drawable == 0 && fake_ctxt == 0) {
1707                 /* Release context */
1708                 if(process->current_state->current_qsurface)
1709                     process->current_state->current_qsurface->ref--;
1710                 process->current_state = &process->default_state;
1711
1712 //                DEBUGF( " --release\n");
1713                 glo_surface_makecurrent(0);
1714             } else { /* Lookup GLState struct for this context */
1715                 glstate = get_glstate_for_fake_ctxt(process, fake_ctxt);
1716                 if (!glstate) {
1717                     DEBUGF( " --invalid fake_ctxt (%d)!\n", fake_ctxt);
1718                 } else {
1719                                         if(!set_current_qsurface(glstate, client_drawable) &&
1720                                            !link_qsurface(process, glstate, client_drawable) ) {
1721                        // If there is no surface, create one.
1722                        QGloSurface *qsurface = calloc(1, sizeof(QGloSurface));
1723                        qsurface->surface = glo_surface_create(4, 4,
1724                                                               glstate->context);
1725                        qsurface->client_drawable = client_drawable;
1726                        qsurface->ref = 1;
1727                                            qsurface->type = SURFACE_WINDOW;
1728                                            qsurface->status = SURFACE_ACTIVE;
1729
1730                        bind_qsurface(glstate, qsurface);
1731 //                       DEBUGF( " --Client drawable not found, create new surface: %16x %16lx\n", (unsigned int)qsurface, (unsigned long int)client_drawable);
1732
1733                     }
1734                     else {
1735 //                       DEBUGF( " --Client drawable found, using surface: %16x %16lx\n", (unsigned int)glstate->current_qsurface, (unsigned long int)client_drawable);
1736                     }
1737 #if 0
1738                     /*Test old surface contents */
1739                     int reset_texture = 0;
1740                     GLState *old_glstate = NULL;
1741                     /* Switch from pixmap */
1742                     if (process->current_state->current_qsurface && SURFACE_PIXMAP == process->current_state->current_qsurface->type )
1743                     {
1744                         glo_surface_updatecontents(process->current_state->current_qsurface->surface);
1745                         reset_texture = 1;
1746                         old_glstate = process->current_state;
1747                     }
1748                     fprintf(stderr, "edwin:MakeCurrent: drawable=0x%x,qsurface=%p.\n", client_drawable, glstate->current_qsurface);
1749
1750 #endif
1751                     /* Switch in pixmap surface */
1752                     if (glstate->current_qsurface && SURFACE_PIXMAP == glstate->current_qsurface->type )
1753                     {
1754                         /* Release it if the surface is used as texture target */
1755                         glo_surface_release_texture(glstate->current_qsurface);
1756                     }
1757
1758                     process->current_state = glstate;
1759
1760                     ret.i = glo_surface_makecurrent(glstate->current_qsurface->surface);
1761 /*                    if (reset_texture)*/
1762 /*                        glo_surface_as_texture(old_glstate->current_qsurface->surface);*/
1763                 }
1764             }
1765             break;
1766         }
1767
1768     case glXSwapBuffers_func:
1769         {
1770             // Does nothing - window data is copied via render_surface()
1771             break;
1772         }
1773     case glXIsDirect_func:
1774         {
1775             // int fake_ctxt = (int) args[1];
1776
1777             // Does this go direct and skip the X server? We'll just say
1778             // yes for now.
1779             ret.c = True;
1780
1781             break;
1782         }
1783
1784     case glXGetConfig_func:
1785         {
1786             int visualid = args[1];
1787             ret.i = glXGetConfigFunc(visualid, args[2], (int *) args[3]);
1788             break;
1789         }
1790
1791     case glXGetConfig_extended_func:
1792         {
1793             int visualid = args[1];
1794             int n = args[2];
1795             int i;
1796             int *attribs = (int *) args[3];
1797             int *values = (int *) args[4];
1798             int *res = (int *) args[5];
1799
1800             for (i = 0; i < n; i++) {
1801                 res[i] = glXGetConfigFunc(visualid, attribs[i], &values[i]);
1802             }
1803             break;
1804         }
1805
1806     case glXUseXFont_func:
1807         {
1808             /* implementation is client-side only :-) */
1809             break;
1810         }
1811
1812     case glXQueryExtension_func:
1813         {
1814             int *errorBase = (int *) args[1];
1815             int *eventBase = (int *) args[2];
1816             if (errorBase) *errorBase = 0; /* FIXME GW */
1817             if (eventBase) *eventBase = 0; /* FIXME GW */
1818             ret.i = True;
1819             break;
1820         }
1821
1822     case glXChooseFBConfig_func:
1823         {
1824             if (process->nfbconfig == MAX_FBCONFIG) {
1825                 *(int *) args[3] = 0;
1826                 ret.i = 0;
1827             } else {
1828                 const GLXFBConfig *fbconfigs =
1829                     glXChooseFBConfigFunc(args[1], (int *) args[2], (int *) args[3]);
1830                 if (fbconfigs) {
1831                     process->fbconfigs[process->nfbconfig] = fbconfigs;
1832                     process->fbconfigs_max[process->nfbconfig] =
1833                         *(int *) args[3];
1834                     process->nfbconfig++;
1835                     ret.i = 1 + process->nfbconfig_total;
1836                     process->nfbconfig_total +=
1837                         process->fbconfigs_max[process->nfbconfig];
1838                 } else {
1839                     ret.i = 0;
1840                 }
1841             }
1842             break;
1843         }
1844     case glXGetFBConfigs_func:
1845         {
1846             if (process->nfbconfig == MAX_FBCONFIG) {
1847                 *(int *) args[2] = 0;
1848                 ret.i = 0;
1849             } else {
1850                 const GLXFBConfig *fbconfigs =
1851                     glXGetFBConfigsFunc(args[1], (int *) args[2]);
1852                 if (fbconfigs) {
1853                     process->fbconfigs[process->nfbconfig] = fbconfigs;
1854                     process->fbconfigs_max[process->nfbconfig] =
1855                         *(int *) args[2];
1856                     process->nfbconfig++;
1857                     ret.i = 1 + process->nfbconfig_total;
1858                     process->nfbconfig_total +=
1859                         process->fbconfigs_max[process->nfbconfig];
1860                 } else {
1861                     ret.i = 0;
1862                 }
1863             }
1864             break;
1865         }
1866     case glXGetFBConfigAttrib_func:
1867         {
1868             int client_fbconfig = args[1];
1869
1870             ret.i = 0;
1871             const GLXFBConfig *fbconfig = get_fbconfig(process, client_fbconfig);
1872
1873             if (fbconfig)
1874                 ret.i =
1875                     glXGetFBConfigAttribFunc(fbconfig, args[2], (int *) args[3]);
1876             break;
1877         }
1878
1879     case glXGetFBConfigAttrib_extended_func:
1880         {
1881             int client_fbconfig = args[1];
1882             int n = args[2];
1883             int i;
1884             int *attribs = (int *) args[3];
1885             int *values = (int *) args[4];
1886             int *res = (int *) args[5];
1887             const GLXFBConfig *fbconfig = get_fbconfig(process, client_fbconfig);
1888
1889             for (i = 0; i < n; i++) {
1890                 if (fbconfig) {
1891                     res[i] =
1892                         glXGetFBConfigAttribFunc(fbconfig, attribs[i], &values[i]);
1893                 } else {
1894                     res[i] = 0;
1895                 }
1896             }
1897             break;
1898         }
1899     case glXQueryContext_func:
1900         {
1901             DEBUGF( "glXQueryContext not implemented\n");
1902             ret.i = 0;
1903 #if 0 //GW
1904             GET_EXT_PTR(int, glXQueryContext,
1905                         (Display *, GLXContext, int, int *));
1906             int fake_ctxt = (int) args[1];
1907
1908             if (display_function_call)
1909                 DEBUGF( "fake_ctx=%i\n", fake_ctxt);
1910             GLXContext ctxt =
1911                 get_association_fakecontext_glxcontext(process, fake_ctxt);
1912             if (ctxt == NULL) {
1913                 DEBUGF( "invalid fake_ctxt (%i) !\n", fake_ctxt);
1914                 ret.i = 0;
1915             } else {
1916                 ret.i =
1917                     ptr_func_glXQueryContext(dpy, ctxt, args[2],
1918                                              (int *) args[3]);
1919             }
1920 #endif
1921             break;
1922         }
1923
1924     case glXQueryDrawable_func:
1925         {
1926             // TODO GW one of:
1927             // GLX_WIDTH, GLX_HEIGHT, GLX_PRESERVED_CONTENTS, GLX_LARGEST_PBUFFER, GLX_FBCONFIG_ID
1928             DEBUGF( "FIXME: glXQueryDrawable not implemented\n");
1929             ret.i = 0;
1930 #if 0 //GW
1931             GET_EXT_PTR(void, glXQueryDrawable,
1932                         (Display *, GLXDrawable, int, int *));
1933             ClientGLXDrawable client_drawable = to_drawable(args[1]);
1934             GLXDrawable drawable =
1935                     get_association_clientdrawable_serverdrawable(
1936                                     glstate, client_drawable);
1937
1938             if (display_function_call)
1939                 DEBUGF( "client_drawable=%p\n",
1940                                 client_drawable);
1941
1942             if (!drawable)
1943                 DEBUGF( "invalid client_drawable (%p) !\n",
1944                                 client_drawable);
1945             else
1946                 ptr_func_glXQueryDrawable(dpy, drawable,
1947                                 args[2], (int *) args[3]);
1948 #endif
1949             break;
1950         }
1951     case glXGetVisualFromFBConfig_func:
1952         {
1953             int client_fbconfig = args[1];
1954
1955             ret.i = 0;
1956             const GLXFBConfig *fbconfig = get_fbconfig(process, client_fbconfig);
1957
1958             if (fbconfig) {
1959                 // we tread visualid as the index into the fbconfigs array
1960                 ret.i = &FBCONFIGS[0] - fbconfig;
1961                 if (display_function_call)
1962                     DEBUGF( "visualid = %d\n", ret.i);
1963             }
1964             break;
1965         }
1966     case glXSwapIntervalSGI_func:
1967         {
1968             /*GET_EXT_PTR(int, glXSwapIntervalSGI, (int));
1969             ret.i = ptr_func_glXSwapIntervalSGI(args[0]);*/
1970             ret.i = 0;
1971             break;
1972         }
1973
1974     case glXGetProcAddress_fake_func:
1975         {
1976 //            if (display_function_call)
1977             //DEBUGF( "glXGetProcAddress %s  ", (char *) args[0]);
1978             ret.i = glo_getprocaddress((const char *) args[0]) != NULL;
1979             //   DEBUGF( " == %08x\n", ret.i);
1980             ret.i = 0;
1981             break;
1982         }
1983
1984     case glXGetProcAddress_global_fake_func:
1985         {
1986             int nbElts = args[0];
1987             char *huge_buffer = (char *) args[1];
1988             char *result = (char *) args[2];
1989             int i;
1990
1991             for (i = 0; i < nbElts; i++) {
1992                 int len = strlen(huge_buffer);
1993                 //DEBUGF( "glXGetProcAddress_global %s  ", (char *)huge_buffer);
1994                 result[i] =
1995                     glo_getprocaddress((const char *) huge_buffer) !=
1996                     NULL;
1997                 huge_buffer += len + 1;
1998             }
1999             break;
2000         }
2001     case glXCreatePixmap_func:
2002         {
2003             int client_fbconfig = args[1];
2004
2005             ret.i = 0;
2006             const GLXFBConfig *fbconfig = get_fbconfig(process, client_fbconfig);
2007
2008             if (fbconfig) {
2009
2010                 /* Create a light-weight context just for creating surface */
2011                 GloContext *context = __glo_context_create(fbconfig->formatFlags);
2012
2013                 /* glXPixmap same as input Pixmap */
2014                 ClientGLXDrawable client_drawable = to_drawable(args[2]);
2015
2016                 QGloSurface *qsurface = calloc(1, sizeof(QGloSurface));
2017
2018                 /* get the width and height */
2019                 int width, height;
2020                 glo_geometry_get_from_glx((int*)args[3], &width, &height);
2021
2022                 DEBUGF( "glXCreatePixmap: %dX%d.\n", width, height);
2023                 qsurface->surface = glo_surface_create(width, height, context);
2024                 qsurface->client_drawable = client_drawable;
2025                                 qsurface->type = SURFACE_PIXMAP;
2026                                 qsurface->status = SURFACE_PENDING;
2027                 /*                qsurface->ref = 1;*/
2028
2029                 /* Keep this surface, will link it with context in MakeCurrent */
2030                 keep_qsurface(process, qsurface);
2031
2032                 /* If this pixmap is linked as texture previously */
2033                 if (link_drawable(process, client_drawable))
2034                         glo_surface_as_texture(qsurface->surface);
2035
2036                 ret.i = client_drawable;
2037
2038             }
2039             break;
2040         }
2041     case glXDestroyPixmap_func:
2042         {
2043             break;
2044         }
2045     case glEGLImageTargetTexture2DOES_fake_func:
2046         {
2047             int target = args[0];
2048             ClientGLXDrawable client_drawable = to_drawable(args[1]);
2049             QGloSurface *qsurface = find_qsurface_from_client_drawable(process, client_drawable);
2050
2051             /* Only support GL_TEXTURE_2D according to spec */
2052             if ( target == GL_TEXTURE_2D )
2053                 add_pixmap_texture_mapping(process->current_state,
2054                         process->current_state->bindTexture2D,
2055                         client_drawable);
2056
2057             if ( !qsurface )
2058             {
2059                 if ( !keep_drawable(process, client_drawable) )
2060                 {
2061                     DEBUGF( "No space to store drawable for ImageTargetTexture. Need call CreatePixmapSurface     to free them.\n");
2062                     break;
2063                 }
2064             }
2065             else
2066                 glo_surface_as_texture(qsurface->surface);
2067
2068             break;
2069         }
2070
2071 /* Begin of texture stuff */
2072     case glBindTexture_func:
2073     case glBindTextureEXT_func:
2074         {
2075             int target = args[0];
2076             unsigned int client_texture = args[1];
2077             unsigned int server_texture;
2078
2079             if (client_texture == 0) {
2080                 glBindTexture(target, 0);
2081             } else {
2082                 alloc_value(process->current_state->textureAllocator,
2083                             client_texture);
2084                 server_texture =
2085                     process->current_state->tabTextures[client_texture];
2086                 if (server_texture == 0) {
2087                     glGenTextures(1, &server_texture);
2088                     process->current_state->tabTextures[client_texture] =
2089                         server_texture;
2090                 }
2091                 glBindTexture(target, server_texture);
2092             }
2093
2094             if ( target == GL_TEXTURE_2D ) {
2095                 QGloSurface *qsurface = NULL;
2096                 ClientGLXDrawable drawable =
2097                     find_pixmap_texture(process->current_state, client_texture);
2098
2099                 if ( drawable )
2100                 {
2101                     qsurface = find_qsurface_from_client_drawable(process, drawable);
2102
2103                     if ( qsurface )
2104                     {
2105                         glo_surface_as_texture(qsurface->surface);
2106                         fprintf(stderr, "edwin:bindtexture: drawable=0x%x,qsurface=%p.\n", drawable, qsurface);
2107                     }
2108                 }
2109
2110                 process->current_state->bindTexture2D = client_texture;
2111             }
2112                         break;
2113         }
2114
2115     case glGenTextures_fake_func:
2116         {
2117             //GET_EXT_PTR(void, glGenTextures, (GLsizei n, GLuint *textures));
2118             int i;
2119             int n = args[0];
2120             unsigned int *clientTabTextures = g_malloc(n * sizeof(int));
2121             unsigned int *serverTabTextures = g_malloc(n * sizeof(int));
2122
2123             alloc_range(process->current_state->textureAllocator, n,
2124                         clientTabTextures);
2125
2126             //ptr_func_glGenTextures(n, serverTabTextures);
2127                 glGenTextures(n, serverTabTextures);
2128             for (i = 0; i < n; i++) {
2129                 process->current_state->tabTextures[clientTabTextures[i]] =
2130                     serverTabTextures[i];
2131             }
2132
2133             g_free(clientTabTextures);
2134             g_free(serverTabTextures);
2135             break;
2136         }
2137
2138
2139     case glDeleteTextures_func:
2140         {
2141             //GET_EXT_PTR(void, glDeleteTextures,
2142             //            (GLsizei n, const GLuint *textures));
2143             int i;
2144             int n = args[0];
2145             unsigned int *clientTabTextures = (unsigned int *) args[1];
2146
2147             delete_range(process->current_state->textureAllocator, n,
2148                          clientTabTextures);
2149
2150             unsigned int *serverTabTextures = g_malloc(n * sizeof(int));
2151
2152             for (i = 0; i < n; i++) {
2153                 serverTabTextures[i] =
2154                     get_server_texture(process, clientTabTextures[i]);
2155             }
2156             //ptr_func_glDeleteTextures(n, serverTabTextures);
2157                 glDeleteTextures(n, serverTabTextures);
2158             for (i = 0; i < n; i++) {
2159                 process->current_state->tabTextures[clientTabTextures[i]] = 0;
2160             }
2161             g_free(serverTabTextures);
2162
2163             for ( i = 0; i < n; i++ )
2164             {
2165                 del_pixmap_texture_mapping(process->current_state, clientTabTextures[i]);
2166             }
2167             break;
2168         }
2169
2170     case glPrioritizeTextures_func:
2171         {
2172             GET_EXT_PTR(void, glPrioritizeTextures,
2173                         (GLsizei n, const GLuint *textures,
2174                          const GLclampf *priorities));
2175
2176             int i;
2177             int n = args[0];
2178             unsigned int *textures = (unsigned int *) args[1];
2179
2180             for (i = 0; i < n; i++) {
2181                 textures[i] = get_server_texture(process, textures[i]);
2182             }
2183             ptr_func_glPrioritizeTextures(n, textures,
2184                                           (const GLclampf *) args[2]);
2185             break;
2186         }
2187
2188     case glAreTexturesResident_func:
2189         {
2190             GET_EXT_PTR(void, glAreTexturesResident,
2191                         (GLsizei n, const GLuint *textures,
2192                          GLboolean *residences));
2193             int i;
2194             int n = args[0];
2195             unsigned int *textures = (unsigned int *) args[1];
2196
2197             for (i = 0; i < n; i++) {
2198                 textures[i] = get_server_texture(process, textures[i]);
2199             }
2200             ptr_func_glAreTexturesResident(n, textures,
2201                                            (GLboolean *) args[2]);
2202             break;
2203         }
2204
2205     case glIsTexture_func:
2206     case glIsTextureEXT_func:
2207         {
2208             //GET_EXT_PTR(GLboolean, glIsTexture, (GLuint texture));
2209             unsigned int client_texture = args[0];
2210             unsigned int server_texture =
2211                 get_server_texture(process, client_texture);
2212             if (server_texture)
2213             //    ret.c = ptr_func_glIsTexture(server_texture);
2214                 ret.c = glIsTexture(server_texture);
2215             else
2216                 ret.c = 0;
2217             break;
2218         }
2219
2220     case glFramebufferTexture1DEXT_func:
2221         {
2222             GET_EXT_PTR(void, glFramebufferTexture1DEXT,
2223                         (int, int, int, int, int));
2224             unsigned int client_texture = args[3];
2225             unsigned int server_texture =
2226                 get_server_texture(process, client_texture);
2227             if (server_texture)
2228                 ptr_func_glFramebufferTexture1DEXT(args[0], args[1], args[2],
2229                                                    server_texture, args[4]);
2230             break;
2231         }
2232
2233     case glFramebufferTexture2D_func:
2234         //DEBUGF( "wooooot!\n");
2235     case glFramebufferTexture2DEXT_func:
2236         {
2237             GET_EXT_PTR(void, glFramebufferTexture2DEXT,
2238                         (int, int, int, int, int));
2239             unsigned int client_texture = args[3];
2240             unsigned int server_texture =
2241                 get_server_texture(process, client_texture);
2242             if (server_texture)
2243                 ptr_func_glFramebufferTexture2DEXT(args[0], args[1], args[2],
2244                                                    server_texture, args[4]);
2245             break;
2246         }
2247
2248     case glFramebufferTexture3DEXT_func:
2249         {
2250             GET_EXT_PTR(void, glFramebufferTexture3DEXT,
2251                         (int, int, int, int, int, int));
2252             unsigned int client_texture = args[3];
2253             unsigned int server_texture =
2254                 get_server_texture(process, client_texture);
2255             if (server_texture)
2256                 ptr_func_glFramebufferTexture3DEXT(args[0], args[1], args[2],
2257                                                    server_texture, args[4],
2258                                                    args[5]);
2259             break;
2260         }
2261 /* End of texture stuff */
2262
2263 /* Begin of list stuff */
2264     case glIsList_func:
2265         {
2266             unsigned int client_list = args[0];
2267             unsigned int server_list = get_server_list(process, client_list);
2268
2269             if (server_list)
2270                 ret.c = glIsList(server_list);
2271             else
2272                 ret.c = 0;
2273             break;
2274         }
2275
2276     case glDeleteLists_func:
2277         {
2278             int i;
2279             unsigned int first_client = args[0];
2280             int n = args[1];
2281
2282             unsigned int first_server =
2283                 get_server_list(process, first_client);
2284             for (i = 0; i < n; i++) {
2285                 if (get_server_list(process, first_client + i) !=
2286                     first_server + i)
2287                     break;
2288             }
2289             if (i == n) {
2290                 glDeleteLists(first_server, n);
2291             } else {
2292                 for (i = 0; i < n; i++) {
2293                     glDeleteLists(get_server_list(process, first_client + i),
2294                                   1);
2295                 }
2296             }
2297
2298             for (i = 0; i < n; i++) {
2299                 process->current_state->tabLists[first_client + i] = 0;
2300             }
2301             delete_consecutive_values(process->current_state->listAllocator,
2302                                       first_client, n);
2303             break;
2304         }
2305
2306     case glGenLists_fake_func:
2307         {
2308             int i;
2309             int n = args[0];
2310             unsigned int server_first = glGenLists(n);
2311
2312             if (server_first) {
2313                 unsigned int client_first =
2314                     alloc_range(process->current_state->listAllocator, n,
2315                                 NULL);
2316                 for (i = 0; i < n; i++) {
2317                     process->current_state->tabLists[client_first + i] =
2318                         server_first + i;
2319                 }
2320             }
2321             break;
2322         }
2323
2324     case glNewList_func:
2325         {
2326             unsigned int client_list = args[0];
2327             int mode = args[1];
2328
2329             alloc_value(process->current_state->listAllocator, client_list);
2330             unsigned int server_list = get_server_list(process, client_list);
2331
2332             if (server_list == 0) {
2333                 server_list = glGenLists(1);
2334                 process->current_state->tabLists[client_list] = server_list;
2335             }
2336             glNewList(server_list, mode);
2337             break;
2338         }
2339
2340     case glCallList_func:
2341         {
2342             unsigned int client_list = args[0];
2343             unsigned int server_list = get_server_list(process, client_list);
2344
2345             glCallList(server_list);
2346             break;
2347         }
2348
2349     case glCallLists_func:
2350         {
2351             int i;
2352             int n = args[0];
2353             int type = args[1];
2354             const GLvoid *lists = (const GLvoid *) args[2];
2355             int *new_lists = g_malloc(sizeof(int) * n);
2356
2357             for (i = 0; i < n; i++) {
2358                 new_lists[i] =
2359                     get_server_list(process, translate_id(i, type, lists));
2360             }
2361             glCallLists(n, GL_UNSIGNED_INT, new_lists);
2362             g_free(new_lists);
2363             break;
2364         }
2365
2366
2367 /* End of list stuff */
2368
2369 /* Begin of buffer stuff */
2370     case glBindBufferARB_func:
2371         {
2372             GET_EXT_PTR(void, glBindBufferARB, (int, int));
2373             int target = args[0];
2374             unsigned int client_buffer = args[1];
2375             unsigned int server_buffer;
2376
2377             if (client_buffer == 0) {
2378                 ptr_func_glBindBufferARB(target, 0);
2379             } else {
2380                 server_buffer = get_server_buffer(process, client_buffer);
2381                 ptr_func_glBindBufferARB(target, server_buffer);
2382             }
2383             break;
2384         }
2385
2386     case glGenBuffersARB_fake_func:
2387         {
2388             GET_EXT_PTR(void, glGenBuffersARB, (int, unsigned int *));
2389             int i;
2390             int n = args[0];
2391             unsigned int *clientTabBuffers = g_malloc(n * sizeof(int));
2392             unsigned int *serverTabBuffers = g_malloc(n * sizeof(int));
2393
2394             alloc_range(process->current_state->bufferAllocator, n,
2395                         clientTabBuffers);
2396
2397             ptr_func_glGenBuffersARB(n, serverTabBuffers);
2398             for (i = 0; i < n; i++) {
2399                 process->current_state->tabBuffers[clientTabBuffers[i]] =
2400                     serverTabBuffers[i];
2401             }
2402
2403             g_free(clientTabBuffers);
2404             g_free(serverTabBuffers);
2405             break;
2406         }
2407
2408
2409     case glDeleteBuffersARB_func:
2410         {
2411             GET_EXT_PTR(void, glDeleteBuffersARB, (int, int *));
2412             int i;
2413             int n = args[0];
2414             unsigned int *clientTabBuffers = (unsigned int *) args[1];
2415
2416             delete_range(process->current_state->bufferAllocator, n,
2417                          clientTabBuffers);
2418
2419             int *serverTabBuffers = g_malloc(n * sizeof(int));
2420
2421             for (i = 0; i < n; i++) {
2422                 serverTabBuffers[i] =
2423                     get_server_buffer(process, clientTabBuffers[i]);
2424             }
2425             ptr_func_glDeleteBuffersARB(n, serverTabBuffers);
2426             for (i = 0; i < n; i++) {
2427                 process->current_state->tabBuffers[clientTabBuffers[i]] = 0;
2428             }
2429             g_free(serverTabBuffers);
2430             break;
2431         }
2432
2433     case glIsBufferARB_func:
2434         {
2435             GET_EXT_PTR(int, glIsBufferARB, (int));
2436             unsigned int client_buffer = args[0];
2437             unsigned int server_buffer =
2438                 get_server_buffer(process, client_buffer);
2439             if (server_buffer)
2440                 ret.i = ptr_func_glIsBufferARB(server_buffer);
2441             else
2442                 ret.i = 0;
2443             break;
2444         }
2445
2446 /* End of buffer stuff */
2447
2448     case glShaderSourceARB_fake_func:
2449         {
2450             GET_EXT_PTR(void, glShaderSourceARB, (int, int, char **, void *));
2451             int size = args[1];
2452             int i;
2453             int acc_length = 0;
2454             GLcharARB **tab_prog = g_malloc(size * sizeof(GLcharARB *));
2455             int *tab_length = (int *) args[3];
2456
2457             for (i = 0; i < size; i++) {
2458                 tab_prog[i] = ((GLcharARB *) args[2]) + acc_length;
2459                 acc_length += tab_length[i];
2460             }
2461             ptr_func_glShaderSourceARB(args[0], args[1], tab_prog,
2462                                        tab_length);
2463             g_free(tab_prog);
2464             break;
2465         }
2466
2467     case glShaderSource_fake_func:
2468                 {
2469                         GET_EXT_PTR(void, glShaderSource, (int, int, char **, void *));
2470                         int size = args[1];
2471                         int i;
2472                         int acc_length = 0;
2473                         GLcharARB **tab_prog = g_malloc(size * sizeof(GLcharARB *));
2474                         int *tab_length = (int *) args[3];
2475
2476                         char **tab_prog_new;
2477                         GLint *tab_length_new;
2478
2479                         tab_prog_new = malloc(args[1]* sizeof(char*));
2480                         tab_length_new = malloc(args[1]* sizeof(GLint));
2481
2482                         memset(tab_prog_new, 0, args[1] * sizeof(char*));
2483                         memset(tab_length_new, 0, args[1] * sizeof(GLint));
2484
2485
2486                         for (i = 0; i < size; i++) {
2487                                 tab_prog[i] = ((GLcharARB *) args[2]) + acc_length;
2488                                 acc_length += tab_length[i];
2489                         }
2490
2491                         shadersrc_gles_to_gl(args[1], tab_prog, tab_prog_new, tab_length, tab_length_new);
2492
2493                         if (!tab_prog_new || !tab_length_new)
2494                                 break;
2495
2496                         ptr_func_glShaderSource(args[0], args[1], tab_prog_new, tab_length_new);
2497
2498                         for (i = 0; i < args[1]; i++) {
2499                                 free(tab_prog_new[i]);
2500                         }
2501
2502                         free(tab_prog_new);
2503                         free(tab_length_new);
2504
2505                         free(tab_prog);
2506
2507                         break;
2508                 }
2509
2510     case glVertexPointer_fake_func:
2511         {
2512             int offset = args[0];
2513             int size = args[1];
2514             int type = args[2];
2515             int stride = args[3];
2516             int bytes_size = args[4];
2517
2518             process->current_state->vertexPointerSize =
2519                 MAX(process->current_state->vertexPointerSize,
2520                     offset + bytes_size);
2521             process->current_state->vertexPointer =
2522                 g_realloc(process->current_state->vertexPointer,
2523                         process->current_state->vertexPointerSize);
2524             memcpy(process->current_state->vertexPointer + offset,
2525                    (void *) args[5], bytes_size);
2526             /* DEBUGF( "glVertexPointer_fake_func size=%d, type=%d,
2527              * stride=%d, byte_size=%d\n", size, type, stride, bytes_size); */
2528             glVertexPointer(size, type, stride,
2529                             process->current_state->vertexPointer);
2530             break;
2531         }
2532
2533     case glNormalPointer_fake_func:
2534         {
2535             int offset = args[0];
2536             int type = args[1];
2537             int stride = args[2];
2538             int bytes_size = args[3];
2539
2540             process->current_state->normalPointerSize =
2541                 MAX(process->current_state->normalPointerSize,
2542                     offset + bytes_size);
2543             process->current_state->normalPointer =
2544                 g_realloc(process->current_state->normalPointer,
2545                         process->current_state->normalPointerSize);
2546             memcpy(process->current_state->normalPointer + offset,
2547                    (void *) args[4], bytes_size);
2548             // DEBUGF( "glNormalPointer_fake_func type=%d, stride=%d,
2549             // byte_size=%d\n", type, stride, bytes_size);
2550             glNormalPointer(type, stride,
2551                             process->current_state->normalPointer);
2552             break;
2553         }
2554
2555     case glIndexPointer_fake_func:
2556         {
2557             int offset = args[0];
2558             int type = args[1];
2559             int stride = args[2];
2560             int bytes_size = args[3];
2561
2562             process->current_state->indexPointerSize =
2563                 MAX(process->current_state->indexPointerSize,
2564                     offset + bytes_size);
2565             process->current_state->indexPointer =
2566                 g_realloc(process->current_state->indexPointer,
2567                         process->current_state->indexPointerSize);
2568             memcpy(process->current_state->indexPointer + offset,
2569                    (void *) args[4], bytes_size);
2570             // DEBUGF( "glIndexPointer_fake_func type=%d, stride=%d,
2571             // byte_size=%d\n", type, stride, bytes_size);
2572             glIndexPointer(type, stride,
2573                            process->current_state->indexPointer);
2574             break;
2575         }
2576
2577     case glEdgeFlagPointer_fake_func:
2578         {
2579             int offset = args[0];
2580             int stride = args[1];
2581             int bytes_size = args[2];
2582
2583             process->current_state->edgeFlagPointerSize =
2584                 MAX(process->current_state->edgeFlagPointerSize,
2585                     offset + bytes_size);
2586             process->current_state->edgeFlagPointer =
2587                 g_realloc(process->current_state->edgeFlagPointer,
2588                         process->current_state->edgeFlagPointerSize);
2589             memcpy(process->current_state->edgeFlagPointer + offset,
2590                    (void *) args[3], bytes_size);
2591             // DEBUGF( "glEdgeFlagPointer_fake_func stride = %d,
2592             // bytes_size=%d\n", stride, bytes_size);
2593             glEdgeFlagPointer(stride,
2594                               process->current_state->edgeFlagPointer);
2595             break;
2596         }
2597
2598     case glVertexAttribPointerARB_fake_func:
2599         {
2600             GET_EXT_PTR(void, glVertexAttribPointerARB,
2601                         (int, int, int, int, int, void *));
2602             int offset = args[0];
2603             int index = args[1];
2604             int size = args[2];
2605             int type = args[3];
2606             int normalized = args[4];
2607             int stride = args[5];
2608             int bytes_size = args[6];
2609
2610             process->current_state->vertexAttribPointerSize[index] =
2611                 MAX(process->current_state->vertexAttribPointerSize[index],
2612                     offset + bytes_size);
2613             process->current_state->vertexAttribPointer[index] =
2614                 g_realloc(process->current_state->vertexAttribPointer[index],
2615                         process->current_state->
2616                         vertexAttribPointerSize[index]);
2617             memcpy(process->current_state->vertexAttribPointer[index] +
2618                    offset, (void *) args[7], bytes_size);
2619             ptr_func_glVertexAttribPointerARB(index, size, type, normalized,
2620                                               stride,
2621                                               process->current_state->
2622                                               vertexAttribPointer[index]);
2623             break;
2624         }
2625
2626     case glVertexAttribPointerNV_fake_func:
2627         {
2628             GET_EXT_PTR(void, glVertexAttribPointerNV,
2629                         (int, int, int, int, void *));
2630             int offset = args[0];
2631             int index = args[1];
2632             int size = args[2];
2633             int type = args[3];
2634             int stride = args[4];
2635             int bytes_size = args[5];
2636
2637             process->current_state->vertexAttribPointerNVSize[index] =
2638                 MAX(process->current_state->vertexAttribPointerNVSize[index],
2639                     offset + bytes_size);
2640             process->current_state->vertexAttribPointerNV[index] =
2641                 g_realloc(process->current_state->vertexAttribPointerNV[index],
2642                         process->current_state->
2643                         vertexAttribPointerNVSize[index]);
2644             memcpy(process->current_state->vertexAttribPointerNV[index] +
2645                    offset, (void *) args[6], bytes_size);
2646             ptr_func_glVertexAttribPointerNV(index, size, type, stride,
2647                                              process->current_state->
2648                                              vertexAttribPointerNV[index]);
2649             break;
2650         }
2651
2652     case glColorPointer_fake_func:
2653         {
2654             int offset = args[0];
2655             int size = args[1];
2656             int type = args[2];
2657             int stride = args[3];
2658             int bytes_size = args[4];
2659
2660             process->current_state->colorPointerSize =
2661                 MAX(process->current_state->colorPointerSize,
2662                     offset + bytes_size);
2663             process->current_state->colorPointer =
2664                 g_realloc(process->current_state->colorPointer,
2665                         process->current_state->colorPointerSize);
2666             memcpy(process->current_state->colorPointer + offset,
2667                    (void *) args[5], bytes_size);
2668             // DEBUGF( "glColorPointer_fake_func bytes_size = %d\n",
2669             // bytes_size);
2670             glColorPointer(size, type, stride,
2671                            process->current_state->colorPointer);
2672
2673             break;
2674         }
2675
2676     case glSecondaryColorPointer_fake_func:
2677         {
2678             GET_EXT_PTR(void, glSecondaryColorPointer,
2679                         (int, int, int, void *));
2680             int offset = args[0];
2681             int size = args[1];
2682             int type = args[2];
2683             int stride = args[3];
2684             int bytes_size = args[4];
2685
2686             process->current_state->secondaryColorPointerSize =
2687                 MAX(process->current_state->secondaryColorPointerSize,
2688                     offset + bytes_size);
2689             process->current_state->secondaryColorPointer =
2690                 g_realloc(process->current_state->secondaryColorPointer,
2691                         process->current_state->secondaryColorPointerSize);
2692             memcpy(process->current_state->secondaryColorPointer + offset,
2693                    (void *) args[5], bytes_size);
2694             // DEBUGF( "glSecondaryColorPointer_fake_func bytes_size
2695             // = %d\n", bytes_size);
2696             ptr_func_glSecondaryColorPointer(size, type, stride,
2697                                              process->current_state->
2698                                              secondaryColorPointer);
2699
2700             break;
2701         }
2702
2703     case glPushClientAttrib_func:
2704         {
2705             int mask = args[0];
2706
2707             if (process->current_state->clientStateSp <
2708                 MAX_CLIENT_STATE_STACK_SIZE) {
2709                 process->current_state->clientStateStack[process->
2710                                                          current_state->
2711                                                          clientStateSp].mask =
2712                     mask;
2713                 if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {
2714                     process->current_state->clientStateStack[process->
2715                                                              current_state->
2716                                                              clientStateSp].
2717                         activeTextureIndex =
2718                         process->current_state->activeTextureIndex;
2719                 }
2720                 process->current_state->clientStateSp++;
2721             }
2722             glPushClientAttrib(mask);
2723             break;
2724         }
2725
2726     case glPopClientAttrib_func:
2727         {
2728             if (process->current_state->clientStateSp > 0) {
2729                 process->current_state->clientStateSp--;
2730                 if (process->current_state->
2731                     clientStateStack[process->current_state->clientStateSp].
2732                     mask & GL_CLIENT_VERTEX_ARRAY_BIT) {
2733                     process->current_state->activeTextureIndex =
2734                         process->current_state->clientStateStack[process->
2735                                                                  current_state->
2736                                                                  clientStateSp].
2737                         activeTextureIndex;
2738                 }
2739             }
2740             glPopClientAttrib();
2741             break;
2742         }
2743
2744     case glClientActiveTexture_func:
2745     case glClientActiveTextureARB_func:
2746         {
2747             int activeTexture = args[0];
2748
2749             process->current_state->activeTextureIndex =
2750                 activeTexture - GL_TEXTURE0_ARB;
2751             do_glClientActiveTextureARB(activeTexture);
2752             break;
2753         }
2754
2755     case glTexCoordPointer_fake_func:
2756         {
2757             int offset = args[0];
2758             int index = args[1];
2759             int size = args[2];
2760             int type = args[3];
2761             int stride = args[4];
2762             int bytes_size = args[5];
2763
2764             process->current_state->texCoordPointerSize[index] =
2765                 MAX(process->current_state->texCoordPointerSize[index],
2766                     offset + bytes_size);
2767             process->current_state->texCoordPointer[index] =
2768                 g_realloc(process->current_state->texCoordPointer[index],
2769                         process->current_state->texCoordPointerSize[index]);
2770             memcpy(process->current_state->texCoordPointer[index] + offset,
2771                    (void *) args[6], bytes_size);
2772             /* DEBUGF( "glTexCoordPointer_fake_func size=%d, type=%d,
2773              * stride=%d, byte_size=%d\n", size, type, stride, bytes_size); */
2774             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + index);
2775             glTexCoordPointer(size, type, stride,
2776                               process->current_state->texCoordPointer[index]);
2777             do_glClientActiveTextureARB(GL_TEXTURE0_ARB +
2778                                         process->current_state->
2779                                         activeTextureIndex);
2780             break;
2781         }
2782
2783     case glWeightPointerARB_fake_func:
2784         {
2785             GET_EXT_PTR(void, glWeightPointerARB, (int, int, int, void *));
2786             int offset = args[0];
2787             int size = args[1];
2788             int type = args[2];
2789             int stride = args[3];
2790             int bytes_size = args[4];
2791
2792             process->current_state->weightPointerSize =
2793                 MAX(process->current_state->weightPointerSize,
2794                     offset + bytes_size);
2795             process->current_state->weightPointer =
2796                 g_realloc(process->current_state->weightPointer,
2797                         process->current_state->weightPointerSize);
2798             memcpy(process->current_state->weightPointer + offset,
2799                    (void *) args[5], bytes_size);
2800             /* DEBUGF( "glWeightPointerARB_fake_func size=%d,
2801              * type=%d, stride=%d, byte_size=%d\n", size, type, stride,
2802              * bytes_size); */
2803             ptr_func_glWeightPointerARB(size, type, stride,
2804                                         process->current_state->
2805                                         weightPointer);
2806             break;
2807         }
2808
2809     case glMatrixIndexPointerARB_fake_func:
2810         {
2811             GET_EXT_PTR(void, glMatrixIndexPointerARB,
2812                         (int, int, int, void *));
2813             int offset = args[0];
2814             int size = args[1];
2815             int type = args[2];
2816             int stride = args[3];
2817             int bytes_size = args[4];
2818
2819             process->current_state->matrixIndexPointerSize =
2820                 MAX(process->current_state->matrixIndexPointerSize,
2821                     offset + bytes_size);
2822             process->current_state->matrixIndexPointer =
2823                 g_realloc(process->current_state->matrixIndexPointer,
2824                         process->current_state->matrixIndexPointerSize);
2825             memcpy(process->current_state->matrixIndexPointer + offset,
2826                    (void *) args[5], bytes_size);
2827             /* DEBUGF( "glMatrixIndexPointerARB_fake_func size=%d,
2828              * type=%d, stride=%d, byte_size=%d\n", size, type, stride,
2829              * bytes_size); */
2830             ptr_func_glMatrixIndexPointerARB(size, type, stride,
2831                                              process->current_state->
2832                                              matrixIndexPointer);
2833             break;
2834         }
2835
2836     case glFogCoordPointer_fake_func:
2837         {
2838             GET_EXT_PTR(void, glFogCoordPointer, (int, int, void *));
2839             int offset = args[0];
2840             int type = args[1];
2841             int stride = args[2];
2842             int bytes_size = args[3];
2843
2844             process->current_state->fogCoordPointerSize =
2845                 MAX(process->current_state->fogCoordPointerSize,
2846                     offset + bytes_size);
2847             process->current_state->fogCoordPointer =
2848                 g_realloc(process->current_state->fogCoordPointer,
2849                         process->current_state->fogCoordPointerSize);
2850             memcpy(process->current_state->fogCoordPointer + offset,
2851                    (void *) args[4], bytes_size);
2852             // DEBUGF( "glFogCoordPointer_fake_func type=%d,
2853             // stride=%d, byte_size=%d\n", type, stride, bytes_size);
2854             ptr_func_glFogCoordPointer(type, stride,
2855                                        process->current_state->
2856                                        fogCoordPointer);
2857             break;
2858         }
2859
2860     case glVariantPointerEXT_fake_func:
2861         {
2862             GET_EXT_PTR(void, glVariantPointerEXT, (int, int, int, void *));
2863             int offset = args[0];
2864             int id = args[1];
2865             int type = args[2];
2866             int stride = args[3];
2867             int bytes_size = args[4];
2868
2869             process->current_state->variantPointerEXTSize[id] =
2870                 MAX(process->current_state->variantPointerEXTSize[id],
2871                     offset + bytes_size);
2872             process->current_state->variantPointerEXT[id] =
2873                 g_realloc(process->current_state->variantPointerEXT[id],
2874                         process->current_state->variantPointerEXTSize[id]);
2875             memcpy(process->current_state->variantPointerEXT[id] + offset,
2876                    (void *) args[5], bytes_size);
2877             // DEBUGF( "glVariantPointerEXT_fake_func[%d] type=%d,
2878             // stride=%d, byte_size=%d\n", id, type, stride, bytes_size);
2879             ptr_func_glVariantPointerEXT(id, type, stride,
2880                                          process->current_state->
2881                                          variantPointerEXT[id]);
2882             break;
2883         }
2884
2885     case glInterleavedArrays_fake_func:
2886         {
2887             GET_EXT_PTR(void, glInterleavedArrays, (int, int, void *));
2888             int offset = args[0];
2889             int format = args[1];
2890             int stride = args[2];
2891             int bytes_size = args[3];
2892
2893             process->current_state->interleavedArraysSize =
2894                 MAX(process->current_state->interleavedArraysSize,
2895                     offset + bytes_size);
2896             process->current_state->interleavedArrays =
2897                 g_realloc(process->current_state->interleavedArrays,
2898                         process->current_state->interleavedArraysSize);
2899             memcpy(process->current_state->interleavedArrays + offset,
2900                    (void *) args[4], bytes_size);
2901             // DEBUGF( "glInterleavedArrays_fake_func format=%d,
2902             // stride=%d, byte_size=%d\n", format, stride, bytes_size);
2903             ptr_func_glInterleavedArrays(format, stride,
2904                                          process->current_state->
2905                                          interleavedArrays);
2906             break;
2907         }
2908
2909     case glElementPointerATI_fake_func:
2910         {
2911             GET_EXT_PTR(void, glElementPointerATI, (int, void *));
2912             int type = args[0];
2913             int bytes_size = args[1];
2914
2915             process->current_state->elementPointerATISize = bytes_size;
2916             process->current_state->elementPointerATI =
2917                 g_realloc(process->current_state->elementPointerATI,
2918                         process->current_state->elementPointerATISize);
2919             memcpy(process->current_state->elementPointerATI,
2920                    (void *) args[2], bytes_size);
2921             // DEBUGF( "glElementPointerATI_fake_func type=%d,
2922             // byte_size=%d\n", type, bytes_size);
2923             ptr_func_glElementPointerATI(type,
2924                                          process->current_state->
2925                                          elementPointerATI);
2926             break;
2927         }
2928
2929     case glTexCoordPointer01_fake_func:
2930         {
2931             int size = args[0];
2932             int type = args[1];
2933             int stride = args[2];
2934             int bytes_size = args[3];
2935
2936             process->current_state->texCoordPointerSize[0] = bytes_size;
2937             process->current_state->texCoordPointer[0] =
2938                 g_realloc(process->current_state->texCoordPointer[0],
2939                         bytes_size);
2940             memcpy(process->current_state->texCoordPointer[0],
2941                    (void *) args[4], bytes_size);
2942             /* DEBUGF( "glTexCoordPointer01_fake_func size=%d,
2943              * type=%d, stride=%d, byte_size=%d\n", size, type, stride,
2944              * bytes_size); */
2945             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
2946             glTexCoordPointer(size, type, stride,
2947                               process->current_state->texCoordPointer[0]);
2948             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
2949             glTexCoordPointer(size, type, stride,
2950                               process->current_state->texCoordPointer[0]);
2951             do_glClientActiveTextureARB(GL_TEXTURE0_ARB +
2952                                         process->current_state->
2953                                         activeTextureIndex);
2954             break;
2955         }
2956
2957     case glTexCoordPointer012_fake_func:
2958         {
2959             int size = args[0];
2960             int type = args[1];
2961             int stride = args[2];
2962             int bytes_size = args[3];
2963
2964             process->current_state->texCoordPointerSize[0] = bytes_size;
2965             process->current_state->texCoordPointer[0] =
2966                 g_realloc(process->current_state->texCoordPointer[0],
2967                         bytes_size);
2968             memcpy(process->current_state->texCoordPointer[0],
2969                    (void *) args[4], bytes_size);
2970             /* DEBUGF( "glTexCoordPointer012_fake_func size=%d,
2971              * type=%d, stride=%d, byte_size=%d\n", size, type, stride,
2972              * bytes_size); */
2973             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
2974             glTexCoordPointer(size, type, stride,
2975                               process->current_state->texCoordPointer[0]);
2976             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
2977             glTexCoordPointer(size, type, stride,
2978                               process->current_state->texCoordPointer[0]);
2979             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 2);
2980             glTexCoordPointer(size, type, stride,
2981                               process->current_state->texCoordPointer[0]);
2982             do_glClientActiveTextureARB(GL_TEXTURE0_ARB +
2983                                         process->current_state->
2984                                         activeTextureIndex);
2985             break;
2986         }
2987
2988     case glVertexAndNormalPointer_fake_func:
2989         {
2990             int vertexPointerSize = args[0];
2991             int vertexPointerType = args[1];
2992             int vertexPointerStride = args[2];
2993             int normalPointerType = args[3];
2994             int normalPointerStride = args[4];
2995             int bytes_size = args[5];
2996             void *ptr = (void *) args[6];
2997
2998             process->current_state->vertexPointerSize = bytes_size;
2999             process->current_state->vertexPointer =
3000                 g_realloc(process->current_state->vertexPointer, bytes_size);
3001             memcpy(process->current_state->vertexPointer, ptr, bytes_size);
3002             glVertexPointer(vertexPointerSize, vertexPointerType,
3003                             vertexPointerStride,
3004                             process->current_state->vertexPointer);
3005             glNormalPointer(normalPointerType, normalPointerStride,
3006                             process->current_state->vertexPointer);
3007             break;
3008         }
3009
3010     case glVertexNormalPointerInterlaced_fake_func:
3011         {
3012             int i = 0;
3013             int offset = args[i++];
3014             int vertexPointerSize = args[i++];
3015             int vertexPointerType = args[i++];
3016             int stride = args[i++];
3017             int normalPointerOffset = args[i++];
3018             int normalPointerType = args[i++];
3019             int bytes_size = args[i++];
3020             void *ptr = (void *) args[i++];
3021
3022             process->current_state->vertexPointerSize =
3023                 MAX(process->current_state->vertexPointerSize,
3024                     offset + bytes_size);
3025             process->current_state->vertexPointer =
3026                 g_realloc(process->current_state->vertexPointer,
3027                         process->current_state->vertexPointerSize);
3028             memcpy(process->current_state->vertexPointer + offset, ptr,
3029                    bytes_size);
3030             glVertexPointer(vertexPointerSize, vertexPointerType, stride,
3031                             process->current_state->vertexPointer);
3032             glNormalPointer(normalPointerType, stride,
3033                             process->current_state->vertexPointer +
3034                             normalPointerOffset);
3035             break;
3036         }
3037
3038     case glTuxRacerDrawElements_fake_func:
3039         {
3040             int mode = args[0];
3041             int count = args[1];
3042             int isColorEnabled = args[2];
3043             void *ptr = (void *) args[3];
3044             int stride =
3045                 6 * sizeof(float) +
3046                 ((isColorEnabled) ? 4 * sizeof(unsigned char) : 0);
3047             glVertexPointer(3, GL_FLOAT, stride, ptr);
3048             glNormalPointer(GL_FLOAT, stride, ptr + 3 * sizeof(float));
3049             if (isColorEnabled)
3050                 glColorPointer(4, GL_UNSIGNED_BYTE, stride,
3051                                ptr + 6 * sizeof(float));
3052             glDrawArrays(mode, 0, count);
3053
3054 #ifdef __APPLE__  //only for mac
3055                         {
3056                                 int prev_fbo;
3057                                 glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo);
3058                                 if ( prev_fbo != 0 )
3059                                         glFlush();
3060                         }
3061 #endif
3062
3063             break;
3064         }
3065
3066     case glVertexNormalColorPointerInterlaced_fake_func:
3067         {
3068             int i = 0;
3069             int offset = args[i++];
3070             int vertexPointerSize = args[i++];
3071             int vertexPointerType = args[i++];
3072             int stride = args[i++];
3073             int normalPointerOffset = args[i++];
3074             int normalPointerType = args[i++];
3075             int colorPointerOffset = args[i++];
3076             int colorPointerSize = args[i++];
3077             int colorPointerType = args[i++];
3078             int bytes_size = args[i++];
3079             void *ptr = (void *) args[i++];
3080
3081             process->current_state->vertexPointerSize =
3082                 MAX(process->current_state->vertexPointerSize,
3083                     offset + bytes_size);
3084             process->current_state->vertexPointer =
3085                 g_realloc(process->current_state->vertexPointer,
3086                         process->current_state->vertexPointerSize);
3087             memcpy(process->current_state->vertexPointer + offset, ptr,
3088                    bytes_size);
3089             glVertexPointer(vertexPointerSize, vertexPointerType, stride,
3090                             process->current_state->vertexPointer);
3091             glNormalPointer(normalPointerType, stride,
3092                             process->current_state->vertexPointer +
3093                             normalPointerOffset);
3094             glColorPointer(colorPointerSize, colorPointerType, stride,
3095                            process->current_state->vertexPointer +
3096                            colorPointerOffset);
3097             break;
3098         }
3099
3100     case glVertexColorTexCoord0PointerInterlaced_fake_func:
3101         {
3102             int i = 0;
3103             int offset = args[i++];
3104             int vertexPointerSize = args[i++];
3105             int vertexPointerType = args[i++];
3106             int stride = args[i++];
3107             int colorPointerOffset = args[i++];
3108             int colorPointerSize = args[i++];
3109             int colorPointerType = args[i++];
3110             int texCoord0PointerOffset = args[i++];
3111             int texCoord0PointerSize = args[i++];
3112             int texCoord0PointerType = args[i++];
3113             int bytes_size = args[i++];
3114             void *ptr = (void *) args[i++];
3115
3116             process->current_state->vertexPointerSize =
3117                 MAX(process->current_state->vertexPointerSize,
3118                     offset + bytes_size);
3119             process->current_state->vertexPointer =
3120                 g_realloc(process->current_state->vertexPointer,
3121                         process->current_state->vertexPointerSize);
3122             memcpy(process->current_state->vertexPointer + offset, ptr,
3123                    bytes_size);
3124             glVertexPointer(vertexPointerSize, vertexPointerType, stride,
3125                             process->current_state->vertexPointer);
3126             glColorPointer(colorPointerSize, colorPointerType, stride,
3127                            process->current_state->vertexPointer +
3128                            colorPointerOffset);
3129             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3130             glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType,
3131                               stride,
3132                               process->current_state->vertexPointer +
3133                               texCoord0PointerOffset);
3134             do_glClientActiveTextureARB(GL_TEXTURE0_ARB +
3135                                         process->current_state->
3136                                         activeTextureIndex);
3137             break;
3138         }
3139
3140     case glVertexNormalTexCoord0PointerInterlaced_fake_func:
3141         {
3142             int i = 0;
3143             int offset = args[i++];
3144             int vertexPointerSize = args[i++];
3145             int vertexPointerType = args[i++];
3146             int stride = args[i++];
3147             int normalPointerOffset = args[i++];
3148             int normalPointerType = args[i++];
3149             int texCoord0PointerOffset = args[i++];
3150             int texCoord0PointerSize = args[i++];
3151             int texCoord0PointerType = args[i++];
3152             int bytes_size = args[i++];
3153             void *ptr = (void *) args[i++];
3154
3155             process->current_state->vertexPointerSize =
3156                 MAX(process->current_state->vertexPointerSize,
3157                     offset + bytes_size);
3158             process->current_state->vertexPointer =
3159                 g_realloc(process->current_state->vertexPointer,
3160                         process->current_state->vertexPointerSize);
3161             memcpy(process->current_state->vertexPointer + offset, ptr,
3162                    bytes_size);
3163             glVertexPointer(vertexPointerSize, vertexPointerType, stride,
3164                             process->current_state->vertexPointer);
3165             glNormalPointer(normalPointerType, stride,
3166                             process->current_state->vertexPointer +
3167                             normalPointerOffset);
3168             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3169             glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType,
3170                               stride,
3171                               process->current_state->vertexPointer +
3172                               texCoord0PointerOffset);
3173             do_glClientActiveTextureARB(GL_TEXTURE0_ARB +
3174                                         process->current_state->
3175                                         activeTextureIndex);
3176             break;
3177         }
3178
3179     case glVertexNormalTexCoord01PointerInterlaced_fake_func:
3180         {
3181             int i = 0;
3182             int offset = args[i++];
3183             int vertexPointerSize = args[i++];
3184             int vertexPointerType = args[i++];
3185             int stride = args[i++];
3186             int normalPointerOffset = args[i++];
3187             int normalPointerType = args[i++];
3188             int texCoord0PointerOffset = args[i++];
3189             int texCoord0PointerSize = args[i++];
3190             int texCoord0PointerType = args[i++];
3191             int texCoord1PointerOffset = args[i++];
3192             int texCoord1PointerSize = args[i++];
3193             int texCoord1PointerType = args[i++];
3194             int bytes_size = args[i++];
3195             void *ptr = (void *) args[i++];
3196
3197             process->current_state->vertexPointerSize =
3198                 MAX(process->current_state->vertexPointerSize,
3199                     offset + bytes_size);
3200             process->current_state->vertexPointer =
3201                 g_realloc(process->current_state->vertexPointer,
3202                         process->current_state->vertexPointerSize);
3203             memcpy(process->current_state->vertexPointer + offset, ptr,
3204                    bytes_size);
3205             glVertexPointer(vertexPointerSize, vertexPointerType, stride,
3206                             process->current_state->vertexPointer);
3207             glNormalPointer(normalPointerType, stride,
3208                             process->current_state->vertexPointer +
3209                             normalPointerOffset);
3210             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3211             glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType,
3212                               stride,
3213                               process->current_state->vertexPointer +
3214                               texCoord0PointerOffset);
3215             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
3216             glTexCoordPointer(texCoord1PointerSize, texCoord1PointerType,
3217                               stride,
3218                               process->current_state->vertexPointer +
3219                               texCoord1PointerOffset);
3220             do_glClientActiveTextureARB(GL_TEXTURE0_ARB +
3221                                         process->current_state->
3222                                         activeTextureIndex);
3223             break;
3224         }
3225
3226     case glVertexNormalTexCoord012PointerInterlaced_fake_func:
3227         {
3228             int i = 0;
3229             int offset = args[i++];
3230             int vertexPointerSize = args[i++];
3231             int vertexPointerType = args[i++];
3232             int stride = args[i++];
3233             int normalPointerOffset = args[i++];
3234             int normalPointerType = args[i++];
3235             int texCoord0PointerOffset = args[i++];
3236             int texCoord0PointerSize = args[i++];
3237             int texCoord0PointerType = args[i++];
3238             int texCoord1PointerOffset = args[i++];
3239             int texCoord1PointerSize = args[i++];
3240             int texCoord1PointerType = args[i++];
3241             int texCoord2PointerOffset = args[i++];
3242             int texCoord2PointerSize = args[i++];
3243             int texCoord2PointerType = args[i++];
3244             int bytes_size = args[i++];
3245             void *ptr = (void *) args[i++];
3246
3247             process->current_state->vertexPointerSize =
3248                 MAX(process->current_state->vertexPointerSize,
3249                     offset + bytes_size);
3250             process->current_state->vertexPointer =
3251                 g_realloc(process->current_state->vertexPointer,
3252                         process->current_state->vertexPointerSize);
3253             memcpy(process->current_state->vertexPointer + offset, ptr,
3254                    bytes_size);
3255             glVertexPointer(vertexPointerSize, vertexPointerType, stride,
3256                             process->current_state->vertexPointer);
3257             glNormalPointer(normalPointerType, stride,
3258                             process->current_state->vertexPointer +
3259                             normalPointerOffset);
3260             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3261             glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType,
3262                               stride,
3263                               process->current_state->vertexPointer +
3264                               texCoord0PointerOffset);
3265             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
3266             glTexCoordPointer(texCoord1PointerSize, texCoord1PointerType,
3267                               stride,
3268                               process->current_state->vertexPointer +
3269                               texCoord1PointerOffset);
3270             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 2);
3271             glTexCoordPointer(texCoord2PointerSize, texCoord2PointerType,
3272                               stride,
3273                               process->current_state->vertexPointer +
3274                               texCoord2PointerOffset);
3275             do_glClientActiveTextureARB(GL_TEXTURE0_ARB +
3276                                         process->current_state->
3277                                         activeTextureIndex);
3278             break;
3279         }
3280
3281     case glVertexNormalColorTexCoord0PointerInterlaced_fake_func:
3282         {
3283             int i = 0;
3284             int offset = args[i++];
3285             int vertexPointerSize = args[i++];
3286             int vertexPointerType = args[i++];
3287             int stride = args[i++];
3288             int normalPointerOffset = args[i++];
3289             int normalPointerType = args[i++];
3290             int colorPointerOffset = args[i++];
3291             int colorPointerSize = args[i++];
3292             int colorPointerType = args[i++];
3293             int texCoord0PointerOffset = args[i++];
3294             int texCoord0PointerSize = args[i++];
3295             int texCoord0PointerType = args[i++];
3296             int bytes_size = args[i++];
3297             void *ptr = (void *) args[i++];
3298
3299             process->current_state->vertexPointerSize =
3300                 MAX(process->current_state->vertexPointerSize,
3301                     offset + bytes_size);
3302             process->current_state->vertexPointer =
3303                 g_realloc(process->current_state->vertexPointer,
3304                         process->current_state->vertexPointerSize);
3305             memcpy(process->current_state->vertexPointer + offset, ptr,
3306                    bytes_size);
3307             glVertexPointer(vertexPointerSize, vertexPointerType, stride,
3308                             process->current_state->vertexPointer);
3309             glNormalPointer(normalPointerType, stride,
3310                             process->current_state->vertexPointer +
3311                             normalPointerOffset);
3312             glColorPointer(colorPointerSize, colorPointerType, stride,
3313                            process->current_state->vertexPointer +
3314                            colorPointerOffset);
3315             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3316             glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType,
3317                               stride,
3318                               process->current_state->vertexPointer +
3319                               texCoord0PointerOffset);
3320             do_glClientActiveTextureARB(GL_TEXTURE0_ARB +
3321                                         process->current_state->
3322                                         activeTextureIndex);
3323             break;
3324         }
3325
3326     case glVertexNormalColorTexCoord01PointerInterlaced_fake_func:
3327         {
3328             int i = 0;
3329             int offset = args[i++];
3330             int vertexPointerSize = args[i++];
3331             int vertexPointerType = args[i++];
3332             int stride = args[i++];
3333             int normalPointerOffset = args[i++];
3334             int normalPointerType = args[i++];
3335             int colorPointerOffset = args[i++];
3336             int colorPointerSize = args[i++];
3337             int colorPointerType = args[i++];
3338             int texCoord0PointerOffset = args[i++];
3339             int texCoord0PointerSize = args[i++];
3340             int texCoord0PointerType = args[i++];
3341             int texCoord1PointerOffset = args[i++];
3342             int texCoord1PointerSize = args[i++];
3343             int texCoord1PointerType = args[i++];
3344             int bytes_size = args[i++];
3345             void *ptr = (void *) args[i++];
3346
3347             process->current_state->vertexPointerSize =
3348                 MAX(process->current_state->vertexPointerSize,
3349                     offset + bytes_size);
3350             process->current_state->vertexPointer =
3351                 g_realloc(process->current_state->vertexPointer,
3352                         process->current_state->vertexPointerSize);
3353             memcpy(process->current_state->vertexPointer + offset, ptr,
3354                    bytes_size);
3355             glVertexPointer(vertexPointerSize, vertexPointerType, stride,
3356                             process->current_state->vertexPointer);
3357             glNormalPointer(normalPointerType, stride,
3358                             process->current_state->vertexPointer +
3359                             normalPointerOffset);
3360             glColorPointer(colorPointerSize, colorPointerType, stride,
3361                            process->current_state->vertexPointer +
3362                            colorPointerOffset);
3363             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3364             glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType,
3365                               stride,
3366                               process->current_state->vertexPointer +
3367                               texCoord0PointerOffset);
3368             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
3369             glTexCoordPointer(texCoord1PointerSize, texCoord1PointerType,
3370                               stride,
3371                               process->current_state->vertexPointer +
3372                               texCoord1PointerOffset);
3373             do_glClientActiveTextureARB(GL_TEXTURE0_ARB +
3374                                         process->current_state->
3375                                         activeTextureIndex);
3376             break;
3377         }
3378
3379     case glVertexNormalColorTexCoord012PointerInterlaced_fake_func:
3380         {
3381             int i = 0;
3382             int offset = args[i++];
3383             int vertexPointerSize = args[i++];
3384             int vertexPointerType = args[i++];
3385             int stride = args[i++];
3386             int normalPointerOffset = args[i++];
3387             int normalPointerType = args[i++];
3388             int colorPointerOffset = args[i++];
3389             int colorPointerSize = args[i++];
3390             int colorPointerType = args[i++];
3391             int texCoord0PointerOffset = args[i++];
3392             int texCoord0PointerSize = args[i++];
3393             int texCoord0PointerType = args[i++];
3394             int texCoord1PointerOffset = args[i++];
3395             int texCoord1PointerSize = args[i++];
3396             int texCoord1PointerType = args[i++];
3397             int texCoord2PointerOffset = args[i++];
3398             int texCoord2PointerSize = args[i++];
3399             int texCoord2PointerType = args[i++];
3400             int bytes_size = args[i++];
3401             void *ptr = (void *) args[i++];
3402
3403             process->current_state->vertexPointerSize =
3404                 MAX(process->current_state->vertexPointerSize,
3405                     offset + bytes_size);
3406             process->current_state->vertexPointer =
3407                 g_realloc(process->current_state->vertexPointer,
3408                         process->current_state->vertexPointerSize);
3409             memcpy(process->current_state->vertexPointer + offset, ptr,
3410                    bytes_size);
3411             glVertexPointer(vertexPointerSize, vertexPointerType, stride,
3412                             process->current_state->vertexPointer);
3413             glNormalPointer(normalPointerType, stride,
3414                             process->current_state->vertexPointer +
3415                             normalPointerOffset);
3416             glColorPointer(colorPointerSize, colorPointerType, stride,
3417                            process->current_state->vertexPointer +
3418                            colorPointerOffset);
3419             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0);
3420             glTexCoordPointer(texCoord0PointerSize, texCoord0PointerType,
3421                               stride,
3422                               process->current_state->vertexPointer +
3423                               texCoord0PointerOffset);
3424             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 1);
3425             glTexCoordPointer(texCoord1PointerSize, texCoord1PointerType,
3426                               stride,
3427                               process->current_state->vertexPointer +
3428                               texCoord1PointerOffset);
3429             do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 2);
3430             glTexCoordPointer(texCoord2PointerSize, texCoord2PointerType,
3431                               stride,
3432                               process->current_state->vertexPointer +
3433                               texCoord2PointerOffset);
3434             do_glClientActiveTextureARB(GL_TEXTURE0_ARB +
3435                                         process->current_state->
3436                                         activeTextureIndex);
3437             break;
3438         }
3439
3440     case _glVertexPointer_buffer_func:
3441         {
3442             glVertexPointer(args[0], args[1], args[2], (void *) args[3]);
3443             break;
3444         }
3445
3446     case _glNormalPointer_buffer_func:
3447         {
3448             glNormalPointer(args[0], args[1], (void *) args[2]);
3449             break;
3450         }
3451
3452     case _glColorPointer_buffer_func:
3453         {
3454             glColorPointer(args[0], args[1], args[2], (void *) args[3]);
3455             break;
3456         }
3457
3458     case _glSecondaryColorPointer_buffer_func:
3459         {
3460             GET_EXT_PTR(void, glSecondaryColorPointer,
3461                         (int, int, int, void *));
3462             ptr_func_glSecondaryColorPointer(args[0], args[1], args[2],
3463                                              (void *) args[3]);
3464             break;
3465         }
3466
3467     case _glIndexPointer_buffer_func:
3468         {
3469             glIndexPointer(args[0], args[1], (void *) args[2]);
3470             break;
3471         }
3472
3473     case _glTexCoordPointer_buffer_func:
3474         {
3475             glTexCoordPointer(args[0], args[1], args[2], (void *) args[3]);
3476             break;
3477         }
3478
3479     case _glEdgeFlagPointer_buffer_func:
3480         {
3481             glEdgeFlagPointer(args[0], (void *) args[1]);
3482             break;
3483         }
3484
3485     case _glVertexAttribPointerARB_buffer_func:
3486         {
3487             GET_EXT_PTR(void, glVertexAttribPointerARB,
3488                         (int, int, int, int, int, void *));
3489             ptr_func_glVertexAttribPointerARB(args[0], args[1], args[2],
3490                                               args[3], args[4],
3491                                               (void *) args[5]);
3492             break;
3493         }
3494
3495     case _glWeightPointerARB_buffer_func:
3496         {
3497             GET_EXT_PTR(void, glWeightPointerARB, (int, int, int, void *));
3498
3499             ptr_func_glWeightPointerARB(args[0], args[1], args[2],
3500                                         (void *) args[3]);
3501             break;
3502         }
3503
3504     case _glMatrixIndexPointerARB_buffer_func:
3505         {
3506             GET_EXT_PTR(void, glMatrixIndexPointerARB,
3507                         (int, int, int, void *));
3508             ptr_func_glMatrixIndexPointerARB(args[0], args[1], args[2],
3509                                              (void *) args[3]);
3510             break;
3511         }
3512
3513     case _glFogCoordPointer_buffer_func:
3514         {
3515             GET_EXT_PTR(void, glFogCoordPointer, (int, int, void *));
3516
3517             ptr_func_glFogCoordPointer(args[0], args[1], (void *) args[2]);
3518             break;
3519         }
3520
3521     case _glVariantPointerEXT_buffer_func:
3522         {
3523             GET_EXT_PTR(void, glVariantPointerEXT, (int, int, int, void *));
3524
3525             ptr_func_glVariantPointerEXT(args[0], args[1], args[2],
3526                                          (void *) args[3]);
3527             break;
3528         }
3529
3530     case _glDrawElements_buffer_func:
3531         {
3532             glDrawElements(args[0], args[1], args[2], (void *) args[3]);
3533
3534 #ifdef __APPLE__  //only for mac
3535                         {
3536                                 int prev_fbo;
3537                                 glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo);
3538                                 if ( prev_fbo != 0 )
3539                                         glFlush();
3540                         }
3541 #endif
3542
3543             break;
3544         }
3545 #ifndef _WIN32
3546     case _glDrawRangeElements_buffer_func:
3547         {
3548             glDrawRangeElements(args[0], args[1], args[2], args[3], args[4],
3549                                 (void *) args[5]);
3550             break;
3551         }
3552 #endif
3553     case _glMultiDrawElements_buffer_func:
3554         {
3555             GET_EXT_PTR(void, glMultiDrawElements,
3556                         (int, int *, int, void **, int));
3557             ptr_func_glMultiDrawElements(args[0], (int *) args[1], args[2],
3558                                        (void **) args[3], args[4]);
3559 #ifdef __APPLE__  //only for mac
3560                         {
3561                                 int prev_fbo;
3562                                 glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo);
3563                                 if ( prev_fbo != 0 )
3564                                         glFlush();
3565                         }
3566 #endif
3567
3568                         break;
3569                 }
3570 #ifdef __APPLE__  // only for mac
3571         case glDrawArrays_func:
3572                 {
3573                         int prev_fbo;
3574                         glDrawArrays(ARG_TO_UNSIGNED_INT(args[0]), ARG_TO_INT(args[1]), ARG_TO_INT(args[2]));
3575                         glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo);
3576                         if ( prev_fbo != 0 )
3577                                 glFlush();
3578                         break;
3579                 }
3580         case glDrawElements_func:
3581                 {
3582                         int prev_fbo;
3583                         glDrawElements(ARG_TO_UNSIGNED_INT(args[0]), ARG_TO_INT(args[1]), ARG_TO_UNSIGNED_INT(args[2]), (const void*)(args[3]));
3584                         glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo);
3585                         if ( prev_fbo != 0 )
3586                                 glFlush();
3587                         break;
3588                 }
3589 #endif
3590
3591     case _glGetError_fake_func:
3592         {
3593             break;
3594         }
3595
3596     case glGetIntegerv_func:
3597         {
3598             glGetIntegerv(args[0], (int *) args[1]);
3599             break;
3600         }
3601
3602     case _glReadPixels_pbo_func:
3603         {
3604             glReadPixels(ARG_TO_INT(args[0]), ARG_TO_INT(args[1]),
3605                          ARG_TO_INT(args[2]), ARG_TO_INT(args[3]),
3606                          ARG_TO_UNSIGNED_INT(args[4]),
3607                          ARG_TO_UNSIGNED_INT(args[5]), (void *) (args[6]));
3608             break;
3609         }
3610
3611     case _glDrawPixels_pbo_func:
3612         {
3613             glDrawPixels(ARG_TO_INT(args[0]), ARG_TO_INT(args[1]),
3614                          ARG_TO_UNSIGNED_INT(args[2]),
3615                          ARG_TO_UNSIGNED_INT(args[3]),
3616                          (const void *) (args[4]));
3617             break;
3618         }
3619
3620     case _glMapBufferARB_fake_func:
3621         {
3622             GET_EXT_PTR(GLvoid *, glMapBufferARB, (GLenum, GLenum));
3623             GET_EXT_PTR(GLboolean, glUnmapBufferARB, (GLenum));
3624             int target = args[0];
3625             int size = args[1];
3626             void *dst_ptr = (void *) args[2];
3627             void *src_ptr = ptr_func_glMapBufferARB(target, GL_READ_ONLY);
3628
3629             if (src_ptr) {
3630                 memcpy(dst_ptr, src_ptr, size);
3631                 ret.i = ptr_func_glUnmapBufferARB(target);
3632             } else {
3633                 ret.i = 0;
3634             }
3635             break;
3636         }
3637
3638     case fake_gluBuild2DMipmaps_func:
3639         {
3640             GET_GLU_PTR(GLint, gluBuild2DMipmaps,
3641                         (GLenum arg_0, GLint arg_1, GLsizei arg_2,
3642                          GLsizei arg_3, GLenum arg_4, GLenum arg_5,
3643                          const GLvoid *arg_6));
3644             if (ptr_func_gluBuild2DMipmaps == NULL)
3645                 ptr_func_gluBuild2DMipmaps = mesa_gluBuild2DMipmaps;
3646             ptr_func_gluBuild2DMipmaps(ARG_TO_UNSIGNED_INT(args[0]),
3647                                        ARG_TO_INT(args[1]),
3648                                        ARG_TO_INT(args[2]),
3649                                        ARG_TO_INT(args[3]),
3650                                        ARG_TO_UNSIGNED_INT(args[4]),
3651                                        ARG_TO_UNSIGNED_INT(args[5]),
3652                                        (const void *) (args[6]));
3653             break;
3654         }
3655
3656     case _glSelectBuffer_fake_func:
3657         {
3658             process->current_state->selectBufferSize = args[0] * 4;
3659             process->current_state->selectBufferPtr =
3660                 g_realloc(process->current_state->selectBufferPtr,
3661                         process->current_state->selectBufferSize);
3662             glSelectBuffer(args[0], process->current_state->selectBufferPtr);
3663             break;
3664         }
3665
3666     case _glGetSelectBuffer_fake_func:
3667         {
3668             void *ptr = (void *) args[0];
3669
3670             memcpy(ptr, process->current_state->selectBufferPtr,
3671                    process->current_state->selectBufferSize);
3672             break;
3673         }
3674
3675     case _glFeedbackBuffer_fake_func:
3676         {
3677             process->current_state->feedbackBufferSize = args[0] * 4;
3678             process->current_state->feedbackBufferPtr =
3679                 g_realloc(process->current_state->feedbackBufferPtr,
3680                         process->current_state->feedbackBufferSize);
3681             glFeedbackBuffer((GLsizei)args[0], (GLenum) args[1],
3682                              process->current_state->feedbackBufferPtr);
3683             break;
3684         }
3685
3686     case _glGetFeedbackBuffer_fake_func:
3687         {
3688             void *ptr = (void *) args[0];
3689
3690             memcpy(ptr, process->current_state->feedbackBufferPtr,
3691                    process->current_state->feedbackBufferSize);
3692             break;
3693         }
3694
3695         /*
3696          * case glEnableClientState_func: { if (display_function_call)
3697          * DEBUGF( "cap : %s\n", nameArrays[args[0] -
3698          * GL_VERTEX_ARRAY]); glEnableClientState(args[0]); break; }
3699          *
3700          * case glDisableClientState_func: { if (display_function_call)
3701          * DEBUGF( "cap : %s\n", nameArrays[args[0] -
3702          * GL_VERTEX_ARRAY]); glDisableClientState(args[0]); break; }
3703          *
3704          * case glClientActiveTexture_func: case
3705          * glClientActiveTextureARB_func: { if (display_function_call)
3706          * DEBUGF( "client activeTexture %d\n", args[0] -
3707          * GL_TEXTURE0_ARB); glClientActiveTextureARB(args[0]); break; }
3708          *
3709          * case glActiveTextureARB_func: { if (display_function_call)
3710          * DEBUGF( "server activeTexture %d\n", args[0] -
3711          * GL_TEXTURE0_ARB); glActiveTextureARB(args[0]); break; }
3712          *
3713          * case glLockArraysEXT_func: break;
3714          *
3715          * case glUnlockArraysEXT_func: break;
3716          *
3717          * case glArrayElement_func: { glArrayElement(args[0]); break; }
3718          *
3719          * case glDrawArrays_func: { glDrawArrays(args[0],args[1],args[2]);
3720          * break; }
3721          *
3722          * case glDrawElements_func: {
3723          * glDrawElements(args[0],args[1],args[2],(void*)args[3]); break; }
3724          *
3725          * case glDrawRangeElements_func: {
3726          * glDrawRangeElements(args[0],args[1],args[2],args[3],args[4],(void*)args[5]);
3727          * break; } */
3728
3729     case glGetError_func:
3730         {
3731             ret.i = glGetError();
3732             break;
3733         }
3734
3735     case glNewObjectBufferATI_func:
3736         {
3737             GET_EXT_PTR(int, glNewObjectBufferATI, (int, void *, int));
3738
3739             ret.i = ptr_func_glNewObjectBufferATI(args[0],
3740                             (void *) args[1], args[2]);
3741             break;
3742         }
3743
3744     case glClear_func:
3745         glClear((GLbitfield)args[0]);
3746         break;
3747 #if 0
3748         /* HACK workaround for an unexplainable issue */
3749         if (args[0] & GL_COLOR_BUFFER_BIT)
3750             glClear(GL_COLOR_BUFFER_BIT);
3751         if (args[0] & GL_STENCIL_BUFFER_BIT)
3752             glClear(GL_STENCIL_BUFFER_BIT);
3753         if (args[0] & GL_DEPTH_BUFFER_BIT)
3754             glClear(GL_DEPTH_BUFFER_BIT);
3755         if (args[0] & GL_ACCUM_BUFFER_BIT)
3756             glClear(GL_ACCUM_BUFFER_BIT);
3757         break;
3758 #endif
3759
3760 #ifdef _WIN32
3761         /* workaround for bug T_SDK-128. If GL_UNPACK_ROW_LENGTH==0, GL driver
3762          * should calculate it for glTexSubImage2D according to width parameter and
3763          * GL_UNPACK_ALIGNMENT. But on windows, some vender's driver like nvidia,
3764          * don't follow it. So we need do it for the driver, and probably remove
3765          * this hack in future if driver get fixed.
3766          */
3767         case glTexSubImage2D_func:
3768                 {
3769                         int origin_row_length, alignment, width;
3770
3771                         if (args[6] == GL_ALPHA) {
3772                                 width = args[4];
3773                                 glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);
3774                                 glGetIntegerv(GL_UNPACK_ROW_LENGTH, &origin_row_length);
3775
3776                                 if (width%alignment != 0) {
3777                                         width = (width/alignment + 1) * alignment;
3778                                 }
3779
3780                                 glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
3781                         }
3782
3783                         glTexSubImage2D(ARG_TO_UNSIGNED_INT(args[0]), ARG_TO_INT(args[1]),
3784                                                 ARG_TO_INT(args[2]), ARG_TO_INT(args[3]),
3785                                                 ARG_TO_INT(args[4]), ARG_TO_INT(args[5]),
3786                                                 ARG_TO_UNSIGNED_INT(args[6]),
3787                                                 ARG_TO_UNSIGNED_INT(args[7]), (const void*)(args[8]));
3788
3789                         if (args[6] == GL_ALPHA)
3790                                 glPixelStorei(GL_UNPACK_ROW_LENGTH, origin_row_length);
3791
3792                         break;
3793                 }
3794 #endif
3795
3796 #ifdef __APPLE__
3797         case glTexSubImage2D_func:
3798                 {
3799
3800                         glTexSubImage2D(ARG_TO_UNSIGNED_INT(args[0]), ARG_TO_INT(args[1]),
3801                                         ARG_TO_INT(args[2]), ARG_TO_INT(args[3]),
3802                                         ARG_TO_INT(args[4]), ARG_TO_INT(args[5]),
3803                                         ARG_TO_UNSIGNED_INT(args[6]), ARG_TO_UNSIGNED_INT(args[7]),
3804                                         (const void*)(args[8]));
3805
3806                         if ( ARG_TO_UNSIGNED_INT(args[0]) == GL_TEXTURE_2D &&
3807                                         ARG_TO_INT(args[1]) == 0 &&
3808                                         ARG_TO_UNSIGNED_INT(args[6]) == GL_RGBA &&
3809                                         ARG_TO_UNSIGNED_INT(args[7]) == GL_UNSIGNED_BYTE )
3810                                 mac_dump_texture();
3811                         else
3812                                 fprintf(stderr, "!!! Probable screen crash, no work around as glTexSubImage2d parameters do not match!\n");
3813
3814                         break;
3815                 }
3816 #endif
3817
3818     default:
3819         execute_func(func_number, (void**)args, &ret);
3820         break;
3821     }
3822
3823     switch (ret_type) {
3824     case TYPE_NONE:
3825     case TYPE_CHAR:
3826     case TYPE_UNSIGNED_CHAR:
3827     case TYPE_INT:
3828     case TYPE_UNSIGNED_INT:
3829         break;
3830
3831     case TYPE_CONST_CHAR:
3832         {
3833             strncpy(ret_string, (ret.s) ? ret.s : "", 32768);
3834             break;
3835         }
3836
3837     default:
3838         DEBUGF( "unexpected ret type : %d\n", ret_type);
3839         exit(-1);
3840         break;
3841     }
3842
3843     if (display_function_call)
3844         DEBUGF( "[%d]< %s\n", process->p.process_id,
3845                 tab_opengl_calls_name[func_number]);
3846
3847     return ret.i;
3848 }