dlls/wined3d/query.c

   1 /*
   2  * Copyright 2005 Oliver Stieber
   3  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
   4  * Copyright 2009-2010 Henri Verbeet for CodeWeavers.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24 #include "wined3d_private.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  27
  28 BOOL wined3d_event_query_supported(const struct wined3d_gl_info *gl_info)
  29 {
  30     return gl_info->supported[ARB_SYNC] || gl_info->supported[NV_FENCE] || gl_info->supported[APPLE_FENCE];
  31 }
  32
  33 void wined3d_event_query_destroy(struct wined3d_event_query *query)
  34 {
  35     if (query->context) context_free_event_query(query);
  36     HeapFree(GetProcessHeap(), 0, query);
  37 }
  38
  39 static enum wined3d_event_query_result wined3d_event_query_test(const struct wined3d_event_query *query,
  40         const struct wined3d_device *device)
  41 {
  42     struct wined3d_context *context;
  43     const struct wined3d_gl_info *gl_info;
  44     enum wined3d_event_query_result ret;
  45     BOOL fence_result;
  46
  47     TRACE("(%p) : device %p\n", query, device);
  48
  49     if (!query->context)
  50     {
  51         TRACE("Query not started\n");
  52         return WINED3D_EVENT_QUERY_NOT_STARTED;
  53     }
  54
  55     if (!query->context->gl_info->supported[ARB_SYNC] && query->context->tid != GetCurrentThreadId())
  56     {
  57         WARN("Event query tested from wrong thread\n");
  58         return WINED3D_EVENT_QUERY_WRONG_THREAD;
  59     }
  60
  61     context = context_acquire(device, query->context->current_rt);
  62     gl_info = context->gl_info;
  63
  64     if (gl_info->supported[ARB_SYNC])
  65     {
  66         GLenum gl_ret = GL_EXTCALL(glClientWaitSync(query->object.sync, 0, 0));
  67         checkGLcall("glClientWaitSync");
  68
  69         switch (gl_ret)
  70         {
  71             case GL_ALREADY_SIGNALED:
  72             case GL_CONDITION_SATISFIED:
  73                 ret = WINED3D_EVENT_QUERY_OK;
  74                 break;
  75
  76             case GL_TIMEOUT_EXPIRED:
  77                 ret = WINED3D_EVENT_QUERY_WAITING;
  78                 break;
  79
  80             case GL_WAIT_FAILED:
  81             default:
  82                 ERR("glClientWaitSync returned %#x.\n", gl_ret);
  83                 ret = WINED3D_EVENT_QUERY_ERROR;
  84         }
  85     }
  86     else if (gl_info->supported[APPLE_FENCE])
  87     {
  88         fence_result = GL_EXTCALL(glTestFenceAPPLE(query->object.id));
  89         checkGLcall("glTestFenceAPPLE");
  90         if (fence_result) ret = WINED3D_EVENT_QUERY_OK;
  91         else ret = WINED3D_EVENT_QUERY_WAITING;
  92     }
  93     else if (gl_info->supported[NV_FENCE])
  94     {
  95         fence_result = GL_EXTCALL(glTestFenceNV(query->object.id));
  96         checkGLcall("glTestFenceNV");
  97         if (fence_result) ret = WINED3D_EVENT_QUERY_OK;
  98         else ret = WINED3D_EVENT_QUERY_WAITING;
  99     }
 100     else
 101     {
 102         ERR("Event query created despite lack of GL support\n");
 103         ret = WINED3D_EVENT_QUERY_ERROR;
 104     }
 105
 106     context_release(context);
 107     return ret;
 108 }
 109
 110 enum wined3d_event_query_result wined3d_event_query_finish(const struct wined3d_event_query *query,
 111         const struct wined3d_device *device)
 112 {
 113     struct wined3d_context *context;
 114     const struct wined3d_gl_info *gl_info;
 115     enum wined3d_event_query_result ret;
 116
 117     TRACE("(%p)\n", query);
 118
 119     if (!query->context)
 120     {
 121         TRACE("Query not started\n");
 122         return WINED3D_EVENT_QUERY_NOT_STARTED;
 123     }
 124     gl_info = query->context->gl_info;
 125
 126     if (query->context->tid != GetCurrentThreadId() && !gl_info->supported[ARB_SYNC])
 127     {
 128         /* A glFinish does not reliably wait for draws in other contexts. The caller has
 129          * to find its own way to cope with the thread switch
 130          */
 131         WARN("Event query finished from wrong thread\n");
 132         return WINED3D_EVENT_QUERY_WRONG_THREAD;
 133     }
 134
 135     context = context_acquire(device, query->context->current_rt);
 136
 137     if (gl_info->supported[ARB_SYNC])
 138     {
 139         /* Apple seems to be into arbitrary limits, and timeouts larger than
 140          * 0xfffffffffffffbff immediately return GL_TIMEOUT_EXPIRED. We don't
 141          * really care and can live with waiting a few μs less. (OS X 10.7.4). */
 142         GLenum gl_ret = GL_EXTCALL(glClientWaitSync(query->object.sync, GL_SYNC_FLUSH_COMMANDS_BIT, ~(GLuint64)0xffff));
 143         checkGLcall("glClientWaitSync");
 144
 145         switch (gl_ret)
 146         {
 147             case GL_ALREADY_SIGNALED:
 148             case GL_CONDITION_SATISFIED:
 149                 ret = WINED3D_EVENT_QUERY_OK;
 150                 break;
 151
 152                 /* We don't expect a timeout for a ~584 year wait */
 153             default:
 154                 ERR("glClientWaitSync returned %#x.\n", gl_ret);
 155                 ret = WINED3D_EVENT_QUERY_ERROR;
 156         }
 157     }
 158     else if (context->gl_info->supported[APPLE_FENCE])
 159     {
 160         GL_EXTCALL(glFinishFenceAPPLE(query->object.id));
 161         checkGLcall("glFinishFenceAPPLE");
 162         ret = WINED3D_EVENT_QUERY_OK;
 163     }
 164     else if (context->gl_info->supported[NV_FENCE])
 165     {
 166         GL_EXTCALL(glFinishFenceNV(query->object.id));
 167         checkGLcall("glFinishFenceNV");
 168         ret = WINED3D_EVENT_QUERY_OK;
 169     }
 170     else
 171     {
 172         ERR("Event query created without GL support\n");
 173         ret = WINED3D_EVENT_QUERY_ERROR;
 174     }
 175
 176     context_release(context);
 177     return ret;
 178 }
 179
 180 void wined3d_event_query_issue(struct wined3d_event_query *query, const struct wined3d_device *device)
 181 {
 182     const struct wined3d_gl_info *gl_info;
 183     struct wined3d_context *context;
 184
 185     if (query->context)
 186     {
 187         if (!query->context->gl_info->supported[ARB_SYNC] && query->context->tid != GetCurrentThreadId())
 188         {
 189             context_free_event_query(query);
 190             context = context_acquire(device, NULL);
 191             context_alloc_event_query(context, query);
 192         }
 193         else
 194         {
 195             context = context_acquire(device, query->context->current_rt);
 196         }
 197     }
 198     else
 199     {
 200         context = context_acquire(device, NULL);
 201         context_alloc_event_query(context, query);
 202     }
 203
 204     gl_info = context->gl_info;
 205
 206     if (gl_info->supported[ARB_SYNC])
 207     {
 208         if (query->object.sync) GL_EXTCALL(glDeleteSync(query->object.sync));
 209         checkGLcall("glDeleteSync");
 210         query->object.sync = GL_EXTCALL(glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0));
 211         checkGLcall("glFenceSync");
 212     }
 213     else if (gl_info->supported[APPLE_FENCE])
 214     {
 215         GL_EXTCALL(glSetFenceAPPLE(query->object.id));
 216         checkGLcall("glSetFenceAPPLE");
 217     }
 218     else if (gl_info->supported[NV_FENCE])
 219     {
 220         GL_EXTCALL(glSetFenceNV(query->object.id, GL_ALL_COMPLETED_NV));
 221         checkGLcall("glSetFenceNV");
 222     }
 223
 224     context_release(context);
 225 }
 226
 227 ULONG CDECL wined3d_query_incref(struct wined3d_query *query)
 228 {
 229     ULONG refcount = InterlockedIncrement(&query->ref);
 230
 231     TRACE("%p increasing refcount to %u.\n", query, refcount);
 232
 233     return refcount;
 234 }
 235
 236 ULONG CDECL wined3d_query_decref(struct wined3d_query *query)
 237 {
 238     ULONG refcount = InterlockedDecrement(&query->ref);
 239
 240     TRACE("%p decreasing refcount to %u.\n", query, refcount);
 241
 242     if (!refcount)
 243     {
 244         /* Queries are specific to the GL context that created them. Not
 245          * deleting the query will obviously leak it, but that's still better
 246          * than potentially deleting a different query with the same id in this
 247          * context, and (still) leaking the actual query. */
 248         if (query->type == WINED3D_QUERY_TYPE_EVENT)
 249         {
 250             struct wined3d_event_query *event_query = query->extendedData;
 251             if (event_query) wined3d_event_query_destroy(event_query);
 252         }
 253         else if (query->type == WINED3D_QUERY_TYPE_OCCLUSION)
 254         {
 255             struct wined3d_occlusion_query *oq = query->extendedData;
 256
 257             if (oq->context) context_free_occlusion_query(oq);
 258             HeapFree(GetProcessHeap(), 0, query->extendedData);
 259         }
 260         else if (query->type == WINED3D_QUERY_TYPE_TIMESTAMP)
 261         {
 262             struct wined3d_timestamp_query *tq = query->extendedData;
 263
 264             if (tq->context)
 265                 context_free_timestamp_query(tq);
 266             HeapFree(GetProcessHeap(), 0, query->extendedData);
 267         }
 268
 269         HeapFree(GetProcessHeap(), 0, query);
 270     }
 271
 272     return refcount;
 273 }
 274
 275 HRESULT CDECL wined3d_query_get_data(struct wined3d_query *query,
 276         void *data, UINT data_size, DWORD flags)
 277 {
 278     TRACE("query %p, data %p, data_size %u, flags %#x.\n",
 279             query, data, data_size, flags);
 280
 281     return query->query_ops->query_get_data(query, data, data_size, flags);
 282 }
 283
 284 UINT CDECL wined3d_query_get_data_size(const struct wined3d_query *query)
 285 {
 286     TRACE("query %p.\n", query);
 287
 288     return query->data_size;
 289 }
 290
 291 HRESULT CDECL wined3d_query_issue(struct wined3d_query *query, DWORD flags)
 292 {
 293     TRACE("query %p, flags %#x.\n", query, flags);
 294
 295     return query->query_ops->query_issue(query, flags);
 296 }
 297
 298 static void fill_query_data(void *out, unsigned int out_size, const void *result, unsigned int result_size)
 299 {
 300     memcpy(out, result, min(out_size, result_size));
 301 }
 302
 303 static HRESULT wined3d_occlusion_query_ops_get_data(struct wined3d_query *query,
 304         void *data, DWORD size, DWORD flags)
 305 {
 306     struct wined3d_occlusion_query *oq = query->extendedData;
 307     struct wined3d_device *device = query->device;
 308     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 309     struct wined3d_context *context;
 310     GLuint available;
 311     GLuint samples;
 312     HRESULT res;
 313
 314     TRACE("query %p, data %p, size %#x, flags %#x.\n", query, data, size, flags);
 315
 316     if (!oq->context)
 317         query->state = QUERY_CREATED;
 318
 319     if (query->state == QUERY_CREATED)
 320     {
 321         /* D3D allows GetData on a new query, OpenGL doesn't. So just invent the data ourselves */
 322         TRACE("Query wasn't yet started, returning S_OK\n");
 323         samples = 0;
 324         fill_query_data(data, size, &samples, sizeof(samples));
 325         return S_OK;
 326     }
 327
 328     if (query->state == QUERY_BUILDING)
 329     {
 330         /* Msdn says this returns an error, but our tests show that S_FALSE is returned */
 331         TRACE("Query is building, returning S_FALSE\n");
 332         return S_FALSE;
 333     }
 334
 335     if (!gl_info->supported[ARB_OCCLUSION_QUERY])
 336     {
 337         WARN("%p Occlusion queries not supported. Returning 1.\n", query);
 338         samples = 1;
 339         fill_query_data(data, size, &samples, sizeof(samples));
 340         return S_OK;
 341     }
 342
 343     if (oq->context->tid != GetCurrentThreadId())
 344     {
 345         FIXME("%p Wrong thread, returning 1.\n", query);
 346         samples = 1;
 347         fill_query_data(data, size, &samples, sizeof(samples));
 348         return S_OK;
 349     }
 350
 351     context = context_acquire(query->device, oq->context->current_rt);
 352
 353     GL_EXTCALL(glGetQueryObjectuivARB(oq->id, GL_QUERY_RESULT_AVAILABLE_ARB, &available));
 354     checkGLcall("glGetQueryObjectuivARB(GL_QUERY_RESULT_AVAILABLE)");
 355     TRACE("available %#x.\n", available);
 356
 357     if (available)
 358     {
 359         if (size)
 360         {
 361             GL_EXTCALL(glGetQueryObjectuivARB(oq->id, GL_QUERY_RESULT_ARB, &samples));
 362             checkGLcall("glGetQueryObjectuivARB(GL_QUERY_RESULT)");
 363             TRACE("Returning %d samples.\n", samples);
 364             fill_query_data(data, size, &samples, sizeof(samples));
 365         }
 366         res = S_OK;
 367     }
 368     else
 369     {
 370         res = S_FALSE;
 371     }
 372
 373     context_release(context);
 374
 375     return res;
 376 }
 377
 378 static HRESULT wined3d_event_query_ops_get_data(struct wined3d_query *query,
 379         void *data, DWORD size, DWORD flags)
 380 {
 381     struct wined3d_event_query *event_query = query->extendedData;
 382     BOOL signaled;
 383     enum wined3d_event_query_result ret;
 384
 385     TRACE("query %p, data %p, size %#x, flags %#x.\n", query, data, size, flags);
 386
 387     if (!data || !size) return S_OK;
 388     if (!event_query)
 389     {
 390         WARN("Event query not supported by GL, reporting GPU idle.\n");
 391         signaled = TRUE;
 392         fill_query_data(data, size, &signaled, sizeof(signaled));
 393         return S_OK;
 394     }
 395
 396     ret = wined3d_event_query_test(event_query, query->device);
 397     switch(ret)
 398     {
 399         case WINED3D_EVENT_QUERY_OK:
 400         case WINED3D_EVENT_QUERY_NOT_STARTED:
 401             signaled = TRUE;
 402             fill_query_data(data, size, &signaled, sizeof(signaled));
 403             break;
 404
 405         case WINED3D_EVENT_QUERY_WAITING:
 406             signaled = FALSE;
 407             fill_query_data(data, size, &signaled, sizeof(signaled));
 408             break;
 409
 410         case WINED3D_EVENT_QUERY_WRONG_THREAD:
 411             FIXME("(%p) Wrong thread, reporting GPU idle.\n", query);
 412             signaled = TRUE;
 413             fill_query_data(data, size, &signaled, sizeof(signaled));
 414             break;
 415
 416         case WINED3D_EVENT_QUERY_ERROR:
 417             ERR("The GL event query failed, returning D3DERR_INVALIDCALL\n");
 418             return WINED3DERR_INVALIDCALL;
 419     }
 420
 421     return S_OK;
 422 }
 423
 424 void * CDECL wined3d_query_get_parent(const struct wined3d_query *query)
 425 {
 426     TRACE("query %p.\n", query);
 427
 428     return query->parent;
 429 }
 430
 431 enum wined3d_query_type CDECL wined3d_query_get_type(const struct wined3d_query *query)
 432 {
 433     TRACE("query %p.\n", query);
 434
 435     return query->type;
 436 }
 437
 438 static HRESULT wined3d_event_query_ops_issue(struct wined3d_query *query, DWORD flags)
 439 {
 440     TRACE("query %p, flags %#x.\n", query, flags);
 441
 442     TRACE("(%p) : flags %#x, type D3DQUERY_EVENT\n", query, flags);
 443     if (flags & WINED3DISSUE_END)
 444     {
 445         struct wined3d_event_query *event_query = query->extendedData;
 446
 447         /* Faked event query support */
 448         if (!event_query) return WINED3D_OK;
 449
 450         wined3d_event_query_issue(event_query, query->device);
 451     }
 452     else if (flags & WINED3DISSUE_BEGIN)
 453     {
 454         /* Started implicitly at device creation */
 455         ERR("Event query issued with START flag - what to do?\n");
 456     }
 457
 458     if (flags & WINED3DISSUE_BEGIN)
 459         query->state = QUERY_BUILDING;
 460     else
 461         query->state = QUERY_SIGNALLED;
 462
 463     return WINED3D_OK;
 464 }
 465
 466 static HRESULT wined3d_occlusion_query_ops_issue(struct wined3d_query *query, DWORD flags)
 467 {
 468     struct wined3d_device *device = query->device;
 469     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 470
 471     TRACE("query %p, flags %#x.\n", query, flags);
 472
 473     if (gl_info->supported[ARB_OCCLUSION_QUERY])
 474     {
 475         struct wined3d_occlusion_query *oq = query->extendedData;
 476         struct wined3d_context *context;
 477
 478         /* This is allowed according to msdn and our tests. Reset the query and restart */
 479         if (flags & WINED3DISSUE_BEGIN)
 480         {
 481             if (query->state == QUERY_BUILDING)
 482             {
 483                 if (oq->context->tid != GetCurrentThreadId())
 484                 {
 485                     FIXME("Wrong thread, can't restart query.\n");
 486
 487                     context_free_occlusion_query(oq);
 488                     context = context_acquire(query->device, NULL);
 489                     context_alloc_occlusion_query(context, oq);
 490                 }
 491                 else
 492                 {
 493                     context = context_acquire(query->device, oq->context->current_rt);
 494
 495                     GL_EXTCALL(glEndQueryARB(GL_SAMPLES_PASSED_ARB));
 496                     checkGLcall("glEndQuery()");
 497                 }
 498             }
 499             else
 500             {
 501                 if (oq->context) context_free_occlusion_query(oq);
 502                 context = context_acquire(query->device, NULL);
 503                 context_alloc_occlusion_query(context, oq);
 504             }
 505
 506             GL_EXTCALL(glBeginQueryARB(GL_SAMPLES_PASSED_ARB, oq->id));
 507             checkGLcall("glBeginQuery()");
 508
 509             context_release(context);
 510         }
 511         if (flags & WINED3DISSUE_END)
 512         {
 513             /* Msdn says _END on a non-building occlusion query returns an error, but
 514              * our tests show that it returns OK. But OpenGL doesn't like it, so avoid
 515              * generating an error
 516              */
 517             if (query->state == QUERY_BUILDING)
 518             {
 519                 if (oq->context->tid != GetCurrentThreadId())
 520                 {
 521                     FIXME("Wrong thread, can't end query.\n");
 522                 }
 523                 else
 524                 {
 525                     context = context_acquire(query->device, oq->context->current_rt);
 526
 527                     GL_EXTCALL(glEndQueryARB(GL_SAMPLES_PASSED_ARB));
 528                     checkGLcall("glEndQuery()");
 529
 530                     context_release(context);
 531                 }
 532             }
 533         }
 534     }
 535     else
 536     {
 537         FIXME("%p Occlusion queries not supported.\n", query);
 538     }
 539
 540     if (flags & WINED3DISSUE_BEGIN)
 541         query->state = QUERY_BUILDING;
 542     else
 543         query->state = QUERY_SIGNALLED;
 544
 545     return WINED3D_OK; /* can be WINED3DERR_INVALIDCALL.    */
 546 }
 547
 548 static HRESULT wined3d_timestamp_query_ops_get_data(struct wined3d_query *query,
 549         void *data, DWORD size, DWORD flags)
 550 {
 551     struct wined3d_timestamp_query *tq = query->extendedData;
 552     struct wined3d_device *device = query->device;
 553     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 554     struct wined3d_context *context;
 555     GLuint available;
 556     GLuint64 timestamp;
 557     HRESULT res;
 558
 559     TRACE("query %p, data %p, size %#x, flags %#x.\n", query, data, size, flags);
 560
 561     if (!tq->context)
 562         query->state = QUERY_CREATED;
 563
 564     if (query->state == QUERY_CREATED)
 565     {
 566         /* D3D allows GetData on a new query, OpenGL doesn't. So just invent the data ourselves. */
 567         TRACE("Query wasn't yet started, returning S_OK.\n");
 568         timestamp = 0;
 569         fill_query_data(data, size, &timestamp, sizeof(timestamp));
 570         return S_OK;
 571     }
 572
 573     if (tq->context->tid != GetCurrentThreadId())
 574     {
 575         FIXME("%p Wrong thread, returning 1.\n", query);
 576         timestamp = 1;
 577         fill_query_data(data, size, &timestamp, sizeof(timestamp));
 578         return S_OK;
 579     }
 580
 581     context = context_acquire(query->device, tq->context->current_rt);
 582
 583     GL_EXTCALL(glGetQueryObjectuivARB(tq->id, GL_QUERY_RESULT_AVAILABLE_ARB, &available));
 584     checkGLcall("glGetQueryObjectuivARB(GL_QUERY_RESULT_AVAILABLE)");
 585     TRACE("available %#x.\n", available);
 586
 587     if (available)
 588     {
 589         if (size)
 590         {
 591             GL_EXTCALL(glGetQueryObjectui64v(tq->id, GL_QUERY_RESULT_ARB, &timestamp));
 592             checkGLcall("glGetQueryObjectuivARB(GL_QUERY_RESULT)");
 593             TRACE("Returning timestamp %s.\n", wine_dbgstr_longlong(timestamp));
 594             fill_query_data(data, size, &timestamp, sizeof(timestamp));
 595         }
 596         res = S_OK;
 597     }
 598     else
 599     {
 600         res = S_FALSE;
 601     }
 602
 603     context_release(context);
 604
 605     return res;
 606 }
 607
 608 static HRESULT wined3d_timestamp_query_ops_issue(struct wined3d_query *query, DWORD flags)
 609 {
 610     struct wined3d_device *device = query->device;
 611     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 612
 613     TRACE("query %p, flags %#x.\n", query, flags);
 614
 615     if (gl_info->supported[ARB_TIMER_QUERY])
 616     {
 617         struct wined3d_timestamp_query *tq = query->extendedData;
 618         struct wined3d_context *context;
 619
 620         if (flags & WINED3DISSUE_BEGIN)
 621         {
 622             WARN("Ignoring WINED3DISSUE_BEGIN with a TIMESTAMP query.\n");
 623         }
 624         if (flags & WINED3DISSUE_END)
 625         {
 626             if (tq->context)
 627                 context_free_timestamp_query(tq);
 628             context = context_acquire(query->device, NULL);
 629             context_alloc_timestamp_query(context, tq);
 630             GL_EXTCALL(glQueryCounter(tq->id, GL_TIMESTAMP));
 631             checkGLcall("glQueryCounter()");
 632             context_release(context);
 633         }
 634     }
 635     else
 636     {
 637         ERR("Timestamp queries not supported.\n");
 638     }
 639
 640     if (flags & WINED3DISSUE_END)
 641         query->state = QUERY_SIGNALLED;
 642
 643     return WINED3D_OK;
 644 }
 645
 646 static HRESULT wined3d_timestamp_disjoint_query_ops_get_data(struct wined3d_query *query,
 647         void *data, DWORD size, DWORD flags)
 648 {
 649     TRACE("query %p, data %p, size %#x, flags %#x.\n", query, data, size, flags);
 650
 651     if (query->type == WINED3D_QUERY_TYPE_TIMESTAMP_DISJOINT)
 652     {
 653         static const struct wined3d_query_data_timestamp_disjoint disjoint_data = {FALSE, 1000 * 1000 * 1000};
 654
 655         if (query->state == QUERY_BUILDING)
 656         {
 657             TRACE("Query is building, returning S_FALSE.\n");
 658             return S_FALSE;
 659         }
 660
 661         fill_query_data(data, size, &disjoint_data, sizeof(disjoint_data));
 662     }
 663     else
 664     {
 665         static const UINT64 freq = 1000 * 1000 * 1000;
 666
 667         fill_query_data(data, size, &freq, sizeof(freq));
 668     }
 669     return S_OK;
 670 }
 671
 672 static HRESULT wined3d_timestamp_disjoint_query_ops_issue(struct wined3d_query *query, DWORD flags)
 673 {
 674     TRACE("query %p, flags %#x.\n", query, flags);
 675
 676     if (flags & WINED3DISSUE_BEGIN)
 677         query->state = QUERY_BUILDING;
 678     if (flags & WINED3DISSUE_END)
 679         query->state = QUERY_SIGNALLED;
 680
 681     return WINED3D_OK;
 682 }
 683
 684 static const struct wined3d_query_ops event_query_ops =
 685 {
 686     wined3d_event_query_ops_get_data,
 687     wined3d_event_query_ops_issue,
 688 };
 689
 690 static const struct wined3d_query_ops occlusion_query_ops =
 691 {
 692     wined3d_occlusion_query_ops_get_data,
 693     wined3d_occlusion_query_ops_issue,
 694 };
 695
 696 static const struct wined3d_query_ops timestamp_query_ops =
 697 {
 698     wined3d_timestamp_query_ops_get_data,
 699     wined3d_timestamp_query_ops_issue,
 700 };
 701
 702 static const struct wined3d_query_ops timestamp_disjoint_query_ops =
 703 {
 704     wined3d_timestamp_disjoint_query_ops_get_data,
 705     wined3d_timestamp_disjoint_query_ops_issue,
 706 };
 707
 708 static HRESULT query_init(struct wined3d_query *query, struct wined3d_device *device,
 709         enum wined3d_query_type type, void *parent)
 710 {
 711     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 712
 713     query->parent = parent;
 714
 715     switch (type)
 716     {
 717         case WINED3D_QUERY_TYPE_OCCLUSION:
 718             TRACE("Occlusion query.\n");
 719             if (!gl_info->supported[ARB_OCCLUSION_QUERY])
 720             {
 721                 WARN("Unsupported in local OpenGL implementation: ARB_OCCLUSION_QUERY.\n");
 722                 return WINED3DERR_NOTAVAILABLE;
 723             }
 724             query->query_ops = &occlusion_query_ops;
 725             query->data_size = sizeof(DWORD);
 726             query->extendedData = HeapAlloc(GetProcessHeap(), 0, sizeof(struct wined3d_occlusion_query));
 727             if (!query->extendedData)
 728             {
 729                 ERR("Failed to allocate occlusion query extended data.\n");
 730                 return E_OUTOFMEMORY;
 731             }
 732             ((struct wined3d_occlusion_query *)query->extendedData)->context = NULL;
 733             break;
 734
 735         case WINED3D_QUERY_TYPE_EVENT:
 736             TRACE("Event query.\n");
 737             if (!wined3d_event_query_supported(gl_info))
 738             {
 739                 /* Half-Life 2 needs this query. It does not render the main
 740                  * menu correctly otherwise. Pretend to support it, faking
 741                  * this query does not do much harm except potentially
 742                  * lowering performance. */
 743                 FIXME("Event query: Unimplemented, but pretending to be supported.\n");
 744             }
 745             query->query_ops = &event_query_ops;
 746             query->data_size = sizeof(BOOL);
 747             query->extendedData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct wined3d_event_query));
 748             if (!query->extendedData)
 749             {
 750                 ERR("Failed to allocate event query memory.\n");
 751                 return E_OUTOFMEMORY;
 752             }
 753             break;
 754
 755         case WINED3D_QUERY_TYPE_TIMESTAMP:
 756             TRACE("Timestamp query.\n");
 757             if (!gl_info->supported[ARB_TIMER_QUERY])
 758             {
 759                 WARN("Unsupported in local OpenGL implementation: ARB_TIMER_QUERY.\n");
 760                 return WINED3DERR_NOTAVAILABLE;
 761             }
 762             query->query_ops = &timestamp_query_ops;
 763             query->data_size = sizeof(UINT64);
 764             query->extendedData = HeapAlloc(GetProcessHeap(), 0, sizeof(struct wined3d_timestamp_query));
 765             if (!query->extendedData)
 766             {
 767                 ERR("Failed to allocate timestamp query extended data.\n");
 768                 return E_OUTOFMEMORY;
 769             }
 770             ((struct wined3d_timestamp_query *)query->extendedData)->context = NULL;
 771             break;
 772
 773         case WINED3D_QUERY_TYPE_TIMESTAMP_DISJOINT:
 774         case WINED3D_QUERY_TYPE_TIMESTAMP_FREQ:
 775             TRACE("TIMESTAMP_DISJOINT query.\n");
 776             if (!gl_info->supported[ARB_TIMER_QUERY])
 777             {
 778                 WARN("Unsupported in local OpenGL implementation: ARB_TIMER_QUERY.\n");
 779                 return WINED3DERR_NOTAVAILABLE;
 780             }
 781             query->query_ops = &timestamp_disjoint_query_ops;
 782             query->data_size = type == WINED3D_QUERY_TYPE_TIMESTAMP_DISJOINT
 783                     ? sizeof(struct wined3d_query_data_timestamp_disjoint) : sizeof(UINT64);
 784             query->extendedData = NULL;
 785             break;
 786
 787         case WINED3D_QUERY_TYPE_VCACHE:
 788         case WINED3D_QUERY_TYPE_RESOURCE_MANAGER:
 789         case WINED3D_QUERY_TYPE_VERTEX_STATS:
 790         case WINED3D_QUERY_TYPE_PIPELINE_TIMINGS:
 791         case WINED3D_QUERY_TYPE_INTERFACE_TIMINGS:
 792         case WINED3D_QUERY_TYPE_VERTEX_TIMINGS:
 793         case WINED3D_QUERY_TYPE_PIXEL_TIMINGS:
 794         case WINED3D_QUERY_TYPE_BANDWIDTH_TIMINGS:
 795         case WINED3D_QUERY_TYPE_CACHE_UTILIZATION:
 796         default:
 797             FIXME("Unhandled query type %#x.\n", type);
 798             return WINED3DERR_NOTAVAILABLE;
 799     }
 800
 801     query->type = type;
 802     query->state = QUERY_CREATED;
 803     query->device = device;
 804     query->ref = 1;
 805
 806     return WINED3D_OK;
 807 }
 808
 809 HRESULT CDECL wined3d_query_create(struct wined3d_device *device,
 810         enum wined3d_query_type type, void *parent, struct wined3d_query **query)
 811 {
 812     struct wined3d_query *object;
 813     HRESULT hr;
 814
 815     TRACE("device %p, type %#x, query %p.\n", device, type, query);
 816
 817     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 818     if (!object)
 819         return E_OUTOFMEMORY;
 820
 821     if (FAILED(hr = query_init(object, device, type, parent)))
 822     {
 823         WARN("Failed to initialize query, hr %#x.\n", hr);
 824         HeapFree(GetProcessHeap(), 0, object);
 825         return hr;
 826     }
 827
 828     TRACE("Created query %p.\n", object);
 829     *query = object;
 830
 831     return WINED3D_OK;
 832 }