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 enum wined3d_query_type CDECL wined3d_query_get_type(const struct wined3d_query *query)
 425 {
 426     TRACE("query %p.\n", query);
 427
 428     return query->type;
 429 }
 430
 431 static HRESULT wined3d_event_query_ops_issue(struct wined3d_query *query, DWORD flags)
 432 {
 433     TRACE("query %p, flags %#x.\n", query, flags);
 434
 435     TRACE("(%p) : flags %#x, type D3DQUERY_EVENT\n", query, flags);
 436     if (flags & WINED3DISSUE_END)
 437     {
 438         struct wined3d_event_query *event_query = query->extendedData;
 439
 440         /* Faked event query support */
 441         if (!event_query) return WINED3D_OK;
 442
 443         wined3d_event_query_issue(event_query, query->device);
 444     }
 445     else if (flags & WINED3DISSUE_BEGIN)
 446     {
 447         /* Started implicitly at device creation */
 448         ERR("Event query issued with START flag - what to do?\n");
 449     }
 450
 451     if (flags & WINED3DISSUE_BEGIN)
 452         query->state = QUERY_BUILDING;
 453     else
 454         query->state = QUERY_SIGNALLED;
 455
 456     return WINED3D_OK;
 457 }
 458
 459 static HRESULT wined3d_occlusion_query_ops_issue(struct wined3d_query *query, DWORD flags)
 460 {
 461     struct wined3d_device *device = query->device;
 462     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 463
 464     TRACE("query %p, flags %#x.\n", query, flags);
 465
 466     if (gl_info->supported[ARB_OCCLUSION_QUERY])
 467     {
 468         struct wined3d_occlusion_query *oq = query->extendedData;
 469         struct wined3d_context *context;
 470
 471         /* This is allowed according to msdn and our tests. Reset the query and restart */
 472         if (flags & WINED3DISSUE_BEGIN)
 473         {
 474             if (query->state == QUERY_BUILDING)
 475             {
 476                 if (oq->context->tid != GetCurrentThreadId())
 477                 {
 478                     FIXME("Wrong thread, can't restart query.\n");
 479
 480                     context_free_occlusion_query(oq);
 481                     context = context_acquire(query->device, NULL);
 482                     context_alloc_occlusion_query(context, oq);
 483                 }
 484                 else
 485                 {
 486                     context = context_acquire(query->device, oq->context->current_rt);
 487
 488                     GL_EXTCALL(glEndQueryARB(GL_SAMPLES_PASSED_ARB));
 489                     checkGLcall("glEndQuery()");
 490                 }
 491             }
 492             else
 493             {
 494                 if (oq->context) context_free_occlusion_query(oq);
 495                 context = context_acquire(query->device, NULL);
 496                 context_alloc_occlusion_query(context, oq);
 497             }
 498
 499             GL_EXTCALL(glBeginQueryARB(GL_SAMPLES_PASSED_ARB, oq->id));
 500             checkGLcall("glBeginQuery()");
 501
 502             context_release(context);
 503         }
 504         if (flags & WINED3DISSUE_END)
 505         {
 506             /* Msdn says _END on a non-building occlusion query returns an error, but
 507              * our tests show that it returns OK. But OpenGL doesn't like it, so avoid
 508              * generating an error
 509              */
 510             if (query->state == QUERY_BUILDING)
 511             {
 512                 if (oq->context->tid != GetCurrentThreadId())
 513                 {
 514                     FIXME("Wrong thread, can't end query.\n");
 515                 }
 516                 else
 517                 {
 518                     context = context_acquire(query->device, oq->context->current_rt);
 519
 520                     GL_EXTCALL(glEndQueryARB(GL_SAMPLES_PASSED_ARB));
 521                     checkGLcall("glEndQuery()");
 522
 523                     context_release(context);
 524                 }
 525             }
 526         }
 527     }
 528     else
 529     {
 530         FIXME("%p Occlusion queries not supported.\n", query);
 531     }
 532
 533     if (flags & WINED3DISSUE_BEGIN)
 534         query->state = QUERY_BUILDING;
 535     else
 536         query->state = QUERY_SIGNALLED;
 537
 538     return WINED3D_OK; /* can be WINED3DERR_INVALIDCALL.    */
 539 }
 540
 541 static HRESULT wined3d_timestamp_query_ops_get_data(struct wined3d_query *query,
 542         void *data, DWORD size, DWORD flags)
 543 {
 544     struct wined3d_timestamp_query *tq = query->extendedData;
 545     struct wined3d_device *device = query->device;
 546     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 547     struct wined3d_context *context;
 548     GLuint available;
 549     GLuint64 timestamp;
 550     HRESULT res;
 551
 552     TRACE("query %p, data %p, size %#x, flags %#x.\n", query, data, size, flags);
 553
 554     if (!tq->context)
 555         query->state = QUERY_CREATED;
 556
 557     if (query->state == QUERY_CREATED)
 558     {
 559         /* D3D allows GetData on a new query, OpenGL doesn't. So just invent the data ourselves. */
 560         TRACE("Query wasn't yet started, returning S_OK.\n");
 561         timestamp = 0;
 562         fill_query_data(data, size, &timestamp, sizeof(timestamp));
 563         return S_OK;
 564     }
 565
 566     if (tq->context->tid != GetCurrentThreadId())
 567     {
 568         FIXME("%p Wrong thread, returning 1.\n", query);
 569         timestamp = 1;
 570         fill_query_data(data, size, &timestamp, sizeof(timestamp));
 571         return S_OK;
 572     }
 573
 574     context = context_acquire(query->device, tq->context->current_rt);
 575
 576     GL_EXTCALL(glGetQueryObjectuivARB(tq->id, GL_QUERY_RESULT_AVAILABLE_ARB, &available));
 577     checkGLcall("glGetQueryObjectuivARB(GL_QUERY_RESULT_AVAILABLE)");
 578     TRACE("available %#x.\n", available);
 579
 580     if (available)
 581     {
 582         if (size)
 583         {
 584             GL_EXTCALL(glGetQueryObjectui64v(tq->id, GL_QUERY_RESULT_ARB, &timestamp));
 585             checkGLcall("glGetQueryObjectuivARB(GL_QUERY_RESULT)");
 586             TRACE("Returning timestamp %s.\n", wine_dbgstr_longlong(timestamp));
 587             fill_query_data(data, size, &timestamp, sizeof(timestamp));
 588         }
 589         res = S_OK;
 590     }
 591     else
 592     {
 593         res = S_FALSE;
 594     }
 595
 596     context_release(context);
 597
 598     return res;
 599 }
 600
 601 static HRESULT wined3d_timestamp_query_ops_issue(struct wined3d_query *query, DWORD flags)
 602 {
 603     struct wined3d_device *device = query->device;
 604     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 605
 606     TRACE("query %p, flags %#x.\n", query, flags);
 607
 608     if (gl_info->supported[ARB_TIMER_QUERY])
 609     {
 610         struct wined3d_timestamp_query *tq = query->extendedData;
 611         struct wined3d_context *context;
 612
 613         if (flags & WINED3DISSUE_BEGIN)
 614         {
 615             WARN("Ignoring WINED3DISSUE_BEGIN with a TIMESTAMP query.\n");
 616         }
 617         if (flags & WINED3DISSUE_END)
 618         {
 619             if (tq->context)
 620                 context_free_timestamp_query(tq);
 621             context = context_acquire(query->device, NULL);
 622             context_alloc_timestamp_query(context, tq);
 623             GL_EXTCALL(glQueryCounter(tq->id, GL_TIMESTAMP));
 624             checkGLcall("glQueryCounter()");
 625             context_release(context);
 626         }
 627     }
 628     else
 629     {
 630         ERR("Timestamp queries not supported.\n");
 631     }
 632
 633     if (flags & WINED3DISSUE_END)
 634         query->state = QUERY_SIGNALLED;
 635
 636     return WINED3D_OK;
 637 }
 638
 639 static HRESULT wined3d_timestamp_disjoint_query_ops_get_data(struct wined3d_query *query,
 640         void *data, DWORD size, DWORD flags)
 641 {
 642     TRACE("query %p, data %p, size %#x, flags %#x.\n", query, data, size, flags);
 643
 644     if (query->type == WINED3D_QUERY_TYPE_TIMESTAMP_DISJOINT)
 645     {
 646         static const struct wined3d_query_data_timestamp_disjoint disjoint_data = {FALSE, 1000 * 1000 * 1000};
 647
 648         if (query->state == QUERY_BUILDING)
 649         {
 650             TRACE("Query is building, returning S_FALSE.\n");
 651             return S_FALSE;
 652         }
 653
 654         fill_query_data(data, size, &disjoint_data, sizeof(disjoint_data));
 655     }
 656     else
 657     {
 658         static const UINT64 freq = 1000 * 1000 * 1000;
 659
 660         fill_query_data(data, size, &freq, sizeof(freq));
 661     }
 662     return S_OK;
 663 }
 664
 665 static HRESULT wined3d_timestamp_disjoint_query_ops_issue(struct wined3d_query *query, DWORD flags)
 666 {
 667     TRACE("query %p, flags %#x.\n", query, flags);
 668
 669     if (flags & WINED3DISSUE_BEGIN)
 670         query->state = QUERY_BUILDING;
 671     if (flags & WINED3DISSUE_END)
 672         query->state = QUERY_SIGNALLED;
 673
 674     return WINED3D_OK;
 675 }
 676
 677 static const struct wined3d_query_ops event_query_ops =
 678 {
 679     wined3d_event_query_ops_get_data,
 680     wined3d_event_query_ops_issue,
 681 };
 682
 683 static const struct wined3d_query_ops occlusion_query_ops =
 684 {
 685     wined3d_occlusion_query_ops_get_data,
 686     wined3d_occlusion_query_ops_issue,
 687 };
 688
 689 static const struct wined3d_query_ops timestamp_query_ops =
 690 {
 691     wined3d_timestamp_query_ops_get_data,
 692     wined3d_timestamp_query_ops_issue,
 693 };
 694
 695 static const struct wined3d_query_ops timestamp_disjoint_query_ops =
 696 {
 697     wined3d_timestamp_disjoint_query_ops_get_data,
 698     wined3d_timestamp_disjoint_query_ops_issue,
 699 };
 700
 701 static HRESULT query_init(struct wined3d_query *query, struct wined3d_device *device, enum wined3d_query_type type)
 702 {
 703     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 704
 705     switch (type)
 706     {
 707         case WINED3D_QUERY_TYPE_OCCLUSION:
 708             TRACE("Occlusion query.\n");
 709             if (!gl_info->supported[ARB_OCCLUSION_QUERY])
 710             {
 711                 WARN("Unsupported in local OpenGL implementation: ARB_OCCLUSION_QUERY.\n");
 712                 return WINED3DERR_NOTAVAILABLE;
 713             }
 714             query->query_ops = &occlusion_query_ops;
 715             query->data_size = sizeof(DWORD);
 716             query->extendedData = HeapAlloc(GetProcessHeap(), 0, sizeof(struct wined3d_occlusion_query));
 717             if (!query->extendedData)
 718             {
 719                 ERR("Failed to allocate occlusion query extended data.\n");
 720                 return E_OUTOFMEMORY;
 721             }
 722             ((struct wined3d_occlusion_query *)query->extendedData)->context = NULL;
 723             break;
 724
 725         case WINED3D_QUERY_TYPE_EVENT:
 726             TRACE("Event query.\n");
 727             if (!wined3d_event_query_supported(gl_info))
 728             {
 729                 /* Half-Life 2 needs this query. It does not render the main
 730                  * menu correctly otherwise. Pretend to support it, faking
 731                  * this query does not do much harm except potentially
 732                  * lowering performance. */
 733                 FIXME("Event query: Unimplemented, but pretending to be supported.\n");
 734             }
 735             query->query_ops = &event_query_ops;
 736             query->data_size = sizeof(BOOL);
 737             query->extendedData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct wined3d_event_query));
 738             if (!query->extendedData)
 739             {
 740                 ERR("Failed to allocate event query memory.\n");
 741                 return E_OUTOFMEMORY;
 742             }
 743             break;
 744
 745         case WINED3D_QUERY_TYPE_TIMESTAMP:
 746             TRACE("Timestamp query.\n");
 747             if (!gl_info->supported[ARB_TIMER_QUERY])
 748             {
 749                 WARN("Unsupported in local OpenGL implementation: ARB_TIMER_QUERY.\n");
 750                 return WINED3DERR_NOTAVAILABLE;
 751             }
 752             query->query_ops = &timestamp_query_ops;
 753             query->data_size = sizeof(UINT64);
 754             query->extendedData = HeapAlloc(GetProcessHeap(), 0, sizeof(struct wined3d_timestamp_query));
 755             if (!query->extendedData)
 756             {
 757                 ERR("Failed to allocate timestamp query extended data.\n");
 758                 return E_OUTOFMEMORY;
 759             }
 760             ((struct wined3d_timestamp_query *)query->extendedData)->context = NULL;
 761             break;
 762
 763         case WINED3D_QUERY_TYPE_TIMESTAMP_DISJOINT:
 764         case WINED3D_QUERY_TYPE_TIMESTAMP_FREQ:
 765             TRACE("TIMESTAMP_DISJOINT query.\n");
 766             if (!gl_info->supported[ARB_TIMER_QUERY])
 767             {
 768                 WARN("Unsupported in local OpenGL implementation: ARB_TIMER_QUERY.\n");
 769                 return WINED3DERR_NOTAVAILABLE;
 770             }
 771             query->query_ops = &timestamp_disjoint_query_ops;
 772             query->data_size = type == WINED3D_QUERY_TYPE_TIMESTAMP_DISJOINT
 773                     ? sizeof(struct wined3d_query_data_timestamp_disjoint) : sizeof(UINT64);
 774             query->extendedData = NULL;
 775             break;
 776
 777         case WINED3D_QUERY_TYPE_VCACHE:
 778         case WINED3D_QUERY_TYPE_RESOURCE_MANAGER:
 779         case WINED3D_QUERY_TYPE_VERTEX_STATS:
 780         case WINED3D_QUERY_TYPE_PIPELINE_TIMINGS:
 781         case WINED3D_QUERY_TYPE_INTERFACE_TIMINGS:
 782         case WINED3D_QUERY_TYPE_VERTEX_TIMINGS:
 783         case WINED3D_QUERY_TYPE_PIXEL_TIMINGS:
 784         case WINED3D_QUERY_TYPE_BANDWIDTH_TIMINGS:
 785         case WINED3D_QUERY_TYPE_CACHE_UTILIZATION:
 786         default:
 787             FIXME("Unhandled query type %#x.\n", type);
 788             return WINED3DERR_NOTAVAILABLE;
 789     }
 790
 791     query->type = type;
 792     query->state = QUERY_CREATED;
 793     query->device = device;
 794     query->ref = 1;
 795
 796     return WINED3D_OK;
 797 }
 798
 799 HRESULT CDECL wined3d_query_create(struct wined3d_device *device,
 800         enum wined3d_query_type type, struct wined3d_query **query)
 801 {
 802     struct wined3d_query *object;
 803     HRESULT hr;
 804
 805     TRACE("device %p, type %#x, query %p.\n", device, type, query);
 806
 807     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 808     if (!object)
 809         return E_OUTOFMEMORY;
 810
 811     hr = query_init(object, device, type);
 812     if (FAILED(hr))
 813     {
 814         WARN("Failed to initialize query, hr %#x.\n", hr);
 815         HeapFree(GetProcessHeap(), 0, object);
 816         return hr;
 817     }
 818
 819     TRACE("Created query %p.\n", object);
 820     *query = object;
 821
 822     return WINED3D_OK;
 823 }