src/modules/tracepath/coregl_tracepath_gl.c

   1 #include "coregl_tracepath.h"
   2
   3 #include <stdlib.h>
   4
   5 struct _Glbuf_Data
   6 {
   7         int obj_idx;
   8         int width;
   9         int height;
  10         int bpp;
  11         char format[80];
  12
  13         struct _Glbuf_Data *next;
  14 };
  15
  16 static void
  17 __addhash_glbuf_object(Glbuf_Data **glbuf, Glbuf_Data *target)
  18 {
  19         Glbuf_Data *data = glbuf[target->obj_idx % MTD_GLBUF_HASH_ARRAY];
  20         if (data == NULL)
  21         {
  22                 glbuf[target->obj_idx % MTD_GLBUF_HASH_ARRAY] = target;
  23         }
  24         else
  25         {
  26                 while (data->next != NULL)
  27                 {
  28                         AST(data->obj_idx != target->obj_idx);
  29                         data = data->next;
  30                 }
  31                 AST(data->obj_idx != target->obj_idx);
  32                 data->next = target;
  33         }
  34         goto finish;
  35
  36 finish:
  37         return;
  38 }
  39
  40 static void
  41 __removehash_glbuf_object(Glbuf_Data **glbuf, Glbuf_Data **target)
  42 {
  43         Glbuf_Data *data = glbuf[(*target)->obj_idx % MTD_GLBUF_HASH_ARRAY];
  44         Glbuf_Data *prev = NULL;
  45         while (data != NULL)
  46         {
  47                 if (data->obj_idx == (*target)->obj_idx)
  48                 {
  49                         if (prev != NULL)
  50                                 prev->next = data->next;
  51                         else
  52                                 glbuf[(*target)->obj_idx % MTD_GLBUF_HASH_ARRAY] = data->next;
  53
  54                         free(*target);
  55                         *target = NULL;
  56                         break;
  57                 }
  58                 prev = data;
  59                 data = data->next;
  60         }
  61         goto finish;
  62
  63 finish:
  64         return;
  65 }
  66
  67 static Glbuf_Data *
  68 __findhash_glbuf_object(Glbuf_Data **glbuf, int obj_idx)
  69 {
  70         Glbuf_Data *data = glbuf[obj_idx % MTD_GLBUF_HASH_ARRAY];
  71         while (data != NULL)
  72         {
  73                 if (data->obj_idx == obj_idx)
  74                         break;
  75                 data = data->next;
  76         }
  77         goto finish;
  78
  79 finish:
  80         return data;
  81 }
  82
  83 void
  84 tracepath_glbuf_clear(Glbuf_Data **glbuf)
  85 {
  86         int i;
  87
  88         for (i = 0; i < MTD_GLBUF_HASH_ARRAY; i++)
  89         {
  90                 Glbuf_Data *data = glbuf[i];
  91
  92                 while (data)
  93                 {
  94                         Glbuf_Data *delitm = data;
  95                         data = data->next;
  96                         free(delitm);
  97                         delitm = NULL;
  98                 }
  99         }
 100 }
 101
 102 static void
 103 _add_glbuf_object(Glbuf_Data **glbuf, int obj_idx, const char *obj_type, int width, int height, int bpp, const char *format)
 104 {
 105         Glbuf_Data *data = __findhash_glbuf_object(glbuf, obj_idx);
 106         if (data == NULL)
 107         {
 108                 data = (Glbuf_Data *)calloc(1, sizeof(Glbuf_Data));
 109                 /* Prevent CID : 387660 */
 110                 if (data == NULL) goto finish;
 111                 data->obj_idx = obj_idx;
 112                 __addhash_glbuf_object(glbuf, data);
 113         }
 114         else
 115         {
 116                 // Update
 117                 {
 118                         char ment[MAX_TRACE_NAME_LENGTH];
 119                         snprintf(ment,sizeof(ment), "%s(%4dx%4d %s)", obj_type, data->width, data->height, data->format);
 120                         _COREGL_TRACE_MEM_REMOVE(ment, data->width * data->height * data->bpp);
 121                 }
 122         }
 123
 124         data->width = width;
 125         data->height = height;
 126         data->bpp = bpp;
 127         snprintf(data->format,sizeof(data->format), "%s", format);
 128
 129         {
 130                 char ment[MAX_TRACE_NAME_LENGTH];
 131                 snprintf(ment,sizeof(ment), "%s(%4dx%4d %s)", obj_type, data->width, data->height, data->format);
 132                 _COREGL_TRACE_MEM_ADD(ment, data->width * data->height * data->bpp);
 133         }
 134         goto finish;
 135
 136 finish:
 137         return;
 138 }
 139
 140 static void
 141 _remove_glbuf_object(Glbuf_Data **glbuf, int obj_idx, const char *obj_type)
 142 {
 143         Glbuf_Data *data = __findhash_glbuf_object(glbuf, obj_idx);
 144         if (data == NULL)
 145         {
 146                 COREGL_WRN("\E[40;31;1mError deleting %s object %d. (is not created)\E[0m\n", obj_type, obj_idx);
 147                 return;
 148         }
 149
 150         {
 151                 char ment[MAX_TRACE_NAME_LENGTH];
 152                 snprintf(ment,sizeof(ment), "%s(%4dx%4d %s)", obj_type, data->width, data->height, data->format);
 153                 _COREGL_TRACE_MEM_REMOVE(ment, data->width * data->height * data->bpp);
 154         }
 155
 156         __removehash_glbuf_object(glbuf, &data);
 157         goto finish;
 158
 159 finish:
 160         return;
 161 }
 162
 163
 164 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 165 void
 166 _surface_trace_set(int set, GLint fbname, GLenum attachment, MY_MODULE_TSTATE *tstate)
 167 {
 168         int atttype = _COREGL_INT_INIT_VALUE;
 169    _orig_tracepath_glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &atttype);
 170         AST(atttype != _COREGL_INT_INIT_VALUE);
 171         int attname = _COREGL_INT_INIT_VALUE;
 172    _orig_tracepath_glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &attname);
 173         AST(attname != _COREGL_INT_INIT_VALUE);
 174         if (set == 1)
 175         {
 176                 switch (atttype)
 177                 {
 178                         case GL_TEXTURE:
 179                                 //COREGL_LOG("FBO DUMPING BEGIN = (TEX)0x%X\n", attname);
 180                                 {
 181                                         char name[256];
 182                                         snprintf(name,sizeof(name), "FBOTEX_0x%X", attname);
 183                                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, fbname, attname, 0, -1, -1, -1, NULL);
 184                                 }
 185                                 break;
 186                         case GL_RENDERBUFFER:
 187                                 //COREGL_LOG("FBO DUMPING BEGIN = (RB)0x%X\n", attname);
 188                                 {
 189                                         char name[256];
 190                                         snprintf(name,sizeof(name), "FBORB_0x%X", attname);
 191                                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, fbname, 0, attname, -1, -1, -1, NULL);
 192                                 }
 193                                 break;
 194                 }
 195         }
 196         else
 197         {
 198                 switch (atttype)
 199                 {
 200                         case GL_TEXTURE:
 201                                 //COREGL_LOG("FBO DUMPING END = (TEX)0x%X\n", attname);
 202                                 {
 203                                         char name[256];
 204                                         snprintf(name,sizeof(name), "FBOTEX_0x%X", attname);
 205                                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, 0, attname, 0, -1, -1, -1, NULL);
 206                                 }
 207                                 break;
 208                         case GL_RENDERBUFFER:
 209                                 //COREGL_LOG("FBO DUMPING END = (RB)0x%X\n", attname);
 210                                 {
 211                                         char name[256];
 212                                         snprintf(name,sizeof(name), "FBORB_0x%X", attname);
 213                                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, 0, 0, attname, -1, -1, -1, NULL);
 214                                 }
 215                                 break;
 216                 }
 217         }
 218 }
 219
 220 void
 221 tracepath_fbdump_update(GLint set)
 222 {
 223         if (trace_surface_flag == 1)
 224         {
 225                 GLint fbname = _COREGL_INT_INIT_VALUE;
 226                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbname);
 227                 AST(fbname != _COREGL_INT_INIT_VALUE);
 228                 if (fbname != 0)
 229                 {
 230                         MY_MODULE_TSTATE *tstate = NULL;
 231
 232                         GET_MY_TSTATE(tstate, get_current_thread_state());
 233                         AST(tstate != NULL);
 234                         /* Prevent CID : 399855 */
 235                         if (tstate != NULL && tstate->ctx != NULL)
 236                         {
 237                                 _surface_trace_set(set, fbname, GL_COLOR_ATTACHMENT0, tstate);
 238 //                              _surface_trace_set(set, fbname, GL_DEPTH_ATTACHMENT, tstate);
 239 //                              _surface_trace_set(set, fbname, GL_STENCIL_ATTACHMENT, tstate);
 240                         }
 241                 }
 242         }
 243 }
 244 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 245
 246
 247
 248
 249
 250
 251 /* OpenGL ES 2.0 */
 252
 253 void
 254 tracepath_glActiveTexture(GLenum texture)
 255 {
 256         _COREGL_TRACEPATH_FUNC_BEGIN();
 257         _orig_tracepath_glActiveTexture(texture);
 258
 259         goto finish;
 260
 261 finish:
 262         _COREGL_TRACEPATH_FUNC_END();
 263 }
 264
 265 void
 266 tracepath_glAttachShader(GLuint program, GLuint shader)
 267 {
 268         _COREGL_TRACEPATH_FUNC_BEGIN();
 269         _orig_tracepath_glAttachShader(program, shader);
 270
 271         goto finish;
 272
 273 finish:
 274         _COREGL_TRACEPATH_FUNC_END();
 275 }
 276
 277 void
 278 tracepath_glBindAttribLocation(GLuint program, GLuint index, const char* name)
 279 {
 280         _COREGL_TRACEPATH_FUNC_BEGIN();
 281         _orig_tracepath_glBindAttribLocation(program, index, name);
 282
 283         goto finish;
 284
 285 finish:
 286         _COREGL_TRACEPATH_FUNC_END();
 287 }
 288
 289 void
 290 tracepath_glBindBuffer(GLenum target, GLuint buffer)
 291 {
 292         _COREGL_TRACEPATH_FUNC_BEGIN();
 293         _orig_tracepath_glBindBuffer(target, buffer);
 294
 295         goto finish;
 296
 297 finish:
 298         _COREGL_TRACEPATH_FUNC_END();
 299 }
 300
 301 void
 302 tracepath_glBindFramebuffer(GLenum target, GLuint framebuffer)
 303 {
 304         _COREGL_TRACEPATH_FUNC_BEGIN();
 305
 306 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 307         if (unlikely(trace_surface_flag == 1))
 308         {
 309                 GLint oldfb;
 310                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oldfb);
 311                 if (oldfb != 0)
 312                 {
 313                         _COREGL_TRACE_SURFACE(0, 2, "GLBINDFBO");
 314                 }
 315
 316                 tracepath_fbdump_update(0);
 317         }
 318 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 319
 320         _orig_tracepath_glBindFramebuffer(target, framebuffer);
 321
 322 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 323         if (unlikely(trace_surface_flag == 1))
 324         {
 325                 tracepath_fbdump_update(1);
 326         }
 327 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 328
 329         goto finish;
 330
 331 finish:
 332         _COREGL_TRACEPATH_FUNC_END();
 333 }
 334
 335 void
 336 tracepath_glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 337 {
 338         _COREGL_TRACEPATH_FUNC_BEGIN();
 339         _orig_tracepath_glBindRenderbuffer(target, renderbuffer);
 340
 341         goto finish;
 342
 343 finish:
 344         _COREGL_TRACEPATH_FUNC_END();
 345 }
 346
 347 void
 348 tracepath_glBindTexture(GLenum target, GLuint texture)
 349 {
 350         _COREGL_TRACEPATH_FUNC_BEGIN();
 351         _orig_tracepath_glBindTexture(target, texture);
 352
 353         goto finish;
 354
 355 finish:
 356         _COREGL_TRACEPATH_FUNC_END();
 357 }
 358
 359 void
 360 tracepath_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 361 {
 362         _COREGL_TRACEPATH_FUNC_BEGIN();
 363         _orig_tracepath_glBlendColor(red, green, blue, alpha);
 364
 365         goto finish;
 366
 367 finish:
 368         _COREGL_TRACEPATH_FUNC_END();
 369 }
 370
 371 void
 372 tracepath_glBlendEquation(GLenum mode)
 373 {
 374         _COREGL_TRACEPATH_FUNC_BEGIN();
 375         _orig_tracepath_glBlendEquation(mode);
 376
 377         goto finish;
 378
 379 finish:
 380         _COREGL_TRACEPATH_FUNC_END();
 381 }
 382
 383 void
 384 tracepath_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 385 {
 386         _COREGL_TRACEPATH_FUNC_BEGIN();
 387         _orig_tracepath_glBlendEquationSeparate(modeRGB, modeAlpha);
 388
 389         goto finish;
 390
 391 finish:
 392         _COREGL_TRACEPATH_FUNC_END();
 393 }
 394
 395 void
 396 tracepath_glBlendFunc(GLenum sfactor, GLenum dfactor)
 397 {
 398         _COREGL_TRACEPATH_FUNC_BEGIN();
 399         _orig_tracepath_glBlendFunc(sfactor, dfactor);
 400
 401         goto finish;
 402
 403 finish:
 404         _COREGL_TRACEPATH_FUNC_END();
 405 }
 406
 407 void
 408 tracepath_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 409 {
 410         _COREGL_TRACEPATH_FUNC_BEGIN();
 411         _orig_tracepath_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 412
 413         goto finish;
 414
 415 finish:
 416         _COREGL_TRACEPATH_FUNC_END();
 417 }
 418
 419 void
 420 tracepath_glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
 421 {
 422         _COREGL_TRACEPATH_FUNC_BEGIN();
 423         _orig_tracepath_glBufferData(target, size, data, usage);
 424
 425         goto finish;
 426
 427 finish:
 428         _COREGL_TRACEPATH_FUNC_END();
 429 }
 430
 431 void
 432 tracepath_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
 433 {
 434         _COREGL_TRACEPATH_FUNC_BEGIN();
 435         _orig_tracepath_glBufferSubData(target, offset, size, data);
 436
 437         goto finish;
 438
 439 finish:
 440         _COREGL_TRACEPATH_FUNC_END();
 441 }
 442
 443 GLenum
 444 tracepath_glCheckFramebufferStatus(GLenum target)
 445 {
 446         GLenum ret = GL_NONE;
 447
 448         _COREGL_TRACEPATH_FUNC_BEGIN();
 449         ret = _orig_tracepath_glCheckFramebufferStatus(target);
 450
 451         goto finish;
 452
 453 finish:
 454         _COREGL_TRACEPATH_FUNC_END();
 455         return ret;
 456 }
 457
 458 void
 459 tracepath_glClear(GLbitfield mask)
 460 {
 461         _COREGL_TRACEPATH_FUNC_BEGIN();
 462         _orig_tracepath_glClear(mask);
 463
 464         goto finish;
 465
 466 finish:
 467         _COREGL_TRACEPATH_FUNC_END();
 468 }
 469
 470 void
 471 tracepath_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 472 {
 473         _COREGL_TRACEPATH_FUNC_BEGIN();
 474         _orig_tracepath_glClearColor(red, green, blue, alpha);
 475
 476         goto finish;
 477
 478 finish:
 479         _COREGL_TRACEPATH_FUNC_END();
 480 }
 481
 482 void
 483 tracepath_glClearDepthf(GLclampf depth)
 484 {
 485         _COREGL_TRACEPATH_FUNC_BEGIN();
 486         _orig_tracepath_glClearDepthf(depth);
 487
 488         goto finish;
 489
 490 finish:
 491         _COREGL_TRACEPATH_FUNC_END();
 492 }
 493
 494 void
 495 tracepath_glClearStencil(GLint s)
 496 {
 497         _COREGL_TRACEPATH_FUNC_BEGIN();
 498         _orig_tracepath_glClearStencil(s);
 499
 500         goto finish;
 501
 502 finish:
 503         _COREGL_TRACEPATH_FUNC_END();
 504 }
 505
 506 void
 507 tracepath_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 508 {
 509         _COREGL_TRACEPATH_FUNC_BEGIN();
 510         _orig_tracepath_glColorMask(red, green, blue, alpha);
 511
 512         goto finish;
 513
 514 finish:
 515         _COREGL_TRACEPATH_FUNC_END();
 516 }
 517
 518 void
 519 tracepath_glCompileShader(GLuint shader)
 520 {
 521         _COREGL_TRACEPATH_FUNC_BEGIN();
 522         _orig_tracepath_glCompileShader(shader);
 523
 524         goto finish;
 525
 526 finish:
 527         _COREGL_TRACEPATH_FUNC_END();
 528 }
 529
 530 void
 531 tracepath_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
 532 {
 533         _COREGL_TRACEPATH_FUNC_BEGIN();
 534         _orig_tracepath_glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 535
 536         goto finish;
 537
 538 finish:
 539         _COREGL_TRACEPATH_FUNC_END();
 540 }
 541
 542 void
 543 tracepath_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
 544 {
 545         _COREGL_TRACEPATH_FUNC_BEGIN();
 546         _orig_tracepath_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 547
 548         goto finish;
 549
 550 finish:
 551         _COREGL_TRACEPATH_FUNC_END();
 552 }
 553
 554 void
 555 tracepath_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 556 {
 557         _COREGL_TRACEPATH_FUNC_BEGIN();
 558         _orig_tracepath_glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 559
 560         goto finish;
 561
 562 finish:
 563         _COREGL_TRACEPATH_FUNC_END();
 564 }
 565
 566 void
 567 tracepath_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 568 {
 569         _COREGL_TRACEPATH_FUNC_BEGIN();
 570         _orig_tracepath_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 571
 572         goto finish;
 573
 574 finish:
 575         _COREGL_TRACEPATH_FUNC_END();
 576 }
 577
 578 GLuint
 579 tracepath_glCreateProgram(void)
 580 {
 581         GLuint ret = _COREGL_INT_INIT_VALUE;
 582
 583         _COREGL_TRACEPATH_FUNC_BEGIN();
 584         ret = _orig_tracepath_glCreateProgram();
 585
 586         goto finish;
 587
 588 finish:
 589         _COREGL_TRACEPATH_FUNC_END();
 590         return ret;
 591 }
 592
 593 GLuint
 594 tracepath_glCreateShader(GLenum type)
 595 {
 596         GLuint ret = _COREGL_INT_INIT_VALUE;
 597         _COREGL_TRACEPATH_FUNC_BEGIN();
 598         ret = _orig_tracepath_glCreateShader(type);
 599
 600         goto finish;
 601
 602 finish:
 603         _COREGL_TRACEPATH_FUNC_END();
 604         return ret;
 605 }
 606
 607 void
 608 tracepath_glCullFace(GLenum mode)
 609 {
 610         _COREGL_TRACEPATH_FUNC_BEGIN();
 611         _orig_tracepath_glCullFace(mode);
 612
 613         goto finish;
 614
 615 finish:
 616         _COREGL_TRACEPATH_FUNC_END();
 617 }
 618
 619 void
 620 tracepath_glDeleteBuffers(GLsizei n, const GLuint* buffers)
 621 {
 622         _COREGL_TRACEPATH_FUNC_BEGIN();
 623         _orig_tracepath_glDeleteBuffers(n, buffers);
 624
 625         goto finish;
 626
 627 finish:
 628         _COREGL_TRACEPATH_FUNC_END();
 629 }
 630
 631 void
 632 tracepath_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
 633 {
 634         _COREGL_TRACEPATH_FUNC_BEGIN();
 635
 636 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 637         tracepath_fbdump_update(0);
 638 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 639
 640         _orig_tracepath_glDeleteFramebuffers(n, framebuffers);
 641
 642 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 643         tracepath_fbdump_update(1);
 644 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 645
 646         goto finish;
 647
 648 finish:
 649         _COREGL_TRACEPATH_FUNC_END();
 650 }
 651
 652 void
 653 tracepath_glDeleteProgram(GLuint program)
 654 {
 655         _COREGL_TRACEPATH_FUNC_BEGIN();
 656         _orig_tracepath_glDeleteProgram(program);
 657
 658         goto finish;
 659
 660 finish:
 661         _COREGL_TRACEPATH_FUNC_END();
 662 }
 663
 664 void
 665 tracepath_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
 666 {
 667         _COREGL_TRACEPATH_FUNC_BEGIN();
 668
 669 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 670         tracepath_fbdump_update(0);
 671 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 672
 673         _orig_tracepath_glDeleteRenderbuffers(n, renderbuffers);
 674
 675 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 676         tracepath_fbdump_update(1);
 677 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 678
 679         goto finish;
 680
 681 finish:
 682         _COREGL_TRACEPATH_FUNC_END();
 683 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
 684         if (trace_mem_flag == 1)
 685         {
 686                 MY_MODULE_TSTATE *tstate = NULL;
 687
 688                 GET_MY_TSTATE(tstate, get_current_thread_state());
 689                 AST(tstate != NULL);
 690                 /* Prevent CID : 402281 */
 691                 if (tstate != NULL && tstate->ctx != NULL)
 692                 {
 693                         for (int i = 0; i < n; i++)
 694                         {
 695                                 if (renderbuffers[i] == 0) continue;
 696                                 _remove_glbuf_object(tstate->ctx->sostate->glbuf_rb, renderbuffers[i], "Renderbuffer");
 697                         }
 698                 }
 699         }
 700 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
 701 }
 702
 703 void
 704 tracepath_glDeleteShader(GLuint shader)
 705 {
 706         _COREGL_TRACEPATH_FUNC_BEGIN();
 707         _orig_tracepath_glDeleteShader(shader);
 708
 709         goto finish;
 710
 711 finish:
 712         _COREGL_TRACEPATH_FUNC_END();
 713 }
 714
 715 void
 716 tracepath_glDeleteTextures(GLsizei n, const GLuint* textures)
 717 {
 718         _COREGL_TRACEPATH_FUNC_BEGIN();
 719
 720 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 721         tracepath_fbdump_update(0);
 722 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 723
 724         _orig_tracepath_glDeleteTextures(n, textures);
 725
 726 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 727         tracepath_fbdump_update(1);
 728 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 729
 730         goto finish;
 731
 732 finish:
 733         _COREGL_TRACEPATH_FUNC_END();
 734 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
 735         if (trace_mem_flag == 1)
 736         {
 737                 MY_MODULE_TSTATE *tstate = NULL;
 738
 739                 GET_MY_TSTATE(tstate, get_current_thread_state());
 740                 AST(tstate != NULL);
 741                 if (tstate != NULL && tstate->ctx != NULL)
 742                 {
 743                         for (int i = 0; i < n; i++)
 744                         {
 745                                 if (textures[i] == 0) continue;
 746                                 _remove_glbuf_object(tstate->ctx->sostate->glbuf_tex, textures[i], "Texture");
 747                         }
 748                 }
 749         }
 750 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
 751 }
 752
 753 void
 754 tracepath_glDepthFunc(GLenum func)
 755 {
 756         _COREGL_TRACEPATH_FUNC_BEGIN();
 757         _orig_tracepath_glDepthFunc(func);
 758
 759         goto finish;
 760
 761 finish:
 762         _COREGL_TRACEPATH_FUNC_END();
 763 }
 764
 765 void
 766 tracepath_glDepthMask(GLboolean flag)
 767 {
 768         _COREGL_TRACEPATH_FUNC_BEGIN();
 769         _orig_tracepath_glDepthMask(flag);
 770
 771         goto finish;
 772
 773 finish:
 774         _COREGL_TRACEPATH_FUNC_END();
 775 }
 776
 777 void
 778 tracepath_glDepthRangef(GLclampf zNear, GLclampf zFar)
 779 {
 780         _COREGL_TRACEPATH_FUNC_BEGIN();
 781         _orig_tracepath_glDepthRangef(zNear, zFar);
 782
 783         goto finish;
 784
 785 finish:
 786         _COREGL_TRACEPATH_FUNC_END();
 787 }
 788
 789 void
 790 tracepath_glDetachShader(GLuint program, GLuint shader)
 791 {
 792         _COREGL_TRACEPATH_FUNC_BEGIN();
 793         _orig_tracepath_glDetachShader(program, shader);
 794
 795         goto finish;
 796
 797 finish:
 798         _COREGL_TRACEPATH_FUNC_END();
 799 }
 800
 801 void
 802 tracepath_glDisable(GLenum cap)
 803 {
 804         _COREGL_TRACEPATH_FUNC_BEGIN();
 805         _orig_tracepath_glDisable(cap);
 806
 807         goto finish;
 808
 809 finish:
 810         _COREGL_TRACEPATH_FUNC_END();
 811 }
 812
 813 void
 814 tracepath_glDisableVertexAttribArray(GLuint index)
 815 {
 816         _COREGL_TRACEPATH_FUNC_BEGIN();
 817         _orig_tracepath_glDisableVertexAttribArray(index);
 818
 819         goto finish;
 820
 821 finish:
 822         _COREGL_TRACEPATH_FUNC_END();
 823 }
 824
 825 void
 826 tracepath_glDrawArrays(GLenum mode, GLint first, GLsizei count)
 827 {
 828         _COREGL_TRACEPATH_FUNC_BEGIN();
 829         _orig_tracepath_glDrawArrays(mode, first, count);
 830
 831         goto finish;
 832
 833 finish:
 834         _COREGL_TRACEPATH_FUNC_END();
 835 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 836         if (trace_surface_flag == 1)
 837         {
 838                 GLint fbname = _COREGL_INT_INIT_VALUE;
 839                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbname);
 840                 AST(fbname != _COREGL_INT_INIT_VALUE);
 841                 if (fbname == 0)
 842                 {
 843                         char name[256];
 844                         EGLint btype;
 845                         _orig_tracepath_eglQuerySurface(_orig_tracepath_eglGetCurrentDisplay(), _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), EGL_RENDER_BUFFER, &btype);
 846                         if (btype == EGL_SINGLE_BUFFER)
 847                                 snprintf(name,sizeof(name), "EGLPIXMAP_%p", _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
 848                         else
 849                                 snprintf(name,sizeof(name), "EGLWINDOW_%p", _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
 850                         tracepath_surface_trace_add(name, _orig_tracepath_eglGetCurrentDisplay(), _orig_tracepath_eglGetCurrentContext(), _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), 0, 0, 0, 0, 0, 0, NULL);
 851                 }
 852    }
 853 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 854 }
 855
 856 void
 857 tracepath_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
 858 {
 859         _COREGL_TRACEPATH_FUNC_BEGIN();
 860         _orig_tracepath_glDrawElements(mode, count, type, indices);
 861
 862         goto finish;
 863
 864 finish:
 865         _COREGL_TRACEPATH_FUNC_END();
 866 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 867         if (trace_surface_flag == 1)
 868         {
 869                 GLint fbname = _COREGL_INT_INIT_VALUE;
 870                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbname);
 871                 AST(fbname != _COREGL_INT_INIT_VALUE);
 872                 if (fbname == 0)
 873                 {
 874                         char name[256];
 875                         EGLint btype;
 876                         _orig_tracepath_eglQuerySurface(_orig_tracepath_eglGetCurrentDisplay(), _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), EGL_RENDER_BUFFER, &btype);
 877                         if (btype == EGL_SINGLE_BUFFER)
 878                                 snprintf(name, "EGLPIXMAP_%p", _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
 879                         else
 880                                 snprintf(name, "EGLWINDOW_%p", _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
 881                         tracepath_surface_trace_add(name, _orig_tracepath_eglGetCurrentDisplay(), _orig_tracepath_eglGetCurrentContext(), _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), 0, 0, 0, 0, 0, 0, NULL);
 882                 }
 883    }
 884 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 885 }
 886
 887 void
 888 tracepath_glEnable(GLenum cap)
 889 {
 890         _COREGL_TRACEPATH_FUNC_BEGIN();
 891         _orig_tracepath_glEnable(cap);
 892
 893         goto finish;
 894
 895 finish:
 896         _COREGL_TRACEPATH_FUNC_END();
 897 }
 898
 899 void
 900 tracepath_glEnableVertexAttribArray(GLuint index)
 901 {
 902         _COREGL_TRACEPATH_FUNC_BEGIN();
 903         _orig_tracepath_glEnableVertexAttribArray(index);
 904
 905         goto finish;
 906
 907 finish:
 908         _COREGL_TRACEPATH_FUNC_END();
 909 }
 910
 911 void
 912 tracepath_glFinish(void)
 913 {
 914         _COREGL_TRACEPATH_FUNC_BEGIN();
 915         _orig_tracepath_glFinish();
 916
 917         _COREGL_TRACE_SURFACE(0, 0, "GLFINISH");
 918
 919         goto finish;
 920
 921 finish:
 922         _COREGL_TRACEPATH_FUNC_END();
 923         _COREGL_TRACE_API_OUTPUT(0);
 924         _COREGL_TRACE_MEM_OUTPUT(0);
 925 }
 926
 927 void
 928 tracepath_glFlush(void)
 929 {
 930         _COREGL_TRACEPATH_FUNC_BEGIN();
 931         _orig_tracepath_glFlush();
 932
 933         _COREGL_TRACE_SURFACE(0, 0, "GLFLUSH");
 934
 935         goto finish;
 936
 937 finish:
 938         _COREGL_TRACEPATH_FUNC_END();
 939         _COREGL_TRACE_API_OUTPUT(0);
 940         _COREGL_TRACE_MEM_OUTPUT(0);
 941 }
 942
 943 void
 944 tracepath_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 945 {
 946         _COREGL_TRACEPATH_FUNC_BEGIN();
 947
 948 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 949         tracepath_fbdump_update(0);
 950 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 951
 952         _orig_tracepath_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 953
 954 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 955         tracepath_fbdump_update(1);
 956 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 957
 958         goto finish;
 959
 960 finish:
 961         _COREGL_TRACEPATH_FUNC_END();
 962 }
 963
 964 void
 965 tracepath_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 966 {
 967         _COREGL_TRACEPATH_FUNC_BEGIN();
 968
 969 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 970         tracepath_fbdump_update(0);
 971 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 972
 973         _orig_tracepath_glFramebufferTexture2D(target, attachment, textarget, texture, level);
 974
 975 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 976         tracepath_fbdump_update(1);
 977 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 978
 979         goto finish;
 980
 981 finish:
 982         _COREGL_TRACEPATH_FUNC_END();
 983 }
 984
 985 void
 986 tracepath_glFrontFace(GLenum mode)
 987 {
 988         _COREGL_TRACEPATH_FUNC_BEGIN();
 989         _orig_tracepath_glFrontFace(mode);
 990
 991         goto finish;
 992
 993 finish:
 994         _COREGL_TRACEPATH_FUNC_END();
 995 }
 996
 997 void
 998 tracepath_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
 999 {
1000         _COREGL_TRACEPATH_FUNC_BEGIN();
1001         _orig_tracepath_glGetVertexAttribfv(index, pname, params);
1002
1003
1004         goto finish;
1005
1006 finish:
1007         _COREGL_TRACEPATH_FUNC_END();
1008 }
1009
1010 void
1011 tracepath_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
1012 {
1013         _COREGL_TRACEPATH_FUNC_BEGIN();
1014         _orig_tracepath_glGetVertexAttribiv(index, pname, params);
1015
1016
1017         goto finish;
1018
1019 finish:
1020         _COREGL_TRACEPATH_FUNC_END();
1021 }
1022
1023 void
1024 tracepath_glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
1025 {
1026         _COREGL_TRACEPATH_FUNC_BEGIN();
1027         _orig_tracepath_glGetVertexAttribPointerv(index, pname, pointer);
1028
1029
1030
1031         goto finish;
1032
1033 finish:
1034         _COREGL_TRACEPATH_FUNC_END();
1035 }
1036
1037 void
1038 tracepath_glHint(GLenum target, GLenum mode)
1039 {
1040         _COREGL_TRACEPATH_FUNC_BEGIN();
1041         _orig_tracepath_glHint(target, mode);
1042
1043         goto finish;
1044
1045 finish:
1046         _COREGL_TRACEPATH_FUNC_END();
1047 }
1048
1049 void
1050 tracepath_glGenBuffers(GLsizei n, GLuint* buffers)
1051 {
1052         _COREGL_TRACEPATH_FUNC_BEGIN();
1053         _orig_tracepath_glGenBuffers(n, buffers);
1054
1055         goto finish;
1056
1057 finish:
1058         _COREGL_TRACEPATH_FUNC_END();
1059 }
1060
1061 void
1062 tracepath_glGenerateMipmap(GLenum target)
1063 {
1064         _COREGL_TRACEPATH_FUNC_BEGIN();
1065         _orig_tracepath_glGenerateMipmap(target);
1066
1067         goto finish;
1068
1069 finish:
1070         _COREGL_TRACEPATH_FUNC_END();
1071 }
1072
1073 void
1074 tracepath_glGenFramebuffers(GLsizei n, GLuint* framebuffers)
1075 {
1076         _COREGL_TRACEPATH_FUNC_BEGIN();
1077         _orig_tracepath_glGenFramebuffers(n, framebuffers);
1078
1079         goto finish;
1080
1081 finish:
1082         _COREGL_TRACEPATH_FUNC_END();
1083 }
1084
1085 void
1086 tracepath_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
1087 {
1088         _COREGL_TRACEPATH_FUNC_BEGIN();
1089         _orig_tracepath_glGenRenderbuffers(n, renderbuffers);
1090
1091         goto finish;
1092
1093 finish:
1094         _COREGL_TRACEPATH_FUNC_END();
1095 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1096         if (trace_mem_flag == 1)
1097         {
1098                 MY_MODULE_TSTATE *tstate = NULL;
1099
1100                 GET_MY_TSTATE(tstate, get_current_thread_state());
1101                 AST(tstate != NULL);
1102                 /* Prevent CID : 396759 */
1103                 if (tstate != NULL && tstate->ctx != NULL)
1104                 {
1105                         for (int i = 0; i < n; i++)
1106                         {
1107                                 if (renderbuffers[i] == 0) continue;
1108                                 _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, renderbuffers[i], "Renderbuffer", 0, 0, 0, "Unknown");
1109                         }
1110                 }
1111         }
1112 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1113 }
1114
1115 void
1116 tracepath_glGenTextures(GLsizei n, GLuint* textures)
1117 {
1118         _COREGL_TRACEPATH_FUNC_BEGIN();
1119         _orig_tracepath_glGenTextures(n, textures);
1120
1121         goto finish;
1122
1123 finish:
1124         _COREGL_TRACEPATH_FUNC_END();
1125 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1126         if (trace_mem_flag == 1)
1127         {
1128                 MY_MODULE_TSTATE *tstate = NULL;
1129
1130                 GET_MY_TSTATE(tstate, get_current_thread_state());
1131                 AST(tstate != NULL);
1132                 /* Prevent CID : 387732 */
1133                 if (tstate != NULL && tstate->ctx != NULL)
1134                 {
1135                         for (int i = 0; i < n; i++)
1136                         {
1137                                 if (textures[i] == 0) continue;
1138                                 _add_glbuf_object(tstate->ctx->sostate->glbuf_tex, textures[i], "Texture", 0, 0, 0, "Unknown");
1139                         }
1140                 }
1141         }
1142 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1143 }
1144
1145 void
1146 tracepath_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
1147 {
1148         _COREGL_TRACEPATH_FUNC_BEGIN();
1149         _orig_tracepath_glGetActiveAttrib(program, index, bufsize, length, size, type, name);
1150
1151         goto finish;
1152
1153 finish:
1154         _COREGL_TRACEPATH_FUNC_END();
1155 }
1156
1157 void
1158 tracepath_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
1159 {
1160         _COREGL_TRACEPATH_FUNC_BEGIN();
1161         _orig_tracepath_glGetActiveUniform(program, index, bufsize, length, size, type, name);
1162
1163         goto finish;
1164
1165 finish:
1166         _COREGL_TRACEPATH_FUNC_END();
1167 }
1168
1169 void
1170 tracepath_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
1171 {
1172         _COREGL_TRACEPATH_FUNC_BEGIN();
1173         _orig_tracepath_glGetAttachedShaders(program, maxcount, count, shaders);
1174
1175         goto finish;
1176
1177 finish:
1178         _COREGL_TRACEPATH_FUNC_END();
1179 }
1180
1181 int
1182 tracepath_glGetAttribLocation(GLuint program, const char* name)
1183 {
1184         int ret = _COREGL_INT_INIT_VALUE;
1185         _COREGL_TRACEPATH_FUNC_BEGIN();
1186         ret = _orig_tracepath_glGetAttribLocation(program, name);
1187
1188         goto finish;
1189
1190 finish:
1191         _COREGL_TRACEPATH_FUNC_END();
1192         return ret;
1193 }
1194
1195 void
1196 tracepath_glGetBooleanv(GLenum pname, GLboolean* params)
1197 {
1198         _COREGL_TRACEPATH_FUNC_BEGIN();
1199         _orig_tracepath_glGetBooleanv(pname, params);
1200
1201         goto finish;
1202
1203 finish:
1204         _COREGL_TRACEPATH_FUNC_END();
1205 }
1206
1207 void
1208 tracepath_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
1209 {
1210         _COREGL_TRACEPATH_FUNC_BEGIN();
1211         _orig_tracepath_glGetBufferParameteriv(target, pname, params);
1212
1213         goto finish;
1214
1215 finish:
1216         _COREGL_TRACEPATH_FUNC_END();
1217 }
1218
1219 GLenum
1220 tracepath_glGetError(void)
1221 {
1222         GLenum ret = GL_NONE;
1223
1224         _COREGL_TRACEPATH_FUNC_BEGIN();
1225         ret = _orig_tracepath_glGetError();
1226         goto finish;
1227
1228 finish:
1229         _COREGL_TRACEPATH_FUNC_END();
1230         return ret;
1231 }
1232
1233 void
1234 tracepath_glGetFloatv(GLenum pname, GLfloat* params)
1235 {
1236         _COREGL_TRACEPATH_FUNC_BEGIN();
1237         _orig_tracepath_glGetFloatv(pname, params);
1238
1239         goto finish;
1240
1241 finish:
1242         _COREGL_TRACEPATH_FUNC_END();
1243 }
1244
1245 void
1246 tracepath_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
1247 {
1248         _COREGL_TRACEPATH_FUNC_BEGIN();
1249         _orig_tracepath_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
1250
1251         goto finish;
1252
1253 finish:
1254         _COREGL_TRACEPATH_FUNC_END();
1255 }
1256
1257 void
1258 tracepath_glGetIntegerv(GLenum pname, GLint* params)
1259 {
1260         _COREGL_TRACEPATH_FUNC_BEGIN();
1261         _orig_tracepath_glGetIntegerv(pname, params);
1262
1263         goto finish;
1264
1265 finish:
1266         _COREGL_TRACEPATH_FUNC_END();
1267 }
1268
1269 void
1270 tracepath_glGetProgramiv(GLuint program, GLenum pname, GLint* params)
1271 {
1272         _COREGL_TRACEPATH_FUNC_BEGIN();
1273         _orig_tracepath_glGetProgramiv(program, pname, params);
1274
1275         goto finish;
1276
1277 finish:
1278         _COREGL_TRACEPATH_FUNC_END();
1279 }
1280
1281 void
1282 tracepath_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
1283 {
1284         _COREGL_TRACEPATH_FUNC_BEGIN();
1285         _orig_tracepath_glGetProgramInfoLog(program, bufsize, length, infolog);
1286
1287         goto finish;
1288
1289 finish:
1290         _COREGL_TRACEPATH_FUNC_END();
1291 }
1292
1293 void
1294 tracepath_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
1295 {
1296         _COREGL_TRACEPATH_FUNC_BEGIN();
1297         _orig_tracepath_glGetRenderbufferParameteriv(target, pname, params);
1298
1299         goto finish;
1300
1301 finish:
1302         _COREGL_TRACEPATH_FUNC_END();
1303 }
1304
1305 void
1306 tracepath_glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
1307 {
1308         _COREGL_TRACEPATH_FUNC_BEGIN();
1309         _orig_tracepath_glGetShaderiv(shader, pname, params);
1310
1311         goto finish;
1312
1313 finish:
1314         _COREGL_TRACEPATH_FUNC_END();
1315 }
1316
1317 void
1318 tracepath_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
1319 {
1320         _COREGL_TRACEPATH_FUNC_BEGIN();
1321         _orig_tracepath_glGetShaderInfoLog(shader, bufsize, length, infolog);
1322
1323         goto finish;
1324
1325 finish:
1326         _COREGL_TRACEPATH_FUNC_END();
1327 }
1328
1329 void
1330 tracepath_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
1331 {
1332         _COREGL_TRACEPATH_FUNC_BEGIN();
1333         _orig_tracepath_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
1334
1335         goto finish;
1336
1337 finish:
1338         _COREGL_TRACEPATH_FUNC_END();
1339 }
1340
1341 void
1342 tracepath_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
1343 {
1344         _COREGL_TRACEPATH_FUNC_BEGIN();
1345         _orig_tracepath_glGetShaderSource(shader, bufsize, length, source);
1346
1347         goto finish;
1348
1349 finish:
1350         _COREGL_TRACEPATH_FUNC_END();
1351 }
1352
1353 const GLubyte *
1354 tracepath_glGetString(GLenum name)
1355 {
1356         const GLubyte *ret = NULL;
1357
1358         _COREGL_TRACEPATH_FUNC_BEGIN();
1359         ret = _orig_tracepath_glGetString(name);
1360
1361         goto finish;
1362
1363 finish:
1364         _COREGL_TRACEPATH_FUNC_END();
1365         return ret;
1366 }
1367
1368 void
1369 tracepath_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
1370 {
1371         _COREGL_TRACEPATH_FUNC_BEGIN();
1372         _orig_tracepath_glGetTexParameterfv(target, pname, params);
1373
1374         goto finish;
1375
1376 finish:
1377         _COREGL_TRACEPATH_FUNC_END();
1378 }
1379
1380 void
1381 tracepath_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
1382 {
1383         _COREGL_TRACEPATH_FUNC_BEGIN();
1384         _orig_tracepath_glGetTexParameteriv(target, pname, params);
1385
1386         goto finish;
1387
1388 finish:
1389         _COREGL_TRACEPATH_FUNC_END();
1390 }
1391
1392 void
1393 tracepath_glGetUniformfv(GLuint program, GLint location, GLfloat* params)
1394 {
1395         _COREGL_TRACEPATH_FUNC_BEGIN();
1396         _orig_tracepath_glGetUniformfv(program, location, params);
1397
1398         goto finish;
1399
1400 finish:
1401         _COREGL_TRACEPATH_FUNC_END();
1402 }
1403
1404 void
1405 tracepath_glGetUniformiv(GLuint program, GLint location, GLint* params)
1406 {
1407         _COREGL_TRACEPATH_FUNC_BEGIN();
1408         _orig_tracepath_glGetUniformiv(program, location, params);
1409
1410         goto finish;
1411
1412 finish:
1413         _COREGL_TRACEPATH_FUNC_END();
1414 }
1415 int
1416 tracepath_glGetUniformLocation(GLuint program, const char* name)
1417 {
1418         int ret = _COREGL_INT_INIT_VALUE;
1419
1420         _COREGL_TRACEPATH_FUNC_BEGIN();
1421         ret = _orig_tracepath_glGetUniformLocation(program, name);
1422
1423         goto finish;
1424
1425 finish:
1426         _COREGL_TRACEPATH_FUNC_END();
1427         return ret;
1428 }
1429
1430 GLboolean
1431 tracepath_glIsBuffer(GLuint buffer)
1432 {
1433         GLboolean ret = GL_FALSE;
1434
1435         _COREGL_TRACEPATH_FUNC_BEGIN();
1436         ret = _orig_tracepath_glIsBuffer(buffer);
1437
1438         goto finish;
1439
1440 finish:
1441         _COREGL_TRACEPATH_FUNC_END();
1442         return ret;
1443 }
1444
1445 GLboolean
1446 tracepath_glIsEnabled(GLenum cap)
1447 {
1448         GLboolean ret = GL_FALSE;
1449
1450         _COREGL_TRACEPATH_FUNC_BEGIN();
1451         ret = _orig_tracepath_glIsEnabled(cap);
1452
1453         goto finish;
1454
1455 finish:
1456         _COREGL_TRACEPATH_FUNC_END();
1457         return ret;
1458 }
1459
1460 GLboolean
1461 tracepath_glIsFramebuffer(GLuint framebuffer)
1462 {
1463         GLboolean ret = GL_FALSE;
1464
1465         _COREGL_TRACEPATH_FUNC_BEGIN();
1466         ret = _orig_tracepath_glIsFramebuffer(framebuffer);
1467
1468         goto finish;
1469
1470 finish:
1471         _COREGL_TRACEPATH_FUNC_END();
1472         return ret;
1473 }
1474
1475 GLboolean
1476 tracepath_glIsProgram(GLuint program)
1477 {
1478         GLboolean ret;
1479         _COREGL_TRACEPATH_FUNC_BEGIN();
1480         ret = _orig_tracepath_glIsProgram(program);
1481
1482         goto finish;
1483
1484 finish:
1485         _COREGL_TRACEPATH_FUNC_END();
1486         return ret;
1487 }
1488
1489 GLboolean
1490 tracepath_glIsRenderbuffer(GLuint renderbuffer)
1491 {
1492         GLboolean ret;
1493         _COREGL_TRACEPATH_FUNC_BEGIN();
1494         ret = _orig_tracepath_glIsRenderbuffer(renderbuffer);
1495
1496         goto finish;
1497
1498 finish:
1499         _COREGL_TRACEPATH_FUNC_END();
1500         return ret;
1501 }
1502
1503 GLboolean
1504 tracepath_glIsShader(GLuint shader)
1505 {
1506         GLboolean ret;
1507         _COREGL_TRACEPATH_FUNC_BEGIN();
1508         ret = _orig_tracepath_glIsShader(shader);
1509
1510         goto finish;
1511
1512 finish:
1513         _COREGL_TRACEPATH_FUNC_END();
1514         return ret;
1515 }
1516
1517 GLboolean
1518 tracepath_glIsTexture(GLuint texture)
1519 {
1520         GLboolean ret;
1521         _COREGL_TRACEPATH_FUNC_BEGIN();
1522         ret = _orig_tracepath_glIsTexture(texture);
1523
1524         goto finish;
1525
1526 finish:
1527         _COREGL_TRACEPATH_FUNC_END();
1528         return ret;
1529 }
1530
1531 void
1532 tracepath_glLineWidth(GLfloat width)
1533 {
1534         _COREGL_TRACEPATH_FUNC_BEGIN();
1535         _orig_tracepath_glLineWidth(width);
1536
1537         goto finish;
1538
1539 finish:
1540         _COREGL_TRACEPATH_FUNC_END();
1541 }
1542
1543 void
1544 tracepath_glLinkProgram(GLuint program)
1545 {
1546         _COREGL_TRACEPATH_FUNC_BEGIN();
1547         _orig_tracepath_glLinkProgram(program);
1548
1549         goto finish;
1550
1551 finish:
1552         _COREGL_TRACEPATH_FUNC_END();
1553 }
1554
1555 void
1556 tracepath_glPixelStorei(GLenum pname, GLint param)
1557 {
1558         _COREGL_TRACEPATH_FUNC_BEGIN();
1559         _orig_tracepath_glPixelStorei(pname, param);
1560
1561         goto finish;
1562
1563 finish:
1564         _COREGL_TRACEPATH_FUNC_END();
1565 }
1566
1567 void
1568 tracepath_glPolygonOffset(GLfloat factor, GLfloat units)
1569 {
1570         _COREGL_TRACEPATH_FUNC_BEGIN();
1571         _orig_tracepath_glPolygonOffset(factor, units);
1572
1573         goto finish;
1574
1575 finish:
1576         _COREGL_TRACEPATH_FUNC_END();
1577 }
1578
1579 void
1580 tracepath_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
1581 {
1582         _COREGL_TRACEPATH_FUNC_BEGIN();
1583         _orig_tracepath_glReadPixels(x, y, width, height, format, type, pixels);
1584
1585         goto finish;
1586
1587 finish:
1588         _COREGL_TRACEPATH_FUNC_END();
1589 }
1590
1591 void
1592 tracepath_glReleaseShaderCompiler(void)
1593 {
1594         _COREGL_TRACEPATH_FUNC_BEGIN();
1595         _orig_tracepath_glReleaseShaderCompiler();
1596
1597         goto finish;
1598
1599 finish:
1600         _COREGL_TRACEPATH_FUNC_END();
1601 }
1602
1603 void
1604 tracepath_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
1605 {
1606         _COREGL_TRACEPATH_FUNC_BEGIN();
1607
1608         _orig_tracepath_glRenderbufferStorage(target, internalformat, width, height);
1609
1610         goto finish;
1611
1612 finish:
1613         _COREGL_TRACEPATH_FUNC_END();
1614 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1615         if (trace_mem_flag == 1)
1616         {
1617                 MY_MODULE_TSTATE *tstate = NULL;
1618
1619                 GET_MY_TSTATE(tstate, get_current_thread_state());
1620                 AST(tstate != NULL);
1621                 /* Precent CID : 406403 */
1622                 if (tstate != NULL && tstate->ctx != NULL)
1623                 {
1624                         int objidx = _COREGL_INT_INIT_VALUE;
1625                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
1626                         AST(objidx != _COREGL_INT_INIT_VALUE);
1627
1628                         // Detect byte per pixel
1629                         int bpp = 0;
1630                         char formatment[80];
1631                         switch (internalformat)
1632                         {
1633                                 case GL_ALPHA: snprintf(formatment,sizeof(formatment), "ALPHA"); bpp = 1; break;
1634                                 case GL_LUMINANCE: snprintf(formatment, sizeof(formatment), "LUMINANCE"); bpp = 1; break;
1635                                 case GL_LUMINANCE_ALPHA: snprintf(formatment, sizeof(formatment),"LUMINANCE_ALPHA"); bpp = 1; break;
1636                                 case GL_RGB: snprintf(formatment,  sizeof(formatment),"RGB"); bpp = 2; break;
1637                                 case GL_RGBA: snprintf(formatment,sizeof(formatment), "RGBA"); bpp = 4; break;
1638                                 case 0x80E1: snprintf(formatment,sizeof(formatment), "BGRA_EXT"); bpp = 4; break;
1639                                 case 0x84F9: snprintf(formatment,sizeof(formatment), "DEPTH_STENCIL_OES"); bpp = 4; break;
1640                                 case GL_DEPTH_COMPONENT : snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT"); bpp = 1; break;
1641                                 case 0x81A5: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT16_ARB"); bpp = 2; break;
1642                                 case 0x81A6: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT24_ARB"); bpp = 3; break;
1643                                 case 0x81A7: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT32_ARB"); bpp = 4; break;
1644                                 case 0x8D46 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX1_OES"); bpp = 1; break;
1645                                 case 0x8D47 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX4_OES"); bpp = 1; break;
1646                                 case 0x8D48 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX8_OES"); bpp = 1; break;
1647                                 default: snprintf(formatment,sizeof(formatment), "0x%X", internalformat); bpp = 0; break;
1648                         }
1649
1650                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width, height, bpp, formatment);
1651                 }
1652         }
1653 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1654 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
1655         if (trace_surface_flag == 1)
1656         {
1657                 MY_MODULE_TSTATE *tstate = NULL;
1658
1659                 GET_MY_TSTATE(tstate, get_current_thread_state());
1660                 AST(tstate != NULL);
1661                 /* Prevent CID : 406403 */
1662                 if (tstate != NULL && tstate->ctx != NULL)
1663                 {
1664                         int objidx = _COREGL_INT_INIT_VALUE;
1665                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
1666                         AST(objidx != _COREGL_INT_INIT_VALUE);
1667
1668                         {
1669                                 int channel = 0;
1670                                 switch (internalformat)
1671                                 {
1672                                         case GL_ALPHA:
1673                                         case GL_LUMINANCE:
1674                                         case GL_DEPTH_COMPONENT :
1675                                         case 0x81A5:
1676                                         case 0x81A6:
1677                                         case 0x81A7:
1678                                         case 0x8D46 :
1679                                         case 0x8D47 :
1680                                         case 0x8D48 : channel = 1; break;
1681                                         case GL_LUMINANCE_ALPHA:
1682                                         case 0x84F9: channel = 2; break;
1683                                         case GL_RGB: channel = 3; break;
1684                                         case GL_RGBA:
1685                                         case 0x80E1: channel = 4; break;
1686                                 }
1687
1688                                 char name[256];
1689                                 snprintf(name,sizeof(name), "FBORB_%d", objidx);
1690                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
1691                         }
1692                 }
1693         }
1694 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
1695 }
1696
1697 void
1698 tracepath_glSampleCoverage(GLclampf value, GLboolean invert)
1699 {
1700         _COREGL_TRACEPATH_FUNC_BEGIN();
1701         _orig_tracepath_glSampleCoverage(value, invert);
1702
1703         goto finish;
1704
1705 finish:
1706         _COREGL_TRACEPATH_FUNC_END();
1707 }
1708
1709 void
1710 tracepath_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
1711 {
1712         _COREGL_TRACEPATH_FUNC_BEGIN();
1713         _orig_tracepath_glScissor(x, y, width, height);
1714
1715         goto finish;
1716
1717 finish:
1718         _COREGL_TRACEPATH_FUNC_END();
1719 }
1720
1721 void
1722 tracepath_glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
1723 {
1724         _COREGL_TRACEPATH_FUNC_BEGIN();
1725         _orig_tracepath_glShaderBinary(n, shaders, binaryformat, binary, length);
1726
1727         goto finish;
1728
1729 finish:
1730         _COREGL_TRACEPATH_FUNC_END();
1731 }
1732
1733 void
1734 tracepath_glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
1735 {
1736         _COREGL_TRACEPATH_FUNC_BEGIN();
1737         _orig_tracepath_glShaderSource(shader, count, string, length);
1738
1739         goto finish;
1740
1741 finish:
1742         _COREGL_TRACEPATH_FUNC_END();
1743 }
1744
1745 void
1746 tracepath_glStencilFunc(GLenum func, GLint ref, GLuint mask)
1747 {
1748         _COREGL_TRACEPATH_FUNC_BEGIN();
1749         _orig_tracepath_glStencilFunc(func, ref, mask);
1750
1751         goto finish;
1752
1753 finish:
1754         _COREGL_TRACEPATH_FUNC_END();
1755 }
1756
1757 void
1758 tracepath_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
1759 {
1760         _COREGL_TRACEPATH_FUNC_BEGIN();
1761         _orig_tracepath_glStencilFuncSeparate(face, func, ref, mask);
1762
1763         goto finish;
1764
1765 finish:
1766         _COREGL_TRACEPATH_FUNC_END();
1767 }
1768
1769 void
1770 tracepath_glStencilMask(GLuint mask)
1771 {
1772         _COREGL_TRACEPATH_FUNC_BEGIN();
1773         _orig_tracepath_glStencilMask(mask);
1774
1775         goto finish;
1776
1777 finish:
1778         _COREGL_TRACEPATH_FUNC_END();
1779 }
1780
1781 void
1782 tracepath_glStencilMaskSeparate(GLenum face, GLuint mask)
1783 {
1784         _COREGL_TRACEPATH_FUNC_BEGIN();
1785         _orig_tracepath_glStencilMaskSeparate(face, mask);
1786
1787         goto finish;
1788
1789 finish:
1790         _COREGL_TRACEPATH_FUNC_END();
1791 }
1792
1793 void
1794 tracepath_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
1795 {
1796         _COREGL_TRACEPATH_FUNC_BEGIN();
1797         _orig_tracepath_glStencilOp(fail, zfail, zpass);
1798
1799         goto finish;
1800
1801 finish:
1802         _COREGL_TRACEPATH_FUNC_END();
1803 }
1804
1805 void
1806 tracepath_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
1807 {
1808         _COREGL_TRACEPATH_FUNC_BEGIN();
1809         _orig_tracepath_glStencilOpSeparate(face, fail, zfail, zpass);
1810
1811         goto finish;
1812
1813 finish:
1814         _COREGL_TRACEPATH_FUNC_END();
1815 }
1816
1817 void
1818 tracepath_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
1819 {
1820         _COREGL_TRACEPATH_FUNC_BEGIN();
1821         _orig_tracepath_glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
1822
1823         goto finish;
1824
1825 finish:
1826         _COREGL_TRACEPATH_FUNC_END();
1827 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1828         if (trace_mem_flag == 1)
1829         {
1830                 MY_MODULE_TSTATE *tstate = NULL;
1831
1832                 GET_MY_TSTATE(tstate, get_current_thread_state());
1833                 AST(tstate != NULL);
1834                 if (tstate != NULL && tstate->ctx != NULL)
1835                 {
1836                         int objidx = _COREGL_INT_INIT_VALUE;
1837                         _orig_tracepath_glGetIntegerv(GL_TEXTURE_BINDING_2D, &objidx);
1838                         AST(objidx != _COREGL_INT_INIT_VALUE);
1839
1840                         // Detect byte per pixel
1841                         int bpp = 0;
1842                         char formatment[80];
1843                         switch (internalformat)
1844                         {
1845                                 case GL_ALPHA: snprintf(formatment,sizeof(formatment), "ALPHA"); bpp = 1; break;
1846                                 case GL_LUMINANCE: snprintf(formatment,sizeof(formatment), "LUMINANCE"); bpp = 1; break;
1847                                 case GL_LUMINANCE_ALPHA: snprintf(formatment,sizeof(formatment), "LUMINANCE_ALPHA"); bpp = 1; break;
1848                                 case GL_RGB: snprintf(formatment,sizeof(formatment), "RGB"); bpp = 2; break;
1849                                 case GL_RGBA: snprintf(formatment,sizeof(formatment), "RGBA"); bpp = 4; break;
1850                                 case 0x80E1: snprintf(formatment,sizeof(formatment), "BGRA_EXT"); bpp = 4; break;
1851                                 case 0x84F9: snprintf(formatment,sizeof(formatment), "DEPTH_STENCIL_OES"); bpp = 4; break;
1852                                 case GL_DEPTH_COMPONENT : snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT"); bpp = 1; break;
1853                                 case 0x81A5: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT16_ARB"); bpp = 2; break;
1854                                 case 0x81A6: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT24_ARB"); bpp = 3; break;
1855                                 case 0x81A7: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT32_ARB"); bpp = 4; break;
1856                                 case 0x8D46 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX1_OES"); bpp = 1; break;
1857                                 case 0x8D47 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX4_OES"); bpp = 1; break;
1858                                 case 0x8D48 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX8_OES"); bpp = 1; break;
1859                                 default: snprintf(formatment, sizeof(formatment),"0x%X", internalformat); bpp = 0; break;
1860                         }
1861
1862                         _add_glbuf_object(tstate->ctx->sostate->glbuf_tex, objidx, "Texture", width, height, bpp, formatment);
1863                 }
1864         }
1865 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1866 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
1867         if (trace_surface_flag == 1)
1868         {
1869                 MY_MODULE_TSTATE *tstate = NULL;
1870
1871                 GET_MY_TSTATE(tstate, get_current_thread_state());
1872                 AST(tstate != NULL);
1873
1874                 /* Prevent CID : 405600 */
1875                 if (tstate != NULL && tstate->ctx != NULL)
1876                 {
1877                         int objidx = _COREGL_INT_INIT_VALUE;
1878                         _orig_tracepath_glGetIntegerv(GL_TEXTURE_BINDING_2D, &objidx);
1879                         AST(objidx != _COREGL_INT_INIT_VALUE);
1880
1881                         {
1882                                 int channel = 0;
1883                                 switch (internalformat)
1884                                 {
1885                                         case GL_ALPHA:
1886                                         case GL_LUMINANCE:
1887                                         case GL_DEPTH_COMPONENT :
1888                                         case 0x81A5:
1889                                         case 0x81A6:
1890                                         case 0x81A7:
1891                                         case 0x8D46 :
1892                                         case 0x8D47 :
1893                                         case 0x8D48 : channel = 1; break;
1894                                         case GL_LUMINANCE_ALPHA:
1895                                         case 0x84F9: channel = 2; break;
1896                                         case GL_RGB: channel = 3; break;
1897                                         case GL_RGBA:
1898                                         case 0x80E1: channel = 4; break;
1899                                 }
1900
1901                                 char name[256];
1902                                 snprintf(name, sizeof(name),"FBOTEX_0x%X", objidx);
1903                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, -1, objidx, 0, width, height, channel, NULL);
1904                         }
1905                 }
1906         }
1907 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
1908 }
1909
1910 void
1911 tracepath_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
1912 {
1913         _COREGL_TRACEPATH_FUNC_BEGIN();
1914         _orig_tracepath_glTexParameterf(target, pname, param);
1915
1916         goto finish;
1917
1918 finish:
1919         _COREGL_TRACEPATH_FUNC_END();
1920 }
1921
1922 void
1923 tracepath_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
1924 {
1925         _COREGL_TRACEPATH_FUNC_BEGIN();
1926         _orig_tracepath_glTexParameterfv(target, pname, params);
1927
1928         goto finish;
1929
1930 finish:
1931         _COREGL_TRACEPATH_FUNC_END();
1932 }
1933
1934 void
1935 tracepath_glTexParameteri(GLenum target, GLenum pname, GLint param)
1936 {
1937         _COREGL_TRACEPATH_FUNC_BEGIN();
1938         _orig_tracepath_glTexParameteri(target, pname, param);
1939
1940         goto finish;
1941
1942 finish:
1943         _COREGL_TRACEPATH_FUNC_END();
1944 }
1945
1946 void
1947 tracepath_glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
1948 {
1949         _COREGL_TRACEPATH_FUNC_BEGIN();
1950         _orig_tracepath_glTexParameteriv(target, pname, params);
1951
1952         goto finish;
1953
1954 finish:
1955         _COREGL_TRACEPATH_FUNC_END();
1956 }
1957
1958 void
1959 tracepath_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
1960 {
1961         _COREGL_TRACEPATH_FUNC_BEGIN();
1962         _orig_tracepath_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
1963
1964         goto finish;
1965
1966 finish:
1967         _COREGL_TRACEPATH_FUNC_END();
1968 }
1969
1970 void
1971 tracepath_glUniform1f(GLint location, GLfloat x)
1972 {
1973         _COREGL_TRACEPATH_FUNC_BEGIN();
1974         _orig_tracepath_glUniform1f(location, x);
1975
1976         goto finish;
1977
1978 finish:
1979         _COREGL_TRACEPATH_FUNC_END();
1980 }
1981
1982 void
1983 tracepath_glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
1984 {
1985         _COREGL_TRACEPATH_FUNC_BEGIN();
1986         _orig_tracepath_glUniform1fv(location, count, v);
1987
1988         goto finish;
1989
1990 finish:
1991         _COREGL_TRACEPATH_FUNC_END();
1992 }
1993
1994 void
1995 tracepath_glUniform1i(GLint location, GLint x)
1996 {
1997         _COREGL_TRACEPATH_FUNC_BEGIN();
1998         _orig_tracepath_glUniform1i(location, x);
1999
2000         goto finish;
2001
2002 finish:
2003         _COREGL_TRACEPATH_FUNC_END();
2004 }
2005
2006 void
2007 tracepath_glUniform1iv(GLint location, GLsizei count, const GLint* v)
2008 {
2009         _COREGL_TRACEPATH_FUNC_BEGIN();
2010         _orig_tracepath_glUniform1iv(location, count, v);
2011
2012         goto finish;
2013
2014 finish:
2015         _COREGL_TRACEPATH_FUNC_END();
2016 }
2017
2018 void
2019 tracepath_glUniform2f(GLint location, GLfloat x, GLfloat y)
2020 {
2021         _COREGL_TRACEPATH_FUNC_BEGIN();
2022         _orig_tracepath_glUniform2f(location, x, y);
2023
2024         goto finish;
2025
2026 finish:
2027         _COREGL_TRACEPATH_FUNC_END();
2028 }
2029
2030 void
2031 tracepath_glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
2032 {
2033         _COREGL_TRACEPATH_FUNC_BEGIN();
2034         _orig_tracepath_glUniform2fv(location, count, v);
2035
2036         goto finish;
2037
2038 finish:
2039         _COREGL_TRACEPATH_FUNC_END();
2040 }
2041
2042 void
2043 tracepath_glUniform2i(GLint location, GLint x, GLint y)
2044 {
2045         _COREGL_TRACEPATH_FUNC_BEGIN();
2046         _orig_tracepath_glUniform2i(location, x, y);
2047
2048         goto finish;
2049
2050 finish:
2051         _COREGL_TRACEPATH_FUNC_END();
2052 }
2053
2054 void
2055 tracepath_glUniform2iv(GLint location, GLsizei count, const GLint* v)
2056 {
2057         _COREGL_TRACEPATH_FUNC_BEGIN();
2058         _orig_tracepath_glUniform2iv(location, count, v);
2059
2060         goto finish;
2061
2062 finish:
2063         _COREGL_TRACEPATH_FUNC_END();
2064 }
2065
2066 void
2067 tracepath_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
2068 {
2069         _COREGL_TRACEPATH_FUNC_BEGIN();
2070         _orig_tracepath_glUniform3f(location, x, y, z);
2071
2072         goto finish;
2073
2074 finish:
2075         _COREGL_TRACEPATH_FUNC_END();
2076 }
2077
2078 void
2079 tracepath_glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
2080 {
2081         _COREGL_TRACEPATH_FUNC_BEGIN();
2082         _orig_tracepath_glUniform3fv(location, count, v);
2083
2084         goto finish;
2085
2086 finish:
2087         _COREGL_TRACEPATH_FUNC_END();
2088 }
2089
2090 void
2091 tracepath_glUniform3i(GLint location, GLint x, GLint y, GLint z)
2092 {
2093         _COREGL_TRACEPATH_FUNC_BEGIN();
2094         _orig_tracepath_glUniform3i(location, x, y, z);
2095
2096         goto finish;
2097
2098 finish:
2099         _COREGL_TRACEPATH_FUNC_END();
2100 }
2101
2102 void
2103 tracepath_glUniform3iv(GLint location, GLsizei count, const GLint* v)
2104 {
2105         _COREGL_TRACEPATH_FUNC_BEGIN();
2106         _orig_tracepath_glUniform3iv(location, count, v);
2107
2108         goto finish;
2109
2110 finish:
2111         _COREGL_TRACEPATH_FUNC_END();
2112 }
2113
2114 void
2115 tracepath_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2116 {
2117         _COREGL_TRACEPATH_FUNC_BEGIN();
2118         _orig_tracepath_glUniform4f(location, x, y, z, w);
2119
2120         goto finish;
2121
2122 finish:
2123         _COREGL_TRACEPATH_FUNC_END();
2124 }
2125
2126 void
2127 tracepath_glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
2128 {
2129         _COREGL_TRACEPATH_FUNC_BEGIN();
2130         _orig_tracepath_glUniform4fv(location, count, v);
2131
2132         goto finish;
2133
2134 finish:
2135         _COREGL_TRACEPATH_FUNC_END();
2136 }
2137
2138 void
2139 tracepath_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
2140 {
2141         _COREGL_TRACEPATH_FUNC_BEGIN();
2142         _orig_tracepath_glUniform4i(location, x, y, z, w);
2143
2144         goto finish;
2145
2146 finish:
2147         _COREGL_TRACEPATH_FUNC_END();
2148 }
2149
2150 void
2151 tracepath_glUniform4iv(GLint location, GLsizei count, const GLint* v)
2152 {
2153         _COREGL_TRACEPATH_FUNC_BEGIN();
2154         _orig_tracepath_glUniform4iv(location, count, v);
2155
2156         goto finish;
2157
2158 finish:
2159         _COREGL_TRACEPATH_FUNC_END();
2160 }
2161
2162 void
2163 tracepath_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2164 {
2165         _COREGL_TRACEPATH_FUNC_BEGIN();
2166         _orig_tracepath_glUniformMatrix2fv(location, count, transpose, value);
2167
2168         goto finish;
2169
2170 finish:
2171         _COREGL_TRACEPATH_FUNC_END();
2172 }
2173
2174 void
2175 tracepath_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2176 {
2177         _COREGL_TRACEPATH_FUNC_BEGIN();
2178         _orig_tracepath_glUniformMatrix3fv(location, count, transpose, value);
2179
2180         goto finish;
2181
2182 finish:
2183         _COREGL_TRACEPATH_FUNC_END();
2184 }
2185
2186 void
2187 tracepath_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2188 {
2189         _COREGL_TRACEPATH_FUNC_BEGIN();
2190         _orig_tracepath_glUniformMatrix4fv(location, count, transpose, value);
2191
2192         goto finish;
2193
2194 finish:
2195         _COREGL_TRACEPATH_FUNC_END();
2196 }
2197
2198 void
2199 tracepath_glUseProgram(GLuint program)
2200 {
2201         _COREGL_TRACEPATH_FUNC_BEGIN();
2202         _orig_tracepath_glUseProgram(program);
2203
2204         goto finish;
2205
2206 finish:
2207         _COREGL_TRACEPATH_FUNC_END();
2208 }
2209
2210 void
2211 tracepath_glValidateProgram(GLuint program)
2212 {
2213         _COREGL_TRACEPATH_FUNC_BEGIN();
2214         _orig_tracepath_glValidateProgram(program);
2215
2216         goto finish;
2217
2218 finish:
2219         _COREGL_TRACEPATH_FUNC_END();
2220 }
2221
2222 void
2223 tracepath_glVertexAttrib1f(GLuint index, GLfloat x)
2224 {
2225         _COREGL_TRACEPATH_FUNC_BEGIN();
2226         _orig_tracepath_glVertexAttrib1f(index, x);
2227
2228         goto finish;
2229
2230 finish:
2231         _COREGL_TRACEPATH_FUNC_END();
2232 }
2233
2234 void
2235 tracepath_glVertexAttrib1fv(GLuint index, const GLfloat* values)
2236 {
2237         _COREGL_TRACEPATH_FUNC_BEGIN();
2238         _orig_tracepath_glVertexAttrib1fv(index, values);
2239
2240         goto finish;
2241
2242 finish:
2243         _COREGL_TRACEPATH_FUNC_END();
2244 }
2245
2246 void
2247 tracepath_glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
2248 {
2249         _COREGL_TRACEPATH_FUNC_BEGIN();
2250         _orig_tracepath_glVertexAttrib2f(index, x, y);
2251
2252         goto finish;
2253
2254 finish:
2255         _COREGL_TRACEPATH_FUNC_END();
2256 }
2257
2258 void
2259 tracepath_glVertexAttrib2fv(GLuint index, const GLfloat* values)
2260 {
2261         _COREGL_TRACEPATH_FUNC_BEGIN();
2262         _orig_tracepath_glVertexAttrib2fv(index, values);
2263
2264         goto finish;
2265
2266 finish:
2267         _COREGL_TRACEPATH_FUNC_END();
2268 }
2269
2270 void
2271 tracepath_glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
2272 {
2273         _COREGL_TRACEPATH_FUNC_BEGIN();
2274         _orig_tracepath_glVertexAttrib3f(index, x, y, z);
2275
2276         goto finish;
2277
2278 finish:
2279         _COREGL_TRACEPATH_FUNC_END();
2280 }
2281
2282 void
2283 tracepath_glVertexAttrib3fv(GLuint index, const GLfloat* values)
2284 {
2285         _COREGL_TRACEPATH_FUNC_BEGIN();
2286         _orig_tracepath_glVertexAttrib3fv(index, values);
2287
2288         goto finish;
2289
2290 finish:
2291         _COREGL_TRACEPATH_FUNC_END();
2292 }
2293
2294 void
2295 tracepath_glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2296 {
2297         _COREGL_TRACEPATH_FUNC_BEGIN();
2298         _orig_tracepath_glVertexAttrib4f(index, x, y, z, w);
2299
2300         goto finish;
2301
2302 finish:
2303         _COREGL_TRACEPATH_FUNC_END();
2304 }
2305
2306 void
2307 tracepath_glVertexAttrib4fv(GLuint index, const GLfloat* values)
2308 {
2309         _COREGL_TRACEPATH_FUNC_BEGIN();
2310         _orig_tracepath_glVertexAttrib4fv(index, values);
2311
2312         goto finish;
2313
2314 finish:
2315         _COREGL_TRACEPATH_FUNC_END();
2316 }
2317
2318 void
2319 tracepath_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer)
2320 {
2321         _COREGL_TRACEPATH_FUNC_BEGIN();
2322         _orig_tracepath_glVertexAttribPointer(index, size, type, normalized, stride, pointer);
2323
2324         goto finish;
2325
2326 finish:
2327         _COREGL_TRACEPATH_FUNC_END();
2328 }
2329
2330 void
2331 tracepath_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
2332 {
2333         _COREGL_TRACEPATH_FUNC_BEGIN();
2334         _orig_tracepath_glViewport(x, y, width, height);
2335
2336         goto finish;
2337
2338 finish:
2339         _COREGL_TRACEPATH_FUNC_END();
2340 }
2341
2342
2343 /* OpenGL ES 3.0 */
2344 void
2345 tracepath_glReadBuffer(GLenum mode)
2346 {
2347         _COREGL_TRACEPATH_FUNC_BEGIN();
2348         _orig_tracepath_glReadBuffer(mode);
2349
2350         goto finish;
2351
2352 finish:
2353         _COREGL_TRACEPATH_FUNC_END();
2354 }
2355
2356 void
2357 tracepath_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices)
2358 {
2359         _COREGL_TRACEPATH_FUNC_BEGIN();
2360         _orig_tracepath_glDrawRangeElements(mode, start, end, count, type, indices);
2361
2362         goto finish;
2363
2364 finish:
2365         _COREGL_TRACEPATH_FUNC_END();
2366 }
2367
2368 void
2369 tracepath_glTexImage3D(GLenum target, GLint level, GLint GLinternalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
2370 {
2371         _COREGL_TRACEPATH_FUNC_BEGIN();
2372         _orig_tracepath_glTexImage3D(target, level, GLinternalFormat, width, height, depth, border, format, type, pixels);
2373
2374         goto finish;
2375
2376 finish:
2377         _COREGL_TRACEPATH_FUNC_END();
2378 }
2379
2380 void
2381 tracepath_glTexImage3DOES(GLenum target, GLint level, GLint GLinternalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
2382 {
2383         _COREGL_TRACEPATH_FUNC_BEGIN();
2384         _orig_tracepath_glTexImage3DOES(target, level, GLinternalFormat, width, height, depth, border, format, type, pixels);
2385
2386         goto finish;
2387
2388 finish:
2389         _COREGL_TRACEPATH_FUNC_END();
2390 }
2391
2392 void
2393 tracepath_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
2394 {
2395         _COREGL_TRACEPATH_FUNC_BEGIN();
2396         _orig_tracepath_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
2397
2398         goto finish;
2399
2400 finish:
2401         _COREGL_TRACEPATH_FUNC_END();
2402 }
2403
2404 void
2405 tracepath_glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
2406 {
2407         _COREGL_TRACEPATH_FUNC_BEGIN();
2408         _orig_tracepath_glTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
2409
2410         goto finish;
2411
2412 finish:
2413         _COREGL_TRACEPATH_FUNC_END();
2414 }
2415
2416 void
2417 tracepath_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
2418 {
2419         _COREGL_TRACEPATH_FUNC_BEGIN();
2420         _orig_tracepath_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
2421
2422         goto finish;
2423
2424 finish:
2425         _COREGL_TRACEPATH_FUNC_END();
2426 }
2427
2428 void
2429 tracepath_glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
2430 {
2431         _COREGL_TRACEPATH_FUNC_BEGIN();
2432         _orig_tracepath_glCopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height);
2433
2434         goto finish;
2435
2436 finish:
2437         _COREGL_TRACEPATH_FUNC_END();
2438 }
2439
2440 void
2441 tracepath_glCompressedTexImage3D(GLenum target, GLint level, GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
2442 {
2443         _COREGL_TRACEPATH_FUNC_BEGIN();
2444         _orig_tracepath_glCompressedTexImage3D(target, level, GLinternalformat, width, height, depth, border, imageSize, data);
2445
2446         goto finish;
2447
2448 finish:
2449         _COREGL_TRACEPATH_FUNC_END();
2450 }
2451
2452 void
2453 tracepath_glCompressedTexImage3DOES(GLenum target, GLint level, GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
2454 {
2455         _COREGL_TRACEPATH_FUNC_BEGIN();
2456         _orig_tracepath_glCompressedTexImage3DOES(target, level, GLinternalformat, width, height, depth, border, imageSize, data);
2457
2458         goto finish;
2459
2460 finish:
2461         _COREGL_TRACEPATH_FUNC_END();
2462 }
2463
2464 void
2465 tracepath_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
2466 {
2467         _COREGL_TRACEPATH_FUNC_BEGIN();
2468         _orig_tracepath_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
2469
2470         goto finish;
2471
2472 finish:
2473         _COREGL_TRACEPATH_FUNC_END();
2474 }
2475
2476 void
2477 tracepath_glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
2478 {
2479         _COREGL_TRACEPATH_FUNC_BEGIN();
2480         _orig_tracepath_glCompressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
2481
2482         goto finish;
2483
2484 finish:
2485         _COREGL_TRACEPATH_FUNC_END();
2486 }
2487
2488 void
2489 tracepath_glGenQueries(GLsizei n, GLuint* ids)
2490 {
2491         _COREGL_TRACEPATH_FUNC_BEGIN();
2492         _orig_tracepath_glGenQueries(n, ids);
2493
2494         goto finish;
2495
2496 finish:
2497         _COREGL_TRACEPATH_FUNC_END();
2498 }
2499
2500 void
2501 tracepath_glDeleteQueries(GLsizei n, const GLuint* ids)
2502 {
2503         _COREGL_TRACEPATH_FUNC_BEGIN();
2504         _orig_tracepath_glDeleteQueries(n, ids);
2505
2506         goto finish;
2507
2508 finish:
2509         _COREGL_TRACEPATH_FUNC_END();
2510 }
2511
2512 GLboolean
2513 tracepath_glIsQuery(GLuint id)
2514 {
2515         GLboolean ret = GL_FALSE;
2516
2517         _COREGL_TRACEPATH_FUNC_BEGIN();
2518         ret = _orig_tracepath_glIsQuery(id);
2519
2520         goto finish;
2521
2522 finish:
2523         _COREGL_TRACEPATH_FUNC_END();
2524         return ret;
2525 }
2526
2527 void
2528 tracepath_glBeginQuery(GLenum target, GLuint id)
2529 {
2530         _COREGL_TRACEPATH_FUNC_BEGIN();
2531         _orig_tracepath_glBeginQuery(target, id);
2532
2533         goto finish;
2534
2535 finish:
2536         _COREGL_TRACEPATH_FUNC_END();
2537 }
2538
2539 void
2540 tracepath_glEndQuery(GLenum target)
2541 {
2542         _COREGL_TRACEPATH_FUNC_BEGIN();
2543         _orig_tracepath_glEndQuery(target);
2544
2545         goto finish;
2546
2547 finish:
2548         _COREGL_TRACEPATH_FUNC_END();
2549 }
2550
2551 void
2552 tracepath_glGetQueryiv(GLenum target, GLenum pname, GLint* params)
2553 {
2554         _COREGL_TRACEPATH_FUNC_BEGIN();
2555         _orig_tracepath_glGetQueryiv(target, pname, params);
2556
2557         goto finish;
2558
2559 finish:
2560         _COREGL_TRACEPATH_FUNC_END();
2561 }
2562
2563 void
2564 tracepath_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
2565 {
2566         _COREGL_TRACEPATH_FUNC_BEGIN();
2567         _orig_tracepath_glGetQueryObjectuiv(id, pname, params);
2568
2569         goto finish;
2570
2571 finish:
2572         _COREGL_TRACEPATH_FUNC_END();
2573 }
2574
2575 GLboolean
2576 tracepath_glUnmapBuffer(GLenum target)
2577 {
2578         GLboolean ret = GL_FALSE;
2579
2580         _COREGL_TRACEPATH_FUNC_BEGIN();
2581         ret = _orig_tracepath_glUnmapBuffer(target);
2582
2583         goto finish;
2584
2585 finish:
2586         _COREGL_TRACEPATH_FUNC_END();
2587         return ret;
2588 }
2589
2590 void
2591 tracepath_glGetBufferPointerv(GLenum target, GLenum pname, GLvoid** params)
2592 {
2593         _COREGL_TRACEPATH_FUNC_BEGIN();
2594         _orig_tracepath_glGetBufferPointerv(target, pname, params);
2595
2596         goto finish;
2597
2598 finish:
2599         _COREGL_TRACEPATH_FUNC_END();
2600 }
2601
2602 void
2603 tracepath_glDrawBuffers(GLsizei n, const GLenum* bufs)
2604 {
2605         _COREGL_TRACEPATH_FUNC_BEGIN();
2606         _orig_tracepath_glDrawBuffers(n, bufs);
2607
2608         goto finish;
2609
2610 finish:
2611         _COREGL_TRACEPATH_FUNC_END();
2612 }
2613
2614 void
2615 tracepath_glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2616 {
2617         _COREGL_TRACEPATH_FUNC_BEGIN();
2618         _orig_tracepath_glUniformMatrix2x3fv(location, count, transpose, value);
2619
2620         goto finish;
2621
2622 finish:
2623         _COREGL_TRACEPATH_FUNC_END();
2624 }
2625
2626 void
2627 tracepath_glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2628 {
2629         _COREGL_TRACEPATH_FUNC_BEGIN();
2630         _orig_tracepath_glUniformMatrix3x2fv(location, count, transpose, value);
2631
2632         goto finish;
2633
2634 finish:
2635         _COREGL_TRACEPATH_FUNC_END();
2636 }
2637
2638 void
2639 tracepath_glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2640 {
2641         _COREGL_TRACEPATH_FUNC_BEGIN();
2642         _orig_tracepath_glUniformMatrix2x4fv(location, count, transpose, value);
2643
2644         goto finish;
2645
2646 finish:
2647         _COREGL_TRACEPATH_FUNC_END();
2648 }
2649
2650 void
2651 tracepath_glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2652 {
2653         _COREGL_TRACEPATH_FUNC_BEGIN();
2654         _orig_tracepath_glUniformMatrix4x2fv(location, count, transpose, value);
2655
2656         goto finish;
2657
2658 finish:
2659         _COREGL_TRACEPATH_FUNC_END();
2660 }
2661
2662 void
2663 tracepath_glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2664 {
2665         _COREGL_TRACEPATH_FUNC_BEGIN();
2666         _orig_tracepath_glUniformMatrix3x4fv(location, count, transpose, value);
2667
2668         goto finish;
2669
2670 finish:
2671         _COREGL_TRACEPATH_FUNC_END();
2672 }
2673
2674 void
2675 tracepath_glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
2676 {
2677         _COREGL_TRACEPATH_FUNC_BEGIN();
2678         _orig_tracepath_glUniformMatrix4x3fv(location, count, transpose, value);
2679
2680         goto finish;
2681
2682 finish:
2683         _COREGL_TRACEPATH_FUNC_END();
2684 }
2685
2686 void
2687 tracepath_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
2688 {
2689         _COREGL_TRACEPATH_FUNC_BEGIN();
2690         _orig_tracepath_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
2691
2692         goto finish;
2693
2694 finish:
2695         _COREGL_TRACEPATH_FUNC_END();
2696 }
2697
2698 void
2699 tracepath_glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
2700 {
2701         _COREGL_TRACEPATH_FUNC_BEGIN();
2702         _orig_tracepath_glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
2703
2704         goto finish;
2705
2706 finish:
2707         _COREGL_TRACEPATH_FUNC_END();
2708 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2709         if (trace_mem_flag == 1)
2710         {
2711                 MY_MODULE_TSTATE *tstate = NULL;
2712
2713                 GET_MY_TSTATE(tstate, get_current_thread_state());
2714                 AST(tstate != NULL);
2715                 /* Prevent CID : 391397 */
2716                 if (tstate != NULL && tstate->ctx != NULL)
2717                 {
2718                         int objidx = _COREGL_INT_INIT_VALUE;
2719                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
2720                         AST(objidx != _COREGL_INT_INIT_VALUE);
2721
2722                         // Detect byte per pixel
2723                         int bpp = 0;
2724                         char formatment[80];
2725                         switch (internalformat)
2726                         {
2727                                 case GL_ALPHA: snprintf(formatment,sizeof(formatment), "ALPHA"); bpp = 1; break;
2728                                 case GL_LUMINANCE: snprintf(formatment,sizeof(formatment), "LUMINANCE"); bpp = 1; break;
2729                                 case GL_LUMINANCE_ALPHA: snprintf(formatment,sizeof(formatment), "LUMINANCE_ALPHA"); bpp = 1; break;
2730                                 case GL_RGB: snprintf(formatment,sizeof(formatment), "RGB"); bpp = 2; break;
2731                                 case GL_RGBA: snprintf(formatment,sizeof(formatment), "RGBA"); bpp = 4; break;
2732                                 case 0x80E1: snprintf(formatment,sizeof(formatment), "BGRA_EXT"); bpp = 4; break;
2733                                 case 0x84F9: snprintf(formatment,sizeof(formatment), "DEPTH_STENCIL_OES"); bpp = 4; break;
2734                                 case GL_DEPTH_COMPONENT : snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT"); bpp = 1; break;
2735                                 case 0x81A5: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT16_ARB"); bpp = 2; break;
2736                                 case 0x81A6: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT24_ARB"); bpp = 3; break;
2737                                 case 0x81A7: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT32_ARB"); bpp = 4; break;
2738                                 case 0x8D46 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX1_OES"); bpp = 1; break;
2739                                 case 0x8D47 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX4_OES"); bpp = 1; break;
2740                                 case 0x8D48 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX8_OES"); bpp = 1; break;
2741                                 default: snprintf(formatment,sizeof(formatment), "0x%X", internalformat); bpp = 0; break;
2742                         }
2743
2744                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width, height, bpp, formatment);
2745                 }
2746         }
2747 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2748 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2749         if (trace_surface_flag == 1)
2750         {
2751                 MY_MODULE_TSTATE *tstate = NULL;
2752
2753                 GET_MY_TSTATE(tstate, get_current_thread_state());
2754                 AST(tstate != NULL);
2755                 /* Prevent CID : 391397 */
2756                 if (tstate != NULL && tstate->ctx != NULL)
2757                 {
2758                         int objidx = _COREGL_INT_INIT_VALUE;
2759                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
2760                         AST(objidx != _COREGL_INT_INIT_VALUE);
2761
2762                         {
2763                                 int channel = 0;
2764                                 switch (internalformat)
2765                                 {
2766                                         case GL_ALPHA:
2767                                         case GL_LUMINANCE:
2768                                         case GL_DEPTH_COMPONENT :
2769                                         case 0x81A5:
2770                                         case 0x81A6:
2771                                         case 0x81A7:
2772                                         case 0x8D46 :
2773                                         case 0x8D47 :
2774                                         case 0x8D48 : channel = 1; break;
2775                                         case GL_LUMINANCE_ALPHA:
2776                                         case 0x84F9: channel = 2; break;
2777                                         case GL_RGB: channel = 3; break;
2778                                         case GL_RGBA:
2779                                         case 0x80E1: channel = 4; break;
2780                                 }
2781
2782                                 char name[256];
2783                                 snprintf(name,sizeof(name), "FBORB_0x%X", objidx);
2784                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
2785                         }
2786                 }
2787         }
2788 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2789 }
2790
2791 void
2792 tracepath_glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
2793 {
2794         _COREGL_TRACEPATH_FUNC_BEGIN();
2795         _orig_tracepath_glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
2796
2797         goto finish;
2798
2799 finish:
2800         _COREGL_TRACEPATH_FUNC_END();
2801 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2802         if (trace_mem_flag == 1)
2803         {
2804                 MY_MODULE_TSTATE *tstate = NULL;
2805
2806                 GET_MY_TSTATE(tstate, get_current_thread_state());
2807                 AST(tstate != NULL);
2808                 /* Prevent CID : 388557 */
2809                 if (tstate != NULL && tstate->ctx != NULL)
2810                 {
2811                         int objidx = _COREGL_INT_INIT_VALUE;
2812                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
2813                         AST(objidx != _COREGL_INT_INIT_VALUE);
2814
2815                         // Detect byte per pixel
2816                         int bpp = 0;
2817                         char formatment[80];
2818                         switch (internalformat)
2819                         {
2820                                 case GL_ALPHA: snprintf(formatment,sizeof(formatment), "ALPHA"); bpp = 1; break;
2821                                 case GL_LUMINANCE: snprintf(formatment,sizeof(formatment), "LUMINANCE"); bpp = 1; break;
2822                                 case GL_LUMINANCE_ALPHA: snprintf(formatment,sizeof(formatment), "LUMINANCE_ALPHA"); bpp = 1; break;
2823                                 case GL_RGB: snprintf(formatment,sizeof(formatment), "RGB"); bpp = 2; break;
2824                                 case GL_RGBA: snprintf(formatment,sizeof(formatment), "RGBA"); bpp = 4; break;
2825                                 case 0x80E1: snprintf(formatment,sizeof(formatment), "BGRA_EXT"); bpp = 4; break;
2826                                 case 0x84F9: snprintf(formatment,sizeof(formatment), "DEPTH_STENCIL_OES"); bpp = 4; break;
2827                                 case GL_DEPTH_COMPONENT : snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT"); bpp = 1; break;
2828                                 case 0x81A5: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT16_ARB"); bpp = 2; break;
2829                                 case 0x81A6: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT24_ARB"); bpp = 3; break;
2830                                 case 0x81A7: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT32_ARB"); bpp = 4; break;
2831                                 case 0x8D46 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX1_OES"); bpp = 1; break;
2832                                 case 0x8D47 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX4_OES"); bpp = 1; break;
2833                                 case 0x8D48 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX8_OES"); bpp = 1; break;
2834                                 default: snprintf(formatment,sizeof(formatment), "0x%X", internalformat); bpp = 0; break;
2835                         }
2836
2837                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width, height, bpp, formatment);
2838                 }
2839         }
2840 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2841 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2842         if (trace_surface_flag == 1)
2843         {
2844                 MY_MODULE_TSTATE *tstate = NULL;
2845
2846                 GET_MY_TSTATE(tstate, get_current_thread_state());
2847                 AST(tstate != NULL);
2848                 /* Prevent CID : 388557 */
2849                 if (tstate != NULL && tstate->ctx != NULL)
2850                 {
2851                         int objidx = _COREGL_INT_INIT_VALUE;
2852                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
2853                         AST(objidx != _COREGL_INT_INIT_VALUE);
2854
2855                         {
2856                                 int channel = 0;
2857                                 switch (internalformat)
2858                                 {
2859                                         case GL_ALPHA:
2860                                         case GL_LUMINANCE:
2861                                         case GL_DEPTH_COMPONENT :
2862                                         case 0x81A5:
2863                                         case 0x81A6:
2864                                         case 0x81A7:
2865                                         case 0x8D46 :
2866                                         case 0x8D47 :
2867                                         case 0x8D48 : channel = 1; break;
2868                                         case GL_LUMINANCE_ALPHA:
2869                                         case 0x84F9: channel = 2; break;
2870                                         case GL_RGB: channel = 3; break;
2871                                         case GL_RGBA:
2872                                         case 0x80E1: channel = 4; break;
2873                                 }
2874
2875                                 char name[256];
2876                                 snprintf(name,sizeof(name), "FBORB_0x%X", objidx);
2877                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
2878                         }
2879                 }
2880         }
2881 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2882 }
2883
2884 void
2885 tracepath_glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
2886 {
2887         _COREGL_TRACEPATH_FUNC_BEGIN();
2888
2889 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2890         tracepath_fbdump_update(0);
2891 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2892
2893         _orig_tracepath_glFramebufferTextureLayer(target, attachment, texture, level, layer);
2894
2895 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2896         tracepath_fbdump_update(1);
2897 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2898
2899         goto finish;
2900
2901 finish:
2902         _COREGL_TRACEPATH_FUNC_END();
2903 }
2904
2905 GLvoid*
2906 tracepath_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
2907 {
2908         GLvoid* ret = NULL;
2909
2910         _COREGL_TRACEPATH_FUNC_BEGIN();
2911         ret = _orig_tracepath_glMapBufferRange(target, offset, length, access);
2912
2913         goto finish;
2914
2915 finish:
2916         _COREGL_TRACEPATH_FUNC_END();
2917         return ret;
2918 }
2919
2920 void
2921 tracepath_glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
2922 {
2923         _COREGL_TRACEPATH_FUNC_BEGIN();
2924         _orig_tracepath_glFlushMappedBufferRange(target, offset, length);
2925
2926         goto finish;
2927
2928 finish:
2929         _COREGL_TRACEPATH_FUNC_END();
2930 }
2931
2932 void
2933 tracepath_glBindVertexArray(GLuint array)
2934 {
2935         _COREGL_TRACEPATH_FUNC_BEGIN();
2936         _orig_tracepath_glBindVertexArray(array);
2937
2938         goto finish;
2939
2940 finish:
2941         _COREGL_TRACEPATH_FUNC_END();
2942 }
2943
2944 void
2945 tracepath_glDeleteVertexArrays(GLsizei n, const GLuint* arrays)
2946 {
2947         _COREGL_TRACEPATH_FUNC_BEGIN();
2948         _orig_tracepath_glDeleteVertexArrays(n, arrays);
2949
2950         goto finish;
2951
2952 finish:
2953         _COREGL_TRACEPATH_FUNC_END();
2954 }
2955
2956 void
2957 tracepath_glGenVertexArrays(GLsizei n, GLuint* arrays)
2958 {
2959         _COREGL_TRACEPATH_FUNC_BEGIN();
2960         _orig_tracepath_glGenVertexArrays(n, arrays);
2961
2962         goto finish;
2963
2964 finish:
2965         _COREGL_TRACEPATH_FUNC_END();
2966 }
2967
2968 GLboolean
2969 tracepath_glIsVertexArray(GLuint array)
2970 {
2971         GLboolean ret = GL_FALSE;
2972
2973         _COREGL_TRACEPATH_FUNC_BEGIN();
2974         ret = _orig_tracepath_glIsVertexArray(array);
2975
2976         goto finish;
2977
2978 finish:
2979         _COREGL_TRACEPATH_FUNC_END();
2980         return ret;
2981 }
2982
2983 void
2984 tracepath_glGetIntegeri_v(GLenum target, GLuint index, GLint* data)
2985 {
2986         _COREGL_TRACEPATH_FUNC_BEGIN();
2987         _orig_tracepath_glGetIntegeri_v(target, index, data);
2988
2989         goto finish;
2990
2991 finish:
2992         _COREGL_TRACEPATH_FUNC_END();
2993 }
2994
2995 void
2996 tracepath_glBeginTransformFeedback(GLenum primitiveMode)
2997 {
2998         _COREGL_TRACEPATH_FUNC_BEGIN();
2999         _orig_tracepath_glBeginTransformFeedback(primitiveMode);
3000
3001         goto finish;
3002
3003 finish:
3004         _COREGL_TRACEPATH_FUNC_END();
3005 }
3006
3007 void
3008 tracepath_glEndTransformFeedback()
3009 {
3010         _COREGL_TRACEPATH_FUNC_BEGIN();
3011         _orig_tracepath_glEndTransformFeedback();
3012
3013         goto finish;
3014
3015 finish:
3016         _COREGL_TRACEPATH_FUNC_END();
3017 }
3018
3019 void
3020 tracepath_glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
3021 {
3022         _COREGL_TRACEPATH_FUNC_BEGIN();
3023         _orig_tracepath_glBindBufferRange(target, index, buffer, offset, size);
3024
3025         goto finish;
3026
3027 finish:
3028         _COREGL_TRACEPATH_FUNC_END();
3029 }
3030
3031 void
3032 tracepath_glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
3033 {
3034         _COREGL_TRACEPATH_FUNC_BEGIN();
3035         _orig_tracepath_glBindBufferBase(target, index, buffer);
3036
3037         goto finish;
3038
3039 finish:
3040         _COREGL_TRACEPATH_FUNC_END();
3041 }
3042
3043 void
3044 tracepath_glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode)
3045 {
3046         _COREGL_TRACEPATH_FUNC_BEGIN();
3047         _orig_tracepath_glTransformFeedbackVaryings(program, count, varyings, bufferMode);
3048
3049         goto finish;
3050
3051 finish:
3052         _COREGL_TRACEPATH_FUNC_END();
3053 }
3054
3055 void
3056 tracepath_glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name)
3057 {
3058         _COREGL_TRACEPATH_FUNC_BEGIN();
3059         _orig_tracepath_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
3060
3061         goto finish;
3062
3063 finish:
3064         _COREGL_TRACEPATH_FUNC_END();
3065 }
3066
3067 void
3068 tracepath_glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
3069 {
3070         _COREGL_TRACEPATH_FUNC_BEGIN();
3071         _orig_tracepath_glVertexAttribIPointer(index, size, type, stride, pointer);
3072
3073         goto finish;
3074
3075 finish:
3076         _COREGL_TRACEPATH_FUNC_END();
3077 }
3078
3079 void
3080 tracepath_glGetVertexAttribIiv(GLuint index, GLenum pname, GLint* params)
3081 {
3082         _COREGL_TRACEPATH_FUNC_BEGIN();
3083         _orig_tracepath_glGetVertexAttribIiv(index, pname, params);
3084
3085         goto finish;
3086
3087 finish:
3088         _COREGL_TRACEPATH_FUNC_END();
3089 }
3090
3091 void
3092 tracepath_glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params)
3093 {
3094         _COREGL_TRACEPATH_FUNC_BEGIN();
3095         _orig_tracepath_glGetVertexAttribIuiv(index, pname, params);
3096
3097         goto finish;
3098
3099 finish:
3100         _COREGL_TRACEPATH_FUNC_END();
3101 }
3102
3103 void
3104 tracepath_glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
3105 {
3106         _COREGL_TRACEPATH_FUNC_BEGIN();
3107         _orig_tracepath_glVertexAttribI4i(index, x, y, z, w);
3108
3109         goto finish;
3110
3111 finish:
3112         _COREGL_TRACEPATH_FUNC_END();
3113 }
3114
3115 void
3116 tracepath_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
3117 {
3118         _COREGL_TRACEPATH_FUNC_BEGIN();
3119         _orig_tracepath_glVertexAttribI4ui(index, x, y, z, w);
3120
3121         goto finish;
3122
3123 finish:
3124         _COREGL_TRACEPATH_FUNC_END();
3125 }
3126
3127 void
3128 tracepath_glVertexAttribI4iv(GLuint index, const GLint* v)
3129 {
3130         _COREGL_TRACEPATH_FUNC_BEGIN();
3131         _orig_tracepath_glVertexAttribI4iv(index, v);
3132
3133         goto finish;
3134
3135 finish:
3136         _COREGL_TRACEPATH_FUNC_END();
3137 }
3138
3139 void
3140 tracepath_glVertexAttribI4uiv(GLuint index, const GLuint* v)
3141 {
3142         _COREGL_TRACEPATH_FUNC_BEGIN();
3143         _orig_tracepath_glVertexAttribI4uiv(index, v);
3144
3145         goto finish;
3146
3147 finish:
3148         _COREGL_TRACEPATH_FUNC_END();
3149 }
3150
3151 void
3152 tracepath_glGetUniformuiv(GLuint program, GLint location, GLuint* params)
3153 {
3154         _COREGL_TRACEPATH_FUNC_BEGIN();
3155         _orig_tracepath_glGetUniformuiv(program, location, params);
3156
3157         goto finish;
3158
3159 finish:
3160         _COREGL_TRACEPATH_FUNC_END();
3161 }
3162
3163 GLint
3164 tracepath_glGetFragDataLocation(GLuint program, const GLchar *name)
3165 {
3166         GLint ret = _COREGL_INT_INIT_VALUE;
3167
3168         _COREGL_TRACEPATH_FUNC_BEGIN();
3169         ret = _orig_tracepath_glGetFragDataLocation(program, name);
3170
3171         goto finish;
3172
3173 finish:
3174         _COREGL_TRACEPATH_FUNC_END();
3175         return ret;
3176 }
3177
3178 void
3179 tracepath_glUniform1ui(GLint location, GLuint v0)
3180 {
3181         _COREGL_TRACEPATH_FUNC_BEGIN();
3182         _orig_tracepath_glUniform1ui(location, v0);
3183
3184         goto finish;
3185
3186 finish:
3187         _COREGL_TRACEPATH_FUNC_END();
3188 }
3189
3190 void
3191 tracepath_glUniform2ui(GLint location, GLuint v0, GLuint v1)
3192 {
3193         _COREGL_TRACEPATH_FUNC_BEGIN();
3194         _orig_tracepath_glUniform2ui(location, v0, v1);
3195
3196         goto finish;
3197
3198 finish:
3199         _COREGL_TRACEPATH_FUNC_END();
3200 }
3201
3202 void
3203 tracepath_glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
3204 {
3205         _COREGL_TRACEPATH_FUNC_BEGIN();
3206         _orig_tracepath_glUniform3ui(location, v0, v1, v2);
3207
3208         goto finish;
3209
3210 finish:
3211         _COREGL_TRACEPATH_FUNC_END();
3212 }
3213
3214 void
3215 tracepath_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
3216 {
3217         _COREGL_TRACEPATH_FUNC_BEGIN();
3218         _orig_tracepath_glUniform4ui(location, v0, v1, v2, v3);
3219
3220         goto finish;
3221
3222 finish:
3223         _COREGL_TRACEPATH_FUNC_END();
3224 }
3225
3226 void
3227 tracepath_glUniform1uiv(GLint location, GLsizei count, const GLuint* value)
3228 {
3229         _COREGL_TRACEPATH_FUNC_BEGIN();
3230         _orig_tracepath_glUniform1uiv(location, count, value);
3231
3232         goto finish;
3233
3234 finish:
3235         _COREGL_TRACEPATH_FUNC_END();
3236 }
3237
3238 void
3239 tracepath_glUniform2uiv(GLint location, GLsizei count, const GLuint* value)
3240 {
3241         _COREGL_TRACEPATH_FUNC_BEGIN();
3242         _orig_tracepath_glUniform2uiv(location, count, value);
3243
3244         goto finish;
3245
3246 finish:
3247         _COREGL_TRACEPATH_FUNC_END();
3248 }
3249
3250 void
3251 tracepath_glUniform3uiv(GLint location, GLsizei count, const GLuint* value)
3252 {
3253         _COREGL_TRACEPATH_FUNC_BEGIN();
3254         _orig_tracepath_glUniform3uiv(location, count, value);
3255
3256         goto finish;
3257
3258 finish:
3259         _COREGL_TRACEPATH_FUNC_END();
3260 }
3261
3262 void
3263 tracepath_glUniform4uiv(GLint location, GLsizei count, const GLuint* value)
3264 {
3265         _COREGL_TRACEPATH_FUNC_BEGIN();
3266         _orig_tracepath_glUniform4uiv(location, count, value);
3267
3268         goto finish;
3269
3270 finish:
3271         _COREGL_TRACEPATH_FUNC_END();
3272 }
3273
3274 void
3275 tracepath_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value)
3276 {
3277         _COREGL_TRACEPATH_FUNC_BEGIN();
3278         _orig_tracepath_glClearBufferiv(buffer, drawbuffer, value);
3279
3280         goto finish;
3281
3282 finish:
3283         _COREGL_TRACEPATH_FUNC_END();
3284 }
3285
3286 void
3287 tracepath_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value)
3288 {
3289         _COREGL_TRACEPATH_FUNC_BEGIN();
3290         _orig_tracepath_glClearBufferuiv(buffer, drawbuffer, value);
3291
3292         goto finish;
3293
3294 finish:
3295         _COREGL_TRACEPATH_FUNC_END();
3296 }
3297
3298 void
3299 tracepath_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value)
3300 {
3301         _COREGL_TRACEPATH_FUNC_BEGIN();
3302         _orig_tracepath_glClearBufferfv(buffer, drawbuffer, value);
3303
3304         goto finish;
3305
3306 finish:
3307         _COREGL_TRACEPATH_FUNC_END();
3308 }
3309
3310 void
3311 tracepath_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
3312 {
3313         _COREGL_TRACEPATH_FUNC_BEGIN();
3314         _orig_tracepath_glClearBufferfi(buffer, drawbuffer, depth, stencil);
3315
3316         goto finish;
3317
3318 finish:
3319         _COREGL_TRACEPATH_FUNC_END();
3320 }
3321
3322 const GLubyte*
3323 tracepath_glGetStringi(GLenum name, GLuint index)
3324 {
3325         const GLubyte* ret = NULL;
3326
3327         _COREGL_TRACEPATH_FUNC_BEGIN();
3328         ret = _orig_tracepath_glGetStringi(name, index);
3329
3330         goto finish;
3331
3332 finish:
3333         _COREGL_TRACEPATH_FUNC_END();
3334         return ret;
3335 }
3336
3337 void
3338 tracepath_glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
3339 {
3340         _COREGL_TRACEPATH_FUNC_BEGIN();
3341         _orig_tracepath_glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
3342
3343         goto finish;
3344
3345 finish:
3346         _COREGL_TRACEPATH_FUNC_END();
3347 }
3348
3349 void
3350 tracepath_glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices)
3351 {
3352         _COREGL_TRACEPATH_FUNC_BEGIN();
3353         _orig_tracepath_glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
3354
3355         goto finish;
3356
3357 finish:
3358         _COREGL_TRACEPATH_FUNC_END();
3359 }
3360
3361 void
3362 tracepath_glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params)
3363 {
3364         _COREGL_TRACEPATH_FUNC_BEGIN();
3365         _orig_tracepath_glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
3366
3367         goto finish;
3368
3369 finish:
3370         _COREGL_TRACEPATH_FUNC_END();
3371 }
3372
3373 GLuint
3374 tracepath_glGetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName)
3375 {
3376         GLuint ret = _COREGL_INT_INIT_VALUE;
3377
3378         _COREGL_TRACEPATH_FUNC_BEGIN();
3379         ret = _orig_tracepath_glGetUniformBlockIndex(program, uniformBlockName);
3380
3381         goto finish;
3382
3383 finish:
3384         _COREGL_TRACEPATH_FUNC_END();
3385         return ret;
3386 }
3387
3388 void
3389 tracepath_glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params)
3390 {
3391         _COREGL_TRACEPATH_FUNC_BEGIN();
3392         _orig_tracepath_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
3393
3394         goto finish;
3395
3396 finish:
3397         _COREGL_TRACEPATH_FUNC_END();
3398 }
3399
3400 void
3401 tracepath_glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName)
3402 {
3403         _COREGL_TRACEPATH_FUNC_BEGIN();
3404         _orig_tracepath_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
3405
3406         goto finish;
3407
3408 finish:
3409         _COREGL_TRACEPATH_FUNC_END();
3410 }
3411
3412 void
3413 tracepath_glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
3414 {
3415         _COREGL_TRACEPATH_FUNC_BEGIN();
3416         _orig_tracepath_glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
3417
3418         goto finish;
3419
3420 finish:
3421         _COREGL_TRACEPATH_FUNC_END();
3422 }
3423
3424 void
3425 tracepath_glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
3426 {
3427         _COREGL_TRACEPATH_FUNC_BEGIN();
3428         _orig_tracepath_glDrawArraysInstanced(mode, first, count, instanceCount);
3429
3430         goto finish;
3431
3432 finish:
3433         _COREGL_TRACEPATH_FUNC_END();
3434 }
3435
3436 void
3437 tracepath_glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount)
3438 {
3439         _COREGL_TRACEPATH_FUNC_BEGIN();
3440         _orig_tracepath_glDrawElementsInstanced(mode, count, type, indices, instanceCount);
3441
3442         goto finish;
3443
3444 finish:
3445         _COREGL_TRACEPATH_FUNC_END();
3446 }
3447
3448 GLsync
3449 tracepath_glFenceSync(GLenum condition, GLbitfield flags)
3450 {
3451         GLsync ret = NULL;
3452
3453         _COREGL_TRACEPATH_FUNC_BEGIN();
3454         ret = _orig_tracepath_glFenceSync(condition, flags);
3455
3456         goto finish;
3457
3458 finish:
3459         _COREGL_TRACEPATH_FUNC_END();
3460         return ret;
3461 }
3462
3463 GLboolean
3464 tracepath_glIsSync(GLsync sync)
3465 {
3466         GLboolean ret = GL_FALSE;
3467
3468         _COREGL_TRACEPATH_FUNC_BEGIN();
3469         ret = _orig_tracepath_glIsSync(sync);
3470
3471         goto finish;
3472
3473 finish:
3474         _COREGL_TRACEPATH_FUNC_END();
3475         return ret;
3476 }
3477
3478 void
3479 tracepath_glDeleteSync(GLsync sync)
3480 {
3481         _COREGL_TRACEPATH_FUNC_BEGIN();
3482         _orig_tracepath_glDeleteSync(sync);
3483
3484         goto finish;
3485
3486 finish:
3487         _COREGL_TRACEPATH_FUNC_END();
3488 }
3489
3490 GLenum
3491 tracepath_glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
3492 {
3493         GLenum ret = _COREGL_INT_INIT_VALUE;
3494
3495         _COREGL_TRACEPATH_FUNC_BEGIN();
3496         ret = _orig_tracepath_glClientWaitSync(sync, flags, timeout);
3497
3498         goto finish;
3499
3500 finish:
3501         _COREGL_TRACEPATH_FUNC_END();
3502         return ret;
3503 }
3504
3505 void
3506 tracepath_glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
3507 {
3508         _COREGL_TRACEPATH_FUNC_BEGIN();
3509         _orig_tracepath_glWaitSync(sync, flags, timeout);
3510
3511         goto finish;
3512
3513 finish:
3514         _COREGL_TRACEPATH_FUNC_END();
3515 }
3516
3517 void
3518 tracepath_glGetInteger64v(GLenum pname, GLint64* params)
3519 {
3520         _COREGL_TRACEPATH_FUNC_BEGIN();
3521         _orig_tracepath_glGetInteger64v(pname, params);
3522
3523         goto finish;
3524
3525 finish:
3526         _COREGL_TRACEPATH_FUNC_END();
3527 }
3528
3529 void
3530 tracepath_glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values)
3531 {
3532         _COREGL_TRACEPATH_FUNC_BEGIN();
3533         _orig_tracepath_glGetSynciv(sync, pname, bufSize, length, values);
3534
3535         goto finish;
3536
3537 finish:
3538         _COREGL_TRACEPATH_FUNC_END();
3539 }
3540
3541 void
3542 tracepath_glGetInteger64i_v(GLenum target, GLuint index, GLint64* data)
3543 {
3544         _COREGL_TRACEPATH_FUNC_BEGIN();
3545         _orig_tracepath_glGetInteger64i_v(target, index, data);
3546
3547         goto finish;
3548
3549 finish:
3550         _COREGL_TRACEPATH_FUNC_END();
3551 }
3552
3553 void
3554 tracepath_glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params)
3555 {
3556         _COREGL_TRACEPATH_FUNC_BEGIN();
3557         _orig_tracepath_glGetBufferParameteri64v(target, pname, params);
3558
3559         goto finish;
3560
3561 finish:
3562         _COREGL_TRACEPATH_FUNC_END();
3563 }
3564
3565 void
3566 tracepath_glGenSamplers(GLsizei n, GLuint* samplers)
3567 {
3568         _COREGL_TRACEPATH_FUNC_BEGIN();
3569         _orig_tracepath_glGenSamplers(n, samplers);
3570
3571         goto finish;
3572
3573 finish:
3574         _COREGL_TRACEPATH_FUNC_END();
3575 }
3576
3577 void
3578 tracepath_glDeleteSamplers(GLsizei n, const GLuint* samplers)
3579 {
3580         _COREGL_TRACEPATH_FUNC_BEGIN();
3581         _orig_tracepath_glDeleteSamplers(n, samplers);
3582
3583         goto finish;
3584
3585 finish:
3586         _COREGL_TRACEPATH_FUNC_END();
3587 }
3588
3589 GLboolean
3590 tracepath_glIsSampler(GLuint sampler)
3591 {
3592         GLboolean ret = GL_FALSE;
3593
3594         _COREGL_TRACEPATH_FUNC_BEGIN();
3595         ret = _orig_tracepath_glIsSampler(sampler);
3596
3597         goto finish;
3598
3599 finish:
3600         _COREGL_TRACEPATH_FUNC_END();
3601         return ret;
3602 }
3603
3604 void
3605 tracepath_glBindSampler(GLuint unit, GLuint sampler)
3606 {
3607         _COREGL_TRACEPATH_FUNC_BEGIN();
3608         _orig_tracepath_glBindSampler(unit, sampler);
3609
3610         goto finish;
3611
3612 finish:
3613         _COREGL_TRACEPATH_FUNC_END();
3614 }
3615
3616 void
3617 tracepath_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
3618 {
3619         _COREGL_TRACEPATH_FUNC_BEGIN();
3620         _orig_tracepath_glSamplerParameteri(sampler, pname, param);
3621
3622         goto finish;
3623
3624 finish:
3625         _COREGL_TRACEPATH_FUNC_END();
3626 }
3627
3628 void
3629 tracepath_glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param)
3630 {
3631         _COREGL_TRACEPATH_FUNC_BEGIN();
3632         _orig_tracepath_glSamplerParameteriv(sampler, pname, param);
3633
3634         goto finish;
3635
3636 finish:
3637         _COREGL_TRACEPATH_FUNC_END();
3638 }
3639
3640 void
3641 tracepath_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
3642 {
3643         _COREGL_TRACEPATH_FUNC_BEGIN();
3644         _orig_tracepath_glSamplerParameterf(sampler, pname, param);
3645
3646         goto finish;
3647
3648 finish:
3649         _COREGL_TRACEPATH_FUNC_END();
3650 }
3651
3652 void
3653 tracepath_glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param)
3654 {
3655         _COREGL_TRACEPATH_FUNC_BEGIN();
3656         _orig_tracepath_glSamplerParameterfv(sampler, pname, param);
3657
3658         goto finish;
3659
3660 finish:
3661         _COREGL_TRACEPATH_FUNC_END();
3662 }
3663
3664 void
3665 tracepath_glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params)
3666 {
3667         _COREGL_TRACEPATH_FUNC_BEGIN();
3668         _orig_tracepath_glGetSamplerParameteriv(sampler, pname, params);
3669
3670         goto finish;
3671
3672 finish:
3673         _COREGL_TRACEPATH_FUNC_END();
3674 }
3675
3676 void
3677 tracepath_glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params)
3678 {
3679         _COREGL_TRACEPATH_FUNC_BEGIN();
3680         _orig_tracepath_glGetSamplerParameterfv(sampler, pname, params);
3681
3682         goto finish;
3683
3684 finish:
3685         _COREGL_TRACEPATH_FUNC_END();
3686 }
3687
3688 void
3689 tracepath_glVertexAttribDivisor(GLuint index, GLuint divisor)
3690 {
3691         _COREGL_TRACEPATH_FUNC_BEGIN();
3692         _orig_tracepath_glVertexAttribDivisor(index, divisor);
3693
3694         goto finish;
3695
3696 finish:
3697         _COREGL_TRACEPATH_FUNC_END();
3698 }
3699
3700 void
3701 tracepath_glBindTransformFeedback(GLenum target, GLuint id)
3702 {
3703         _COREGL_TRACEPATH_FUNC_BEGIN();
3704         _orig_tracepath_glBindTransformFeedback(target, id);
3705
3706         goto finish;
3707
3708 finish:
3709         _COREGL_TRACEPATH_FUNC_END();
3710 }
3711
3712 void
3713 tracepath_glDeleteTransformFeedbacks(GLsizei n, const GLuint* ids)
3714 {
3715         _COREGL_TRACEPATH_FUNC_BEGIN();
3716         _orig_tracepath_glDeleteTransformFeedbacks(n, ids);
3717
3718         goto finish;
3719
3720 finish:
3721         _COREGL_TRACEPATH_FUNC_END();
3722 }
3723
3724 void
3725 tracepath_glGenTransformFeedbacks(GLsizei n, GLuint* ids)
3726 {
3727         _COREGL_TRACEPATH_FUNC_BEGIN();
3728         _orig_tracepath_glGenTransformFeedbacks(n, ids);
3729
3730         goto finish;
3731
3732 finish:
3733         _COREGL_TRACEPATH_FUNC_END();
3734 }
3735
3736 GLboolean
3737 tracepath_glIsTransformFeedback(GLuint id)
3738 {
3739         GLboolean ret = GL_FALSE;
3740
3741         _COREGL_TRACEPATH_FUNC_BEGIN();
3742         ret = _orig_tracepath_glIsTransformFeedback(id);
3743
3744         goto finish;
3745
3746 finish:
3747         _COREGL_TRACEPATH_FUNC_END();
3748         return ret;
3749 }
3750
3751 void
3752 tracepath_glPauseTransformFeedback()
3753 {
3754         _COREGL_TRACEPATH_FUNC_BEGIN();
3755         _orig_tracepath_glPauseTransformFeedback();
3756
3757         goto finish;
3758
3759 finish:
3760         _COREGL_TRACEPATH_FUNC_END();
3761 }
3762
3763 void
3764 tracepath_glResumeTransformFeedback()
3765 {
3766         _COREGL_TRACEPATH_FUNC_BEGIN();
3767         _orig_tracepath_glResumeTransformFeedback();
3768
3769         goto finish;
3770
3771 finish:
3772         _COREGL_TRACEPATH_FUNC_END();
3773 }
3774
3775 void
3776 tracepath_glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
3777 {
3778         _COREGL_TRACEPATH_FUNC_BEGIN();
3779         _orig_tracepath_glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
3780
3781         goto finish;
3782
3783 finish:
3784         _COREGL_TRACEPATH_FUNC_END();
3785 }
3786
3787 void
3788 tracepath_glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
3789 {
3790         _COREGL_TRACEPATH_FUNC_BEGIN();
3791         _orig_tracepath_glGetProgramBinaryOES(program, bufSize, length, binaryFormat, binary);
3792
3793         goto finish;
3794
3795 finish:
3796         _COREGL_TRACEPATH_FUNC_END();
3797 }
3798
3799 void
3800 tracepath_glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length)
3801 {
3802         _COREGL_TRACEPATH_FUNC_BEGIN();
3803         _orig_tracepath_glProgramBinary(program, binaryFormat, binary, length);
3804
3805         goto finish;
3806
3807 finish:
3808         _COREGL_TRACEPATH_FUNC_END();
3809 }
3810
3811 void
3812 tracepath_glProgramBinaryOES(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length)
3813 {
3814         _COREGL_TRACEPATH_FUNC_BEGIN();
3815         _orig_tracepath_glProgramBinaryOES(program, binaryFormat, binary, length);
3816
3817         goto finish;
3818
3819 finish:
3820         _COREGL_TRACEPATH_FUNC_END();
3821 }
3822
3823 void
3824 tracepath_glProgramParameteri(GLuint program, GLenum pname, GLint value)
3825 {
3826         _COREGL_TRACEPATH_FUNC_BEGIN();
3827         _orig_tracepath_glProgramParameteri(program, pname, value);
3828
3829         goto finish;
3830
3831 finish:
3832         _COREGL_TRACEPATH_FUNC_END();
3833 }
3834
3835 void
3836 tracepath_glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments)
3837 {
3838         _COREGL_TRACEPATH_FUNC_BEGIN();
3839         _orig_tracepath_glInvalidateFramebuffer(target, numAttachments, attachments);
3840
3841         goto finish;
3842
3843 finish:
3844         _COREGL_TRACEPATH_FUNC_END();
3845 }
3846
3847 void
3848 tracepath_glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments)
3849 {
3850         _COREGL_TRACEPATH_FUNC_BEGIN();
3851         _orig_tracepath_glDiscardFramebufferEXT(target, numAttachments, attachments);
3852
3853         goto finish;
3854
3855 finish:
3856         _COREGL_TRACEPATH_FUNC_END();
3857 }
3858
3859 void
3860 tracepath_glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height)
3861 {
3862         _COREGL_TRACEPATH_FUNC_BEGIN();
3863         _orig_tracepath_glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
3864
3865         goto finish;
3866
3867 finish:
3868         _COREGL_TRACEPATH_FUNC_END();
3869 }
3870
3871 void
3872 tracepath_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
3873 {
3874         _COREGL_TRACEPATH_FUNC_BEGIN();
3875         _orig_tracepath_glTexStorage2D(target, levels, internalformat, width, height);
3876
3877         goto finish;
3878
3879 finish:
3880         _COREGL_TRACEPATH_FUNC_END();
3881 }
3882
3883 void
3884 tracepath_glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
3885 {
3886         _COREGL_TRACEPATH_FUNC_BEGIN();
3887         _orig_tracepath_glTexStorage3D(target, levels, internalformat, width, height, depth);
3888
3889         goto finish;
3890
3891 finish:
3892         _COREGL_TRACEPATH_FUNC_END();
3893 }
3894
3895 void
3896 tracepath_glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params)
3897 {
3898         _COREGL_TRACEPATH_FUNC_BEGIN();
3899         _orig_tracepath_glGetInternalformativ(target, internalformat, pname, bufSize, params);
3900
3901         goto finish;
3902
3903 finish:
3904         _COREGL_TRACEPATH_FUNC_END();
3905 }
3906
3907
3908 /* GLES Extensions */
3909 void
3910 tracepath_glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
3911 {
3912         _COREGL_TRACEPATH_FUNC_BEGIN();
3913         _orig_tracepath_glEGLImageTargetTexture2DOES(target, image);
3914         goto finish;
3915
3916 finish:
3917         _COREGL_TRACEPATH_FUNC_END();
3918 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
3919         if (trace_mem_flag == 1)
3920         {
3921                 MY_MODULE_TSTATE *tstate = NULL;
3922
3923                 GET_MY_TSTATE(tstate, get_current_thread_state());
3924                 AST(tstate != NULL);
3925                 /* Prevent CID : 404286 */
3926                 if (tstate != NULL && tstate->ctx != NULL)
3927                 {
3928                         int objidx = _COREGL_INT_INIT_VALUE;
3929                         _orig_tracepath_glGetIntegerv(GL_TEXTURE_BINDING_2D, &objidx);
3930                         AST(objidx != _COREGL_INT_INIT_VALUE);
3931
3932                         _add_glbuf_object(tstate->ctx->sostate->glbuf_tex, objidx, "Texture", 0, 0, 0, "Unknown");
3933                 }
3934         }
3935 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
3936 }
3937
3938 void
3939 tracepath_glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
3940 {
3941         _COREGL_TRACEPATH_FUNC_BEGIN();
3942         _orig_tracepath_glEGLImageTargetRenderbufferStorageOES(target, image);
3943         goto finish;
3944
3945 finish:
3946         _COREGL_TRACEPATH_FUNC_END();
3947 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
3948         if (trace_mem_flag == 1)
3949         {
3950                 MY_MODULE_TSTATE *tstate = NULL;
3951
3952                 GET_MY_TSTATE(tstate, get_current_thread_state());
3953                 AST(tstate != NULL);
3954                 /* Prevent CID : 397458 */
3955                 if (tstate != NULL && tstate->ctx != NULL)
3956                 {
3957                         int objidx = _COREGL_INT_INIT_VALUE;
3958                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
3959                         AST(objidx != _COREGL_INT_INIT_VALUE);
3960
3961                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", 0, 0, 0, "Unknown");
3962                 }
3963         }
3964 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
3965 }
3966
3967 void
3968 tracepath_glUseProgramStagesEXT(GLuint pipeline, GLbitfield stages, GLuint program)
3969 {
3970         _COREGL_TRACEPATH_FUNC_BEGIN();
3971         _orig_tracepath_glUseProgramStagesEXT(pipeline, stages, program);
3972
3973         goto finish;
3974
3975 finish:
3976         _COREGL_TRACEPATH_FUNC_END();
3977 }
3978
3979 void
3980 tracepath_glActiveShaderProgramEXT(GLuint pipeline, GLuint program)
3981 {
3982         _COREGL_TRACEPATH_FUNC_BEGIN();
3983         _orig_tracepath_glActiveShaderProgramEXT(pipeline, program);
3984
3985         goto finish;
3986
3987 finish:
3988         _COREGL_TRACEPATH_FUNC_END();
3989 }
3990
3991 GLuint
3992 tracepath_glCreateShaderProgramvEXT(GLenum type, GLsizei count, const char **strings)
3993 {
3994         GLuint ret = _COREGL_INT_INIT_VALUE;
3995
3996         _COREGL_TRACEPATH_FUNC_BEGIN();
3997         ret = _orig_tracepath_glCreateShaderProgramvEXT(type, count, strings);
3998
3999         goto finish;
4000
4001 finish:
4002         _COREGL_TRACEPATH_FUNC_END();
4003    return ret;
4004 }
4005
4006 void
4007 tracepath_glBindProgramPipelineEXT(GLuint pipeline)
4008 {
4009         _COREGL_TRACEPATH_FUNC_BEGIN();
4010         _orig_tracepath_glBindProgramPipelineEXT(pipeline);
4011
4012         goto finish;
4013
4014 finish:
4015         _COREGL_TRACEPATH_FUNC_END();
4016 }
4017
4018 void
4019 tracepath_glDeleteProgramPipelinesEXT(GLsizei n, const GLuint *pipelines)
4020 {
4021         _COREGL_TRACEPATH_FUNC_BEGIN();
4022         _orig_tracepath_glDeleteProgramPipelinesEXT(n, pipelines);
4023
4024         goto finish;
4025
4026 finish:
4027         _COREGL_TRACEPATH_FUNC_END();
4028 }
4029
4030 void
4031 tracepath_glGenProgramPipelinesEXT(GLsizei n, GLuint *pipelines)
4032 {
4033         _COREGL_TRACEPATH_FUNC_BEGIN();
4034         _orig_tracepath_glGenProgramPipelinesEXT(n, pipelines);
4035
4036         goto finish;
4037
4038 finish:
4039         _COREGL_TRACEPATH_FUNC_END();
4040 }
4041
4042 GLboolean
4043 tracepath_glIsProgramPipelineEXT(GLuint pipeline)
4044 {
4045         GLboolean ret = _COREGL_INT_INIT_VALUE;
4046
4047         _COREGL_TRACEPATH_FUNC_BEGIN();
4048         ret = _orig_tracepath_glIsProgramPipelineEXT(pipeline);
4049
4050         goto finish;
4051
4052 finish:
4053         _COREGL_TRACEPATH_FUNC_END();
4054    return ret;
4055 }
4056
4057 void
4058 tracepath_glProgramParameteriEXT(GLuint program, GLenum pname, GLint value)
4059 {
4060         _COREGL_TRACEPATH_FUNC_BEGIN();
4061         _orig_tracepath_glProgramParameteriEXT(program, pname, value);
4062
4063         goto finish;
4064
4065 finish:
4066         _COREGL_TRACEPATH_FUNC_END();
4067 }
4068
4069 void
4070 tracepath_glGetProgramPipelineivEXT(GLuint pipeline, GLenum pname, GLint *params)
4071 {
4072         _COREGL_TRACEPATH_FUNC_BEGIN();
4073         _orig_tracepath_glGetProgramPipelineivEXT(pipeline, pname, params);
4074
4075         goto finish;
4076
4077 finish:
4078         _COREGL_TRACEPATH_FUNC_END();
4079 }
4080
4081 void
4082 tracepath_glProgramUniform1iEXT(GLuint program, GLint location, GLint x)
4083 {
4084         _COREGL_TRACEPATH_FUNC_BEGIN();
4085         _orig_tracepath_glProgramUniform1iEXT(program, location, x);
4086
4087         goto finish;
4088
4089 finish:
4090         _COREGL_TRACEPATH_FUNC_END();
4091 }
4092
4093 void
4094 tracepath_glProgramUniform2iEXT(GLuint program, GLint location, GLint x, GLint y)
4095 {
4096         _COREGL_TRACEPATH_FUNC_BEGIN();
4097         _orig_tracepath_glProgramUniform2iEXT(program, location, x, y);
4098
4099         goto finish;
4100
4101 finish:
4102         _COREGL_TRACEPATH_FUNC_END();
4103 }
4104
4105 void
4106 tracepath_glProgramUniform3iEXT(GLuint program, GLint location, GLint x, GLint y, GLint z)
4107 {
4108         _COREGL_TRACEPATH_FUNC_BEGIN();
4109         _orig_tracepath_glProgramUniform3iEXT(program, location, x, y, z);
4110
4111         goto finish;
4112
4113 finish:
4114         _COREGL_TRACEPATH_FUNC_END();
4115 }
4116
4117 void
4118 tracepath_glProgramUniform4iEXT(GLuint program, GLint location, GLint x, GLint y, GLint z, GLint w)
4119 {
4120         _COREGL_TRACEPATH_FUNC_BEGIN();
4121         _orig_tracepath_glProgramUniform4iEXT(program, location, x, y, z, w);
4122
4123         goto finish;
4124
4125 finish:
4126         _COREGL_TRACEPATH_FUNC_END();
4127 }
4128
4129 void
4130 tracepath_glProgramUniform1fEXT(GLuint program, GLint location, GLfloat x)
4131 {
4132         _COREGL_TRACEPATH_FUNC_BEGIN();
4133         _orig_tracepath_glProgramUniform1fEXT(program, location, x);
4134
4135         goto finish;
4136
4137 finish:
4138         _COREGL_TRACEPATH_FUNC_END();
4139 }
4140
4141 void
4142 tracepath_glProgramUniform2fEXT(GLuint program, GLint location, GLfloat x, GLfloat y)
4143 {
4144         _COREGL_TRACEPATH_FUNC_BEGIN();
4145         _orig_tracepath_glProgramUniform2fEXT(program, location, x, y);
4146
4147         goto finish;
4148
4149 finish:
4150         _COREGL_TRACEPATH_FUNC_END();
4151 }
4152
4153 void
4154 tracepath_glProgramUniform3fEXT(GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z)
4155 {
4156         _COREGL_TRACEPATH_FUNC_BEGIN();
4157         _orig_tracepath_glProgramUniform3fEXT(program, location, x, y, z);
4158
4159         goto finish;
4160
4161 finish:
4162         _COREGL_TRACEPATH_FUNC_END();
4163 }
4164
4165 void
4166 tracepath_glProgramUniform4fEXT(GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4167 {
4168         _COREGL_TRACEPATH_FUNC_BEGIN();
4169         _orig_tracepath_glProgramUniform4fEXT(program, location, x, y, z, w);
4170
4171         goto finish;
4172
4173 finish:
4174         _COREGL_TRACEPATH_FUNC_END();
4175 }
4176
4177 void
4178 tracepath_glProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
4179 {
4180         _COREGL_TRACEPATH_FUNC_BEGIN();
4181         _orig_tracepath_glProgramUniform1ivEXT(program, location, count, value);
4182
4183         goto finish;
4184
4185 finish:
4186         _COREGL_TRACEPATH_FUNC_END();
4187 }
4188
4189 void
4190 tracepath_glProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
4191 {
4192         _COREGL_TRACEPATH_FUNC_BEGIN();
4193         _orig_tracepath_glProgramUniform2ivEXT(program, location, count, value);
4194
4195         goto finish;
4196
4197 finish:
4198         _COREGL_TRACEPATH_FUNC_END();
4199 }
4200
4201 void
4202 tracepath_glProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
4203 {
4204         _COREGL_TRACEPATH_FUNC_BEGIN();
4205         _orig_tracepath_glProgramUniform3ivEXT(program, location, count, value);
4206
4207         goto finish;
4208
4209 finish:
4210         _COREGL_TRACEPATH_FUNC_END();
4211 }
4212
4213 void
4214 tracepath_glProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
4215 {
4216         _COREGL_TRACEPATH_FUNC_BEGIN();
4217         _orig_tracepath_glProgramUniform4ivEXT(program, location, count, value);
4218
4219         goto finish;
4220
4221 finish:
4222         _COREGL_TRACEPATH_FUNC_END();
4223 }
4224
4225 void
4226 tracepath_glProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
4227 {
4228         _COREGL_TRACEPATH_FUNC_BEGIN();
4229         _orig_tracepath_glProgramUniform1fvEXT(program, location, count, value);
4230
4231         goto finish;
4232
4233 finish:
4234         _COREGL_TRACEPATH_FUNC_END();
4235 }
4236
4237 void
4238 tracepath_glProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
4239 {
4240         _COREGL_TRACEPATH_FUNC_BEGIN();
4241         _orig_tracepath_glProgramUniform2fvEXT(program, location, count, value);
4242
4243         goto finish;
4244
4245 finish:
4246         _COREGL_TRACEPATH_FUNC_END();
4247 }
4248
4249 void
4250 tracepath_glProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
4251 {
4252         _COREGL_TRACEPATH_FUNC_BEGIN();
4253         _orig_tracepath_glProgramUniform3fvEXT(program, location, count, value);
4254
4255         goto finish;
4256
4257 finish:
4258         _COREGL_TRACEPATH_FUNC_END();
4259 }
4260
4261 void
4262 tracepath_glProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
4263 {
4264         _COREGL_TRACEPATH_FUNC_BEGIN();
4265         _orig_tracepath_glProgramUniform4fvEXT(program, location, count, value);
4266
4267         goto finish;
4268
4269 finish:
4270         _COREGL_TRACEPATH_FUNC_END();
4271 }
4272
4273 void
4274 tracepath_glProgramUniformMatrix2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4275 {
4276         _COREGL_TRACEPATH_FUNC_BEGIN();
4277         _orig_tracepath_glProgramUniformMatrix2fvEXT(program, location, count, transpose, value);
4278
4279         goto finish;
4280
4281 finish:
4282         _COREGL_TRACEPATH_FUNC_END();
4283 }
4284
4285 void
4286 tracepath_glProgramUniformMatrix3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4287 {
4288         _COREGL_TRACEPATH_FUNC_BEGIN();
4289         _orig_tracepath_glProgramUniformMatrix3fvEXT(program, location, count, transpose, value);
4290
4291         goto finish;
4292
4293 finish:
4294         _COREGL_TRACEPATH_FUNC_END();
4295 }
4296
4297 void
4298 tracepath_glProgramUniformMatrix4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4299 {
4300         _COREGL_TRACEPATH_FUNC_BEGIN();
4301         _orig_tracepath_glProgramUniformMatrix4fvEXT(program, location, count, transpose, value);
4302
4303         goto finish;
4304
4305 finish:
4306         _COREGL_TRACEPATH_FUNC_END();
4307 }
4308
4309 void
4310 tracepath_glValidateProgramPipelineEXT(GLuint pipeline)
4311 {
4312         _COREGL_TRACEPATH_FUNC_BEGIN();
4313         _orig_tracepath_glValidateProgramPipelineEXT(pipeline);
4314
4315         goto finish;
4316
4317 finish:
4318         _COREGL_TRACEPATH_FUNC_END();
4319 }
4320
4321 void
4322 tracepath_glGetProgramPipelineInfoLogEXT(GLuint pipeline, GLsizei bufSize, GLsizei *length, char *infoLog)
4323 {
4324         _COREGL_TRACEPATH_FUNC_BEGIN();
4325         _orig_tracepath_glGetProgramPipelineInfoLogEXT(pipeline, bufSize, length, infoLog);
4326
4327         goto finish;
4328
4329 finish:
4330         _COREGL_TRACEPATH_FUNC_END();
4331 }
4332
4333
4334 void
4335 tracepath_glFramebufferTexture2DMultisampleEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
4336 {
4337         _COREGL_TRACEPATH_FUNC_BEGIN();
4338
4339 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
4340         tracepath_fbdump_update(0);
4341 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
4342
4343         _orig_tracepath_glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples);
4344
4345 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
4346         tracepath_fbdump_update(1);
4347 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
4348
4349         goto finish;
4350
4351 finish:
4352         _COREGL_TRACEPATH_FUNC_END();
4353 }
4354
4355 void
4356 tracepath_glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
4357 {
4358         _COREGL_TRACEPATH_FUNC_BEGIN();
4359         _orig_tracepath_glFramebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset);
4360
4361         goto finish;
4362
4363 finish:
4364         _COREGL_TRACEPATH_FUNC_END();
4365 }
4366
4367 void
4368 tracepath_glBlitFramebufferANGLE(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
4369 {
4370         _COREGL_TRACEPATH_FUNC_BEGIN();
4371         _orig_tracepath_glBlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
4372
4373         goto finish;
4374
4375 finish:
4376         _COREGL_TRACEPATH_FUNC_END();
4377 }
4378
4379 void
4380 tracepath_glRenderbufferStorageMultisampleANGLE(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
4381 {
4382         _COREGL_TRACEPATH_FUNC_BEGIN();
4383
4384         _orig_tracepath_glRenderbufferStorageMultisampleANGLE(target, samples, internalformat, width, height);
4385
4386         goto finish;
4387
4388 finish:
4389         _COREGL_TRACEPATH_FUNC_END();
4390 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
4391         if (trace_mem_flag == 1)
4392         {
4393                 MY_MODULE_TSTATE *tstate = NULL;
4394
4395                 GET_MY_TSTATE(tstate, get_current_thread_state());
4396                 AST(tstate != NULL);
4397                 /* Prevent CID : 394055 */
4398                 if (tstate != NULL && tstate->ctx != NULL)
4399                 {
4400                         int objidx = _COREGL_INT_INIT_VALUE;
4401                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
4402                         AST(objidx != _COREGL_INT_INIT_VALUE);
4403
4404                         // Detect byte per pixel
4405                         int bpp = 0;
4406                         char formatment[80];
4407                         switch (internalformat)
4408                         {
4409                                 case GL_ALPHA: snprintf(formatment,sizeof(formatment), "ALPHA"); bpp = 1; break;
4410                                 case GL_LUMINANCE: snprintf(formatment,sizeof(formatment), "LUMINANCE"); bpp = 1; break;
4411                                 case GL_LUMINANCE_ALPHA: snprintf(formatment,sizeof(formatment), "LUMINANCE_ALPHA"); bpp = 1; break;
4412                                 case GL_RGB: snprintf(formatment,sizeof(formatment), "RGB"); bpp = 2; break;
4413                                 case GL_RGBA: snprintf(formatment,sizeof(formatment), "RGBA"); bpp = 4; break;
4414                                 case 0x80E1: snprintf(formatment,sizeof(formatment), "BGRA_EXT"); bpp = 4; break;
4415                                 case 0x84F9: snprintf(formatment,sizeof(formatment), "DEPTH_STENCIL_OES"); bpp = 4; break;
4416                                 case GL_DEPTH_COMPONENT : snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT"); bpp = 1; break;
4417                                 case 0x81A5: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT16_ARB"); bpp = 2; break;
4418                                 case 0x81A6: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT24_ARB"); bpp = 3; break;
4419                                 case 0x81A7: snprintf(formatment,sizeof(formatment), "DEPTH_COMPONENT32_ARB"); bpp = 4; break;
4420                                 case 0x8D46 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX1_OES"); bpp = 1; break;
4421                                 case 0x8D47 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX4_OES"); bpp = 1; break;
4422                                 case 0x8D48 : snprintf(formatment,sizeof(formatment), "STENCIL_INDEX8_OES"); bpp = 1; break;
4423                                 default: snprintf(formatment,sizeof(formatment), "0x%X", internalformat); bpp = 0; break;
4424                         }
4425
4426                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width, height, bpp, formatment);
4427                 }
4428         }
4429 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
4430 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
4431         if (trace_surface_flag == 1)
4432         {
4433                 MY_MODULE_TSTATE *tstate = NULL;
4434
4435                 GET_MY_TSTATE(tstate, get_current_thread_state());
4436                 AST(tstate != NULL);
4437                 /* Prevent CID : 394055 */
4438                 if (tstate != NULL && tstate->ctx != NULL)
4439                 {
4440                         int objidx = _COREGL_INT_INIT_VALUE;
4441                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
4442                         AST(objidx != _COREGL_INT_INIT_VALUE);
4443
4444                         {
4445                                 int channel = 0;
4446                                 switch (internalformat)
4447                                 {
4448                                         case GL_ALPHA:
4449                                         case GL_LUMINANCE:
4450                                         case GL_DEPTH_COMPONENT :
4451                                         case 0x81A5:
4452                                         case 0x81A6:
4453                                         case 0x81A7:
4454                                         case 0x8D46 :
4455                                         case 0x8D47 :
4456                                         case 0x8D48 : channel = 1; break;
4457                                         case GL_LUMINANCE_ALPHA:
4458                                         case 0x84F9: channel = 2; break;
4459                                         case GL_RGB: channel = 3; break;
4460                                         case GL_RGBA:
4461                                         case 0x80E1: channel = 4; break;
4462                                 }
4463
4464                                 char name[256];
4465                                 snprintf(name, sizeof(name),"FBORB_%d", objidx);
4466                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
4467                         }
4468                 }
4469         }
4470 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
4471 }
4472
4473
4474 void
4475 tracepath_glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid** params)
4476 {
4477         _COREGL_TRACEPATH_FUNC_BEGIN();
4478         _orig_tracepath_glGetBufferPointervOES(target, pname, params);
4479
4480         goto finish;
4481
4482 finish:
4483         _COREGL_TRACEPATH_FUNC_END();
4484 }
4485
4486
4487 void *
4488 tracepath_glMapBufferOES(GLenum target, GLenum access)
4489 {
4490         void *ret = NULL;
4491
4492         _COREGL_TRACEPATH_FUNC_BEGIN();
4493         ret = _orig_tracepath_glMapBufferOES(target, access);
4494
4495         goto finish;
4496
4497 finish:
4498         _COREGL_TRACEPATH_FUNC_END();
4499    return ret;
4500 }
4501
4502
4503 GLboolean
4504 tracepath_glUnmapBufferOES(GLenum target)
4505 {
4506         GLboolean ret = GL_FALSE;
4507
4508         _COREGL_TRACEPATH_FUNC_BEGIN();
4509         ret = _orig_tracepath_glUnmapBufferOES(target);
4510
4511         goto finish;
4512
4513 finish:
4514         _COREGL_TRACEPATH_FUNC_END();
4515    return ret;
4516 }
4517