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 static void wined3d_query_buffer_invalidate(struct wined3d_query *query)
  29 {
  30     /* map[0] != map[1]: exact values do not have any significance. */
  31     query->map_ptr[0] = 0;
  32     query->map_ptr[1] = ~(UINT64)0;
  33 }
  34
  35 static BOOL wined3d_query_buffer_is_valid(struct wined3d_query *query)
  36 {
  37     return query->map_ptr[0] == query->map_ptr[1];
  38 }
  39
  40 static void wined3d_query_create_buffer_object(struct wined3d_context_gl *context_gl, struct wined3d_query *query)
  41 {
  42     const GLuint map_flags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT;
  43     const struct wined3d_gl_info *gl_info = context_gl->gl_info;
  44     GLuint buffer_object;
  45
  46     GL_EXTCALL(glGenBuffers(1, &buffer_object));
  47     GL_EXTCALL(glBindBuffer(GL_QUERY_BUFFER, buffer_object));
  48     GL_EXTCALL(glBufferStorage(GL_QUERY_BUFFER, sizeof(query->map_ptr[0]) * 2, NULL, map_flags));
  49     query->map_ptr = GL_EXTCALL(glMapBufferRange(GL_QUERY_BUFFER, 0, sizeof(query->map_ptr[0]) * 2, map_flags));
  50     GL_EXTCALL(glBindBuffer(GL_QUERY_BUFFER, 0));
  51     checkGLcall("query buffer object creation");
  52
  53     wined3d_query_buffer_invalidate(query);
  54     query->buffer_object = buffer_object;
  55 }
  56
  57 void wined3d_query_gl_destroy_buffer_object(struct wined3d_context_gl *context_gl, struct wined3d_query *query)
  58 {
  59     const struct wined3d_gl_info *gl_info = context_gl->gl_info;
  60
  61     GL_EXTCALL(glDeleteBuffers(1, &query->buffer_object));
  62     checkGLcall("query buffer object destruction");
  63
  64     query->buffer_object = 0;
  65     query->map_ptr = NULL;
  66 }
  67
  68 /* From ARB_occlusion_query: "Querying the state for a given occlusion query
  69  * forces that occlusion query to complete within a finite amount of time."
  70  * In practice, that means drivers flush when retrieving
  71  * GL_QUERY_RESULT_AVAILABLE, which can be undesirable when applications use a
  72  * significant number of queries. Using a persistently mapped query buffer
  73  * object allows us to avoid these implicit flushes. An additional benefit is
  74  * that it allows us to poll the query status from the application-thread
  75  * instead of from the csmt-thread. */
  76 static BOOL wined3d_query_buffer_queue_result(struct wined3d_context_gl *context_gl,
  77         struct wined3d_query *query, GLuint id)
  78 {
  79     const struct wined3d_gl_info *gl_info = context_gl->gl_info;
  80     GLsync tmp_sync;
  81
  82     if (!gl_info->supported[ARB_QUERY_BUFFER_OBJECT] || !gl_info->supported[ARB_BUFFER_STORAGE])
  83         return FALSE;
  84     /* Don't use query buffers without CSMT, mainly for simplicity. */
  85     if (!context_gl->c.device->cs->thread)
  86         return FALSE;
  87
  88     if (query->buffer_object)
  89     {
  90         /* If there's still a query result in-flight for the existing buffer
  91          * object (i.e., the query was restarted before we received its
  92          * result), we can't reuse the existing buffer object. */
  93         if (wined3d_query_buffer_is_valid(query))
  94             wined3d_query_buffer_invalidate(query);
  95         else
  96             wined3d_query_gl_destroy_buffer_object(context_gl, query);
  97     }
  98
  99     if (!query->buffer_object)
 100         wined3d_query_create_buffer_object(context_gl, query);
 101
 102     GL_EXTCALL(glBindBuffer(GL_QUERY_BUFFER, query->buffer_object));
 103     /* Read the same value twice. We know we have the result if map_ptr[0] == map_ptr[1]. */
 104     GL_EXTCALL(glGetQueryObjectui64v(id, GL_QUERY_RESULT, (void *)0));
 105     GL_EXTCALL(glGetQueryObjectui64v(id, GL_QUERY_RESULT, (void *)sizeof(query->map_ptr[0])));
 106     GL_EXTCALL(glBindBuffer(GL_QUERY_BUFFER, 0));
 107     checkGLcall("queue query result");
 108
 109     /* ARB_buffer_storage requires the client to call FenceSync with
 110      * SYNC_GPU_COMMANDS_COMPLETE after the server does a write. This behavior
 111      * is not enforced by Mesa.
 112      */
 113     tmp_sync = GL_EXTCALL(glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0));
 114     GL_EXTCALL(glDeleteSync(tmp_sync));
 115     checkGLcall("query buffer sync");
 116
 117     return TRUE;
 118 }
 119
 120 static UINT64 get_query_result64(GLuint id, const struct wined3d_gl_info *gl_info)
 121 {
 122     if (gl_info->supported[ARB_TIMER_QUERY])
 123     {
 124         GLuint64 result;
 125         GL_EXTCALL(glGetQueryObjectui64v(id, GL_QUERY_RESULT, &result));
 126         return result;
 127     }
 128     else
 129     {
 130         GLuint result;
 131         GL_EXTCALL(glGetQueryObjectuiv(id, GL_QUERY_RESULT, &result));
 132         return result;
 133     }
 134 }
 135
 136 static void wined3d_query_init(struct wined3d_query *query, struct wined3d_device *device,
 137         enum wined3d_query_type type, const void *data, DWORD data_size,
 138         const struct wined3d_query_ops *query_ops, void *parent, const struct wined3d_parent_ops *parent_ops)
 139 {
 140     query->ref = 1;
 141     query->parent = parent;
 142     query->parent_ops = parent_ops;
 143     query->device = device;
 144     query->state = QUERY_CREATED;
 145     query->type = type;
 146     query->data = data;
 147     query->data_size = data_size;
 148     query->query_ops = query_ops;
 149     list_init(&query->poll_list_entry);
 150 }
 151
 152 static struct wined3d_event_query *wined3d_event_query_from_query(struct wined3d_query *query)
 153 {
 154     return CONTAINING_RECORD(query, struct wined3d_event_query, query);
 155 }
 156
 157 static struct wined3d_occlusion_query *wined3d_occlusion_query_from_query(struct wined3d_query *query)
 158 {
 159     return CONTAINING_RECORD(query, struct wined3d_occlusion_query, query);
 160 }
 161
 162 static struct wined3d_timestamp_query *wined3d_timestamp_query_from_query(struct wined3d_query *query)
 163 {
 164     return CONTAINING_RECORD(query, struct wined3d_timestamp_query, query);
 165 }
 166
 167 static struct wined3d_so_statistics_query *wined3d_so_statistics_query_from_query(struct wined3d_query *query)
 168 {
 169     return CONTAINING_RECORD(query, struct wined3d_so_statistics_query, query);
 170 }
 171
 172 static struct wined3d_pipeline_statistics_query *wined3d_pipeline_statistics_query_from_query(
 173         struct wined3d_query *query)
 174 {
 175     return CONTAINING_RECORD(query, struct wined3d_pipeline_statistics_query, query);
 176 }
 177
 178 static BOOL wined3d_fence_supported(const struct wined3d_gl_info *gl_info)
 179 {
 180     return gl_info->supported[ARB_SYNC] || gl_info->supported[NV_FENCE] || gl_info->supported[APPLE_FENCE];
 181 }
 182
 183 static enum wined3d_fence_result wined3d_fence_test(const struct wined3d_fence *fence,
 184         struct wined3d_device *device, DWORD flags)
 185 {
 186     const struct wined3d_gl_info *gl_info;
 187     struct wined3d_context_gl *context_gl;
 188     enum wined3d_fence_result ret;
 189     BOOL fence_result;
 190
 191     TRACE("fence %p, device %p, flags %#x.\n", fence, device, flags);
 192
 193     if (!fence->context_gl)
 194     {
 195         TRACE("Fence not issued.\n");
 196         return WINED3D_FENCE_NOT_STARTED;
 197     }
 198
 199     if (!(context_gl = wined3d_context_gl_reacquire(fence->context_gl)))
 200     {
 201         if (!fence->context_gl->gl_info->supported[ARB_SYNC])
 202         {
 203             WARN("Fence tested from wrong thread.\n");
 204             return WINED3D_FENCE_WRONG_THREAD;
 205         }
 206         context_gl = wined3d_context_gl(context_acquire(device, NULL, 0));
 207     }
 208     gl_info = context_gl->gl_info;
 209
 210     if (gl_info->supported[ARB_SYNC])
 211     {
 212         GLenum gl_ret = GL_EXTCALL(glClientWaitSync(fence->object.sync,
 213                 (flags & WINED3DGETDATA_FLUSH) ? GL_SYNC_FLUSH_COMMANDS_BIT : 0, 0));
 214         checkGLcall("glClientWaitSync");
 215
 216         switch (gl_ret)
 217         {
 218             case GL_ALREADY_SIGNALED:
 219             case GL_CONDITION_SATISFIED:
 220                 ret = WINED3D_FENCE_OK;
 221                 break;
 222
 223             case GL_TIMEOUT_EXPIRED:
 224                 ret = WINED3D_FENCE_WAITING;
 225                 break;
 226
 227             case GL_WAIT_FAILED:
 228             default:
 229                 ERR("glClientWaitSync returned %#x.\n", gl_ret);
 230                 ret = WINED3D_FENCE_ERROR;
 231         }
 232     }
 233     else if (gl_info->supported[APPLE_FENCE])
 234     {
 235         fence_result = GL_EXTCALL(glTestFenceAPPLE(fence->object.id));
 236         checkGLcall("glTestFenceAPPLE");
 237         if (fence_result)
 238             ret = WINED3D_FENCE_OK;
 239         else
 240             ret = WINED3D_FENCE_WAITING;
 241     }
 242     else if (gl_info->supported[NV_FENCE])
 243     {
 244         fence_result = GL_EXTCALL(glTestFenceNV(fence->object.id));
 245         checkGLcall("glTestFenceNV");
 246         if (fence_result)
 247             ret = WINED3D_FENCE_OK;
 248         else
 249             ret = WINED3D_FENCE_WAITING;
 250     }
 251     else
 252     {
 253         ERR("Fence created despite lack of GL support.\n");
 254         ret = WINED3D_FENCE_ERROR;
 255     }
 256
 257     context_release(&context_gl->c);
 258     return ret;
 259 }
 260
 261 enum wined3d_fence_result wined3d_fence_wait(const struct wined3d_fence *fence,
 262         struct wined3d_device *device)
 263 {
 264     const struct wined3d_gl_info *gl_info;
 265     struct wined3d_context_gl *context_gl;
 266     enum wined3d_fence_result ret;
 267
 268     TRACE("fence %p, device %p.\n", fence, device);
 269
 270     if (!fence->context_gl)
 271     {
 272         TRACE("Fence not issued.\n");
 273         return WINED3D_FENCE_NOT_STARTED;
 274     }
 275     gl_info = fence->context_gl->gl_info;
 276
 277     if (!(context_gl = wined3d_context_gl_reacquire(fence->context_gl)))
 278     {
 279         /* A glFinish does not reliably wait for draws in other contexts. The caller has
 280          * to find its own way to cope with the thread switch
 281          */
 282         if (!gl_info->supported[ARB_SYNC])
 283         {
 284             WARN("Fence finished from wrong thread.\n");
 285             return WINED3D_FENCE_WRONG_THREAD;
 286         }
 287         context_gl = wined3d_context_gl(context_acquire(device, NULL, 0));
 288     }
 289     gl_info = context_gl->gl_info;
 290
 291     if (gl_info->supported[ARB_SYNC])
 292     {
 293         /* Timeouts near 0xffffffffffffffff may immediately return GL_TIMEOUT_EXPIRED,
 294          * possibly because macOS internally adds some slop to the timer. To avoid this,
 295          * we use a large number that isn't near the point of overflow (macOS 10.12.5).
 296          */
 297         GLenum gl_ret = GL_EXTCALL(glClientWaitSync(fence->object.sync,
 298                 GL_SYNC_FLUSH_COMMANDS_BIT, ~(GLuint64)0 >> 1));
 299         checkGLcall("glClientWaitSync");
 300
 301         switch (gl_ret)
 302         {
 303             case GL_ALREADY_SIGNALED:
 304             case GL_CONDITION_SATISFIED:
 305                 ret = WINED3D_FENCE_OK;
 306                 break;
 307
 308                 /* We don't expect a timeout for a ~292 year wait */
 309             default:
 310                 ERR("glClientWaitSync returned %#x.\n", gl_ret);
 311                 ret = WINED3D_FENCE_ERROR;
 312         }
 313     }
 314     else if (gl_info->supported[APPLE_FENCE])
 315     {
 316         GL_EXTCALL(glFinishFenceAPPLE(fence->object.id));
 317         checkGLcall("glFinishFenceAPPLE");
 318         ret = WINED3D_FENCE_OK;
 319     }
 320     else if (gl_info->supported[NV_FENCE])
 321     {
 322         GL_EXTCALL(glFinishFenceNV(fence->object.id));
 323         checkGLcall("glFinishFenceNV");
 324         ret = WINED3D_FENCE_OK;
 325     }
 326     else
 327     {
 328         ERR("Fence created without GL support.\n");
 329         ret = WINED3D_FENCE_ERROR;
 330     }
 331
 332     context_release(&context_gl->c);
 333     return ret;
 334 }
 335
 336 void wined3d_fence_issue(struct wined3d_fence *fence, struct wined3d_device *device)
 337 {
 338     struct wined3d_context_gl *context_gl = NULL;
 339     const struct wined3d_gl_info *gl_info;
 340
 341     if (fence->context_gl && !(context_gl = wined3d_context_gl_reacquire(fence->context_gl))
 342             && !fence->context_gl->gl_info->supported[ARB_SYNC])
 343         wined3d_context_gl_free_fence(fence);
 344     if (!context_gl)
 345         context_gl = wined3d_context_gl(context_acquire(device, NULL, 0));
 346     gl_info = context_gl->gl_info;
 347     if (!fence->context_gl)
 348         wined3d_context_gl_alloc_fence(context_gl, fence);
 349
 350     if (gl_info->supported[ARB_SYNC])
 351     {
 352         if (fence->object.sync)
 353             GL_EXTCALL(glDeleteSync(fence->object.sync));
 354         checkGLcall("glDeleteSync");
 355         fence->object.sync = GL_EXTCALL(glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0));
 356         checkGLcall("glFenceSync");
 357     }
 358     else if (gl_info->supported[APPLE_FENCE])
 359     {
 360         GL_EXTCALL(glSetFenceAPPLE(fence->object.id));
 361         checkGLcall("glSetFenceAPPLE");
 362     }
 363     else if (gl_info->supported[NV_FENCE])
 364     {
 365         GL_EXTCALL(glSetFenceNV(fence->object.id, GL_ALL_COMPLETED_NV));
 366         checkGLcall("glSetFenceNV");
 367     }
 368
 369     context_release(&context_gl->c);
 370 }
 371
 372 static void wined3d_fence_free(struct wined3d_fence *fence)
 373 {
 374     if (fence->context_gl)
 375         wined3d_context_gl_free_fence(fence);
 376 }
 377
 378 void wined3d_fence_destroy(struct wined3d_fence *fence)
 379 {
 380     wined3d_fence_free(fence);
 381     heap_free(fence);
 382 }
 383
 384 static HRESULT wined3d_fence_init(struct wined3d_fence *fence, const struct wined3d_gl_info *gl_info)
 385 {
 386     if (!wined3d_fence_supported(gl_info))
 387     {
 388         WARN("Fences not supported.\n");
 389         return WINED3DERR_NOTAVAILABLE;
 390     }
 391
 392     return WINED3D_OK;
 393 }
 394
 395 HRESULT wined3d_fence_create(struct wined3d_device *device, struct wined3d_fence **fence)
 396 {
 397     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 398     struct wined3d_fence *object;
 399     HRESULT hr;
 400
 401     TRACE("device %p, fence %p.\n", device, fence);
 402
 403     if (!(object = heap_alloc_zero(sizeof(*object))))
 404         return E_OUTOFMEMORY;
 405
 406     if (FAILED(hr = wined3d_fence_init(object, gl_info)))
 407     {
 408         heap_free(object);
 409         return hr;
 410     }
 411
 412     TRACE("Created fence %p.\n", object);
 413     *fence = object;
 414
 415     return WINED3D_OK;
 416 }
 417
 418 ULONG CDECL wined3d_query_incref(struct wined3d_query *query)
 419 {
 420     ULONG refcount = InterlockedIncrement(&query->ref);
 421
 422     TRACE("%p increasing refcount to %u.\n", query, refcount);
 423
 424     return refcount;
 425 }
 426
 427 static void wined3d_query_destroy_object(void *object)
 428 {
 429     struct wined3d_query *query = object;
 430
 431     if (!list_empty(&query->poll_list_entry))
 432         list_remove(&query->poll_list_entry);
 433 }
 434
 435 ULONG CDECL wined3d_query_decref(struct wined3d_query *query)
 436 {
 437     ULONG refcount = InterlockedDecrement(&query->ref);
 438
 439     TRACE("%p decreasing refcount to %u.\n", query, refcount);
 440
 441     if (!refcount)
 442     {
 443         struct wined3d_device *device = query->device;
 444
 445         query->parent_ops->wined3d_object_destroyed(query->parent);
 446         wined3d_cs_destroy_object(device->cs, wined3d_query_destroy_object, query);
 447         device->adapter->adapter_ops->adapter_destroy_query(query);
 448     }
 449
 450     return refcount;
 451 }
 452
 453 HRESULT CDECL wined3d_query_get_data(struct wined3d_query *query,
 454         void *data, UINT data_size, DWORD flags)
 455 {
 456     TRACE("query %p, data %p, data_size %u, flags %#x.\n",
 457             query, data, data_size, flags);
 458
 459     if (query->state == QUERY_BUILDING)
 460     {
 461         WARN("Query is building, returning S_FALSE.\n");
 462         return S_FALSE;
 463     }
 464
 465     if (query->state == QUERY_CREATED)
 466     {
 467         WARN("Query wasn't started yet.\n");
 468         return WINED3DERR_INVALIDCALL;
 469     }
 470
 471     if (query->device->cs->thread)
 472     {
 473         if (query->counter_main != query->counter_retrieved
 474                 || (query->buffer_object && !wined3d_query_buffer_is_valid(query)))
 475         {
 476             if (flags & WINED3DGETDATA_FLUSH && !query->device->cs->queries_flushed)
 477                 wined3d_cs_emit_flush(query->device->cs);
 478             return S_FALSE;
 479         }
 480         if (query->buffer_object)
 481             query->data = query->map_ptr;
 482     }
 483     else if (!query->query_ops->query_poll(query, flags))
 484     {
 485         return S_FALSE;
 486     }
 487
 488     if (data)
 489         memcpy(data, query->data, min(data_size, query->data_size));
 490
 491     return S_OK;
 492 }
 493
 494 UINT CDECL wined3d_query_get_data_size(const struct wined3d_query *query)
 495 {
 496     TRACE("query %p.\n", query);
 497
 498     return query->data_size;
 499 }
 500
 501 HRESULT CDECL wined3d_query_issue(struct wined3d_query *query, DWORD flags)
 502 {
 503     TRACE("query %p, flags %#x.\n", query, flags);
 504
 505     if (flags & WINED3DISSUE_END)
 506         ++query->counter_main;
 507
 508     wined3d_cs_emit_query_issue(query->device->cs, query, flags);
 509
 510     if (flags & WINED3DISSUE_BEGIN)
 511         query->state = QUERY_BUILDING;
 512     else
 513         query->state = QUERY_SIGNALLED;
 514
 515     return WINED3D_OK;
 516 }
 517
 518 static BOOL wined3d_occlusion_query_ops_poll(struct wined3d_query *query, DWORD flags)
 519 {
 520     struct wined3d_occlusion_query *oq = wined3d_occlusion_query_from_query(query);
 521     const struct wined3d_gl_info *gl_info;
 522     struct wined3d_context_gl *context_gl;
 523     GLuint available;
 524
 525     TRACE("query %p, flags %#x.\n", query, flags);
 526
 527     if (!(context_gl = wined3d_context_gl_reacquire(oq->context_gl)))
 528     {
 529         FIXME("%p Wrong thread, returning 1.\n", query);
 530         oq->samples = 1;
 531         return TRUE;
 532     }
 533     gl_info = context_gl->gl_info;
 534
 535     GL_EXTCALL(glGetQueryObjectuiv(oq->id, GL_QUERY_RESULT_AVAILABLE, &available));
 536     TRACE("Available %#x.\n", available);
 537
 538     if (available)
 539     {
 540         oq->samples = get_query_result64(oq->id, gl_info);
 541         TRACE("Returning 0x%s samples.\n", wine_dbgstr_longlong(oq->samples));
 542     }
 543
 544     checkGLcall("poll occlusion query");
 545     context_release(&context_gl->c);
 546
 547     return available;
 548 }
 549
 550 static BOOL wined3d_event_query_ops_poll(struct wined3d_query *query, DWORD flags)
 551 {
 552     struct wined3d_event_query *event_query = wined3d_event_query_from_query(query);
 553     enum wined3d_fence_result ret;
 554
 555     TRACE("query %p, flags %#x.\n", query, flags);
 556
 557     ret = wined3d_fence_test(&event_query->fence, query->device, flags);
 558     switch (ret)
 559     {
 560         case WINED3D_FENCE_OK:
 561         case WINED3D_FENCE_NOT_STARTED:
 562             return event_query->signalled = TRUE;
 563
 564         case WINED3D_FENCE_WAITING:
 565             return event_query->signalled = FALSE;
 566
 567         case WINED3D_FENCE_WRONG_THREAD:
 568             FIXME("(%p) Wrong thread, reporting GPU idle.\n", query);
 569             return event_query->signalled = TRUE;
 570
 571         case WINED3D_FENCE_ERROR:
 572             ERR("The GL event query failed.\n");
 573             return event_query->signalled = TRUE;
 574
 575         default:
 576             ERR("Unexpected wined3d_event_query_test result %#x.\n", ret);
 577             return event_query->signalled = TRUE;
 578     }
 579 }
 580
 581 void * CDECL wined3d_query_get_parent(const struct wined3d_query *query)
 582 {
 583     TRACE("query %p.\n", query);
 584
 585     return query->parent;
 586 }
 587
 588 enum wined3d_query_type CDECL wined3d_query_get_type(const struct wined3d_query *query)
 589 {
 590     TRACE("query %p.\n", query);
 591
 592     return query->type;
 593 }
 594
 595 static BOOL wined3d_event_query_ops_issue(struct wined3d_query *query, DWORD flags)
 596 {
 597     TRACE("query %p, flags %#x.\n", query, flags);
 598
 599     if (flags & WINED3DISSUE_END)
 600     {
 601         struct wined3d_event_query *event_query = wined3d_event_query_from_query(query);
 602
 603         wined3d_fence_issue(&event_query->fence, query->device);
 604         return TRUE;
 605     }
 606     else if (flags & WINED3DISSUE_BEGIN)
 607     {
 608         /* Started implicitly at query creation. */
 609         ERR("Event query issued with START flag - what to do?\n");
 610     }
 611
 612     return FALSE;
 613 }
 614
 615 static BOOL wined3d_occlusion_query_ops_issue(struct wined3d_query *query, DWORD flags)
 616 {
 617     struct wined3d_occlusion_query *oq = wined3d_occlusion_query_from_query(query);
 618     struct wined3d_device *device = query->device;
 619     const struct wined3d_gl_info *gl_info;
 620     struct wined3d_context_gl *context_gl;
 621     BOOL poll = FALSE;
 622
 623     TRACE("query %p, flags %#x.\n", query, flags);
 624
 625     /* This is allowed according to MSDN and our tests. Reset the query and
 626      * restart. */
 627     if (flags & WINED3DISSUE_BEGIN)
 628     {
 629         if (oq->started)
 630         {
 631             if ((context_gl = wined3d_context_gl_reacquire(oq->context_gl)))
 632             {
 633                 gl_info = context_gl->gl_info;
 634                 GL_EXTCALL(glEndQuery(GL_SAMPLES_PASSED));
 635                 checkGLcall("glEndQuery()");
 636             }
 637             else
 638             {
 639                 FIXME("Wrong thread, can't restart query.\n");
 640                 wined3d_context_gl_free_occlusion_query(oq);
 641                 context_gl = wined3d_context_gl(context_acquire(device, NULL, 0));
 642                 wined3d_context_gl_alloc_occlusion_query(context_gl, oq);
 643             }
 644         }
 645         else
 646         {
 647             if (oq->context_gl)
 648                 wined3d_context_gl_free_occlusion_query(oq);
 649             context_gl = wined3d_context_gl(context_acquire(device, NULL, 0));
 650             wined3d_context_gl_alloc_occlusion_query(context_gl, oq);
 651         }
 652         gl_info = context_gl->gl_info;
 653
 654         GL_EXTCALL(glBeginQuery(GL_SAMPLES_PASSED, oq->id));
 655         checkGLcall("glBeginQuery()");
 656
 657         context_release(&context_gl->c);
 658         oq->started = TRUE;
 659     }
 660     if (flags & WINED3DISSUE_END)
 661     {
 662         /* MSDN says END on a non-building occlusion query returns an error,
 663          * but our tests show that it returns OK. But OpenGL doesn't like it,
 664          * so avoid generating an error. */
 665         if (oq->started)
 666         {
 667             if ((context_gl = wined3d_context_gl_reacquire(oq->context_gl)))
 668             {
 669                 gl_info = context_gl->gl_info;
 670                 GL_EXTCALL(glEndQuery(GL_SAMPLES_PASSED));
 671                 checkGLcall("glEndQuery()");
 672                 wined3d_query_buffer_queue_result(context_gl, query, oq->id);
 673
 674                 context_release(&context_gl->c);
 675                 poll = TRUE;
 676             }
 677             else
 678             {
 679                 FIXME("Wrong thread, can't end query.\n");
 680             }
 681         }
 682         oq->started = FALSE;
 683     }
 684
 685     return poll;
 686 }
 687
 688 static BOOL wined3d_timestamp_query_ops_poll(struct wined3d_query *query, DWORD flags)
 689 {
 690     struct wined3d_timestamp_query *tq = wined3d_timestamp_query_from_query(query);
 691     const struct wined3d_gl_info *gl_info;
 692     struct wined3d_context_gl *context_gl;
 693     GLuint64 timestamp;
 694     GLuint available;
 695
 696     TRACE("query %p, flags %#x.\n", query, flags);
 697
 698     if (!(context_gl = wined3d_context_gl_reacquire(tq->context_gl)))
 699     {
 700         FIXME("%p Wrong thread, returning 1.\n", query);
 701         tq->timestamp = 1;
 702         return TRUE;
 703     }
 704     gl_info = context_gl->gl_info;
 705
 706     GL_EXTCALL(glGetQueryObjectuiv(tq->id, GL_QUERY_RESULT_AVAILABLE, &available));
 707     checkGLcall("glGetQueryObjectuiv(GL_QUERY_RESULT_AVAILABLE)");
 708     TRACE("available %#x.\n", available);
 709
 710     if (available)
 711     {
 712         GL_EXTCALL(glGetQueryObjectui64v(tq->id, GL_QUERY_RESULT, &timestamp));
 713         checkGLcall("glGetQueryObjectui64v(GL_QUERY_RESULT)");
 714         TRACE("Returning timestamp %s.\n", wine_dbgstr_longlong(timestamp));
 715         tq->timestamp = timestamp;
 716     }
 717
 718     context_release(&context_gl->c);
 719
 720     return available;
 721 }
 722
 723 static BOOL wined3d_timestamp_query_ops_issue(struct wined3d_query *query, DWORD flags)
 724 {
 725     struct wined3d_timestamp_query *tq = wined3d_timestamp_query_from_query(query);
 726     const struct wined3d_gl_info *gl_info;
 727     struct wined3d_context_gl *context_gl;
 728
 729     TRACE("query %p, flags %#x.\n", query, flags);
 730
 731     if (flags & WINED3DISSUE_BEGIN)
 732     {
 733         WARN("Ignoring WINED3DISSUE_BEGIN with a TIMESTAMP query.\n");
 734     }
 735     if (flags & WINED3DISSUE_END)
 736     {
 737         if (tq->context_gl)
 738             wined3d_context_gl_free_timestamp_query(tq);
 739         context_gl = wined3d_context_gl(context_acquire(query->device, NULL, 0));
 740         gl_info = context_gl->gl_info;
 741         wined3d_context_gl_alloc_timestamp_query(context_gl, tq);
 742         GL_EXTCALL(glQueryCounter(tq->id, GL_TIMESTAMP));
 743         checkGLcall("glQueryCounter()");
 744         context_release(&context_gl->c);
 745
 746         return TRUE;
 747     }
 748
 749     return FALSE;
 750 }
 751
 752 static BOOL wined3d_timestamp_disjoint_query_ops_poll(struct wined3d_query *query, DWORD flags)
 753 {
 754     TRACE("query %p, flags %#x.\n", query, flags);
 755
 756     return TRUE;
 757 }
 758
 759 static BOOL wined3d_timestamp_disjoint_query_ops_issue(struct wined3d_query *query, DWORD flags)
 760 {
 761     TRACE("query %p, flags %#x.\n", query, flags);
 762
 763     return FALSE;
 764 }
 765
 766 static BOOL wined3d_so_statistics_query_ops_poll(struct wined3d_query *query, DWORD flags)
 767 {
 768     struct wined3d_so_statistics_query *pq = wined3d_so_statistics_query_from_query(query);
 769     GLuint written_available, generated_available;
 770     const struct wined3d_gl_info *gl_info;
 771     struct wined3d_context_gl *context_gl;
 772
 773     TRACE("query %p, flags %#x.\n", query, flags);
 774
 775     if (!(context_gl = wined3d_context_gl_reacquire(pq->context_gl)))
 776     {
 777         FIXME("%p Wrong thread, returning 0 primitives.\n", query);
 778         memset(&pq->statistics, 0, sizeof(pq->statistics));
 779         return TRUE;
 780     }
 781     gl_info = context_gl->gl_info;
 782
 783     GL_EXTCALL(glGetQueryObjectuiv(pq->u.query.written,
 784             GL_QUERY_RESULT_AVAILABLE, &written_available));
 785     GL_EXTCALL(glGetQueryObjectuiv(pq->u.query.generated,
 786             GL_QUERY_RESULT_AVAILABLE, &generated_available));
 787     TRACE("Available %#x, %#x.\n", written_available, generated_available);
 788
 789     if (written_available && generated_available)
 790     {
 791         pq->statistics.primitives_written = get_query_result64(pq->u.query.written, gl_info);
 792         pq->statistics.primitives_generated = get_query_result64(pq->u.query.generated, gl_info);
 793         TRACE("Returning %s, %s primitives.\n",
 794                 wine_dbgstr_longlong(pq->statistics.primitives_written),
 795                 wine_dbgstr_longlong(pq->statistics.primitives_generated));
 796     }
 797
 798     checkGLcall("poll SO statistics query");
 799     context_release(&context_gl->c);
 800
 801     return written_available && generated_available;
 802 }
 803
 804 static void wined3d_so_statistics_query_end(struct wined3d_so_statistics_query *query,
 805         struct wined3d_context_gl *context_gl)
 806 {
 807     const struct wined3d_gl_info *gl_info = context_gl->gl_info;
 808
 809     if (gl_info->supported[ARB_TRANSFORM_FEEDBACK3])
 810     {
 811         GL_EXTCALL(glEndQueryIndexed(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, query->stream_idx));
 812         GL_EXTCALL(glEndQueryIndexed(GL_PRIMITIVES_GENERATED, query->stream_idx));
 813     }
 814     else
 815     {
 816         GL_EXTCALL(glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN));
 817         GL_EXTCALL(glEndQuery(GL_PRIMITIVES_GENERATED));
 818     }
 819     checkGLcall("end query");
 820 }
 821
 822 static BOOL wined3d_so_statistics_query_ops_issue(struct wined3d_query *query, DWORD flags)
 823 {
 824     struct wined3d_so_statistics_query *pq = wined3d_so_statistics_query_from_query(query);
 825     struct wined3d_device *device = query->device;
 826     const struct wined3d_gl_info *gl_info;
 827     struct wined3d_context_gl *context_gl;
 828     BOOL poll = FALSE;
 829
 830     TRACE("query %p, flags %#x.\n", query, flags);
 831
 832     if (flags & WINED3DISSUE_BEGIN)
 833     {
 834         if (pq->started)
 835         {
 836             if ((context_gl = wined3d_context_gl_reacquire(pq->context_gl)))
 837             {
 838                 wined3d_so_statistics_query_end(pq, context_gl);
 839             }
 840             else
 841             {
 842                 FIXME("Wrong thread, can't restart query.\n");
 843                 wined3d_context_gl_free_so_statistics_query(pq);
 844                 context_gl = wined3d_context_gl(context_acquire(device, NULL, 0));
 845                 wined3d_context_gl_alloc_so_statistics_query(context_gl, pq);
 846             }
 847         }
 848         else
 849         {
 850             if (pq->context_gl)
 851                 wined3d_context_gl_free_so_statistics_query(pq);
 852             context_gl = wined3d_context_gl(context_acquire(device, NULL, 0));
 853             wined3d_context_gl_alloc_so_statistics_query(context_gl, pq);
 854         }
 855         gl_info = context_gl->gl_info;
 856
 857         if (gl_info->supported[ARB_TRANSFORM_FEEDBACK3])
 858         {
 859             GL_EXTCALL(glBeginQueryIndexed(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN,
 860                     pq->stream_idx, pq->u.query.written));
 861             GL_EXTCALL(glBeginQueryIndexed(GL_PRIMITIVES_GENERATED,
 862                     pq->stream_idx, pq->u.query.generated));
 863         }
 864         else
 865         {
 866             GL_EXTCALL(glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN,
 867                     pq->u.query.written));
 868             GL_EXTCALL(glBeginQuery(GL_PRIMITIVES_GENERATED,
 869                     pq->u.query.generated));
 870         }
 871         checkGLcall("begin query");
 872
 873         context_release(&context_gl->c);
 874         pq->started = TRUE;
 875     }
 876     if (flags & WINED3DISSUE_END)
 877     {
 878         if (pq->started)
 879         {
 880             if ((context_gl = wined3d_context_gl_reacquire(pq->context_gl)))
 881             {
 882                 wined3d_so_statistics_query_end(pq, context_gl);
 883
 884                 context_release(&context_gl->c);
 885                 poll = TRUE;
 886             }
 887             else
 888             {
 889                 FIXME("Wrong thread, can't end query.\n");
 890             }
 891         }
 892         pq->started = FALSE;
 893     }
 894
 895     return poll;
 896 }
 897
 898 static BOOL wined3d_pipeline_query_ops_poll(struct wined3d_query *query, DWORD flags)
 899 {
 900     struct wined3d_pipeline_statistics_query *pq = wined3d_pipeline_statistics_query_from_query(query);
 901     const struct wined3d_gl_info *gl_info;
 902     struct wined3d_context_gl *context_gl;
 903     GLuint available;
 904     int i;
 905
 906     TRACE("query %p, flags %#x.\n", query, flags);
 907
 908     if (!(context_gl = wined3d_context_gl_reacquire(pq->context_gl)))
 909     {
 910         FIXME("%p Wrong thread.\n", query);
 911         memset(&pq->statistics, 0, sizeof(pq->statistics));
 912         return TRUE;
 913     }
 914     gl_info = context_gl->gl_info;
 915
 916     for (i = 0; i < ARRAY_SIZE(pq->u.id); ++i)
 917     {
 918         GL_EXTCALL(glGetQueryObjectuiv(pq->u.id[i], GL_QUERY_RESULT_AVAILABLE, &available));
 919         if (!available)
 920             break;
 921     }
 922
 923     if (available)
 924     {
 925         pq->statistics.vertices_submitted = get_query_result64(pq->u.query.vertices, gl_info);
 926         pq->statistics.primitives_submitted = get_query_result64(pq->u.query.primitives, gl_info);
 927         pq->statistics.vs_invocations = get_query_result64(pq->u.query.vertex_shader, gl_info);
 928         pq->statistics.hs_invocations = get_query_result64(pq->u.query.tess_control_shader, gl_info);
 929         pq->statistics.ds_invocations = get_query_result64(pq->u.query.tess_eval_shader, gl_info);
 930         pq->statistics.gs_invocations = get_query_result64(pq->u.query.geometry_shader, gl_info);
 931         pq->statistics.gs_primitives = get_query_result64(pq->u.query.geometry_primitives, gl_info);
 932         pq->statistics.ps_invocations = get_query_result64(pq->u.query.fragment_shader, gl_info);
 933         pq->statistics.cs_invocations = get_query_result64(pq->u.query.compute_shader, gl_info);
 934         pq->statistics.clipping_input_primitives = get_query_result64(pq->u.query.clipping_input, gl_info);
 935         pq->statistics.clipping_output_primitives = get_query_result64(pq->u.query.clipping_output, gl_info);
 936     }
 937
 938     checkGLcall("poll pipeline statistics query");
 939     context_release(&context_gl->c);
 940     return available;
 941 }
 942
 943 static void wined3d_pipeline_statistics_query_end(struct wined3d_pipeline_statistics_query *query,
 944         struct wined3d_context_gl *context_gl)
 945 {
 946     const struct wined3d_gl_info *gl_info = context_gl->gl_info;
 947
 948     GL_EXTCALL(glEndQuery(GL_VERTICES_SUBMITTED_ARB));
 949     GL_EXTCALL(glEndQuery(GL_PRIMITIVES_SUBMITTED_ARB));
 950     GL_EXTCALL(glEndQuery(GL_VERTEX_SHADER_INVOCATIONS_ARB));
 951     GL_EXTCALL(glEndQuery(GL_TESS_CONTROL_SHADER_PATCHES_ARB));
 952     GL_EXTCALL(glEndQuery(GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB));
 953     GL_EXTCALL(glEndQuery(GL_GEOMETRY_SHADER_INVOCATIONS));
 954     GL_EXTCALL(glEndQuery(GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB));
 955     GL_EXTCALL(glEndQuery(GL_FRAGMENT_SHADER_INVOCATIONS_ARB));
 956     GL_EXTCALL(glEndQuery(GL_COMPUTE_SHADER_INVOCATIONS_ARB));
 957     GL_EXTCALL(glEndQuery(GL_CLIPPING_INPUT_PRIMITIVES_ARB));
 958     GL_EXTCALL(glEndQuery(GL_CLIPPING_OUTPUT_PRIMITIVES_ARB));
 959     checkGLcall("end query");
 960 }
 961
 962 static BOOL wined3d_pipeline_query_ops_issue(struct wined3d_query *query, DWORD flags)
 963 {
 964     struct wined3d_pipeline_statistics_query *pq = wined3d_pipeline_statistics_query_from_query(query);
 965     struct wined3d_device *device = query->device;
 966     const struct wined3d_gl_info *gl_info;
 967     struct wined3d_context_gl *context_gl;
 968     BOOL poll = FALSE;
 969
 970     TRACE("query %p, flags %#x.\n", query, flags);
 971
 972     if (flags & WINED3DISSUE_BEGIN)
 973     {
 974         if (pq->started)
 975         {
 976             if ((context_gl = wined3d_context_gl_reacquire(pq->context_gl)))
 977             {
 978                 wined3d_pipeline_statistics_query_end(pq, context_gl);
 979             }
 980             else
 981             {
 982                 FIXME("Wrong thread, can't restart query.\n");
 983                 wined3d_context_gl_free_pipeline_statistics_query(pq);
 984                 context_gl = wined3d_context_gl(context_acquire(device, NULL, 0));
 985                 wined3d_context_gl_alloc_pipeline_statistics_query(context_gl, pq);
 986             }
 987         }
 988         else
 989         {
 990             if (pq->context_gl)
 991                 wined3d_context_gl_free_pipeline_statistics_query(pq);
 992             context_gl = wined3d_context_gl(context_acquire(device, NULL, 0));
 993             wined3d_context_gl_alloc_pipeline_statistics_query(context_gl, pq);
 994         }
 995         gl_info = context_gl->gl_info;
 996
 997         GL_EXTCALL(glBeginQuery(GL_VERTICES_SUBMITTED_ARB, pq->u.query.vertices));
 998         GL_EXTCALL(glBeginQuery(GL_PRIMITIVES_SUBMITTED_ARB, pq->u.query.primitives));
 999         GL_EXTCALL(glBeginQuery(GL_VERTEX_SHADER_INVOCATIONS_ARB, pq->u.query.vertex_shader));
1000         GL_EXTCALL(glBeginQuery(GL_TESS_CONTROL_SHADER_PATCHES_ARB, pq->u.query.tess_control_shader));
1001         GL_EXTCALL(glBeginQuery(GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB, pq->u.query.tess_eval_shader));
1002         GL_EXTCALL(glBeginQuery(GL_GEOMETRY_SHADER_INVOCATIONS, pq->u.query.geometry_shader));
1003         GL_EXTCALL(glBeginQuery(GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB, pq->u.query.geometry_primitives));
1004         GL_EXTCALL(glBeginQuery(GL_FRAGMENT_SHADER_INVOCATIONS_ARB, pq->u.query.fragment_shader));
1005         GL_EXTCALL(glBeginQuery(GL_COMPUTE_SHADER_INVOCATIONS_ARB, pq->u.query.compute_shader));
1006         GL_EXTCALL(glBeginQuery(GL_CLIPPING_INPUT_PRIMITIVES_ARB, pq->u.query.clipping_input));
1007         GL_EXTCALL(glBeginQuery(GL_CLIPPING_OUTPUT_PRIMITIVES_ARB, pq->u.query.clipping_output));
1008         checkGLcall("begin query");
1009
1010         context_release(&context_gl->c);
1011         pq->started = TRUE;
1012     }
1013     if (flags & WINED3DISSUE_END)
1014     {
1015         if (pq->started)
1016         {
1017             if ((context_gl = wined3d_context_gl_reacquire(pq->context_gl)))
1018             {
1019                 wined3d_pipeline_statistics_query_end(pq, context_gl);
1020                 context_release(&context_gl->c);
1021                 poll = TRUE;
1022             }
1023             else
1024             {
1025                 FIXME("Wrong thread, can't end query.\n");
1026             }
1027         }
1028         pq->started = FALSE;
1029     }
1030
1031     return poll;
1032 }
1033
1034 static void wined3d_event_query_ops_destroy(struct wined3d_query *query)
1035 {
1036     struct wined3d_event_query *event_query = wined3d_event_query_from_query(query);
1037
1038     wined3d_fence_free(&event_query->fence);
1039     heap_free(event_query);
1040 }
1041
1042 static const struct wined3d_query_ops event_query_ops =
1043 {
1044     wined3d_event_query_ops_poll,
1045     wined3d_event_query_ops_issue,
1046     wined3d_event_query_ops_destroy,
1047 };
1048
1049 static HRESULT wined3d_event_query_create(struct wined3d_device *device,
1050         enum wined3d_query_type type, void *parent, const struct wined3d_parent_ops *parent_ops,
1051         struct wined3d_query **query)
1052 {
1053     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1054     struct wined3d_event_query *object;
1055     HRESULT hr;
1056
1057     TRACE("device %p, type %#x, parent %p, parent_ops %p, query %p.\n",
1058             device, type, parent, parent_ops, query);
1059
1060     if (!(object = heap_alloc_zero(sizeof(*object))))
1061         return E_OUTOFMEMORY;
1062
1063     if (FAILED(hr = wined3d_fence_init(&object->fence, gl_info)))
1064     {
1065         WARN("Event queries not supported.\n");
1066         heap_free(object);
1067         return hr;
1068     }
1069
1070     wined3d_query_init(&object->query, device, type, &object->signalled,
1071             sizeof(object->signalled), &event_query_ops, parent, parent_ops);
1072
1073     TRACE("Created query %p.\n", object);
1074     *query = &object->query;
1075
1076     return WINED3D_OK;
1077 }
1078
1079 static void wined3d_occlusion_query_ops_destroy(struct wined3d_query *query)
1080 {
1081     struct wined3d_occlusion_query *oq = wined3d_occlusion_query_from_query(query);
1082
1083     if (oq->context_gl)
1084         wined3d_context_gl_free_occlusion_query(oq);
1085     heap_free(oq);
1086 }
1087
1088 static const struct wined3d_query_ops occlusion_query_ops =
1089 {
1090     wined3d_occlusion_query_ops_poll,
1091     wined3d_occlusion_query_ops_issue,
1092     wined3d_occlusion_query_ops_destroy,
1093 };
1094
1095 static HRESULT wined3d_occlusion_query_create(struct wined3d_device *device,
1096         enum wined3d_query_type type, void *parent, const struct wined3d_parent_ops *parent_ops,
1097         struct wined3d_query **query)
1098 {
1099     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1100     struct wined3d_occlusion_query *object;
1101
1102     TRACE("device %p, type %#x, parent %p, parent_ops %p, query %p.\n",
1103             device, type, parent, parent_ops, query);
1104
1105     if (!gl_info->supported[ARB_OCCLUSION_QUERY])
1106     {
1107         WARN("Unsupported in local OpenGL implementation: ARB_OCCLUSION_QUERY.\n");
1108         return WINED3DERR_NOTAVAILABLE;
1109     }
1110
1111     if (!(object = heap_alloc_zero(sizeof(*object))))
1112         return E_OUTOFMEMORY;
1113
1114     wined3d_query_init(&object->query, device, type, &object->samples,
1115             sizeof(object->samples), &occlusion_query_ops, parent, parent_ops);
1116
1117     TRACE("Created query %p.\n", object);
1118     *query = &object->query;
1119
1120     return WINED3D_OK;
1121 }
1122
1123 static void wined3d_timestamp_query_ops_destroy(struct wined3d_query *query)
1124 {
1125     struct wined3d_timestamp_query *tq = wined3d_timestamp_query_from_query(query);
1126
1127     if (tq->context_gl)
1128         wined3d_context_gl_free_timestamp_query(tq);
1129     heap_free(tq);
1130 }
1131
1132 static const struct wined3d_query_ops timestamp_query_ops =
1133 {
1134     wined3d_timestamp_query_ops_poll,
1135     wined3d_timestamp_query_ops_issue,
1136     wined3d_timestamp_query_ops_destroy,
1137 };
1138
1139 static HRESULT wined3d_timestamp_query_create(struct wined3d_device *device,
1140         enum wined3d_query_type type, void *parent, const struct wined3d_parent_ops *parent_ops,
1141         struct wined3d_query **query)
1142 {
1143     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1144     struct wined3d_timestamp_query *object;
1145
1146     TRACE("device %p, type %#x, parent %p, parent_ops %p, query %p.\n",
1147             device, type, parent, parent_ops, query);
1148
1149     if (!gl_info->supported[ARB_TIMER_QUERY])
1150     {
1151         WARN("Unsupported in local OpenGL implementation: ARB_TIMER_QUERY.\n");
1152         return WINED3DERR_NOTAVAILABLE;
1153     }
1154
1155     if (!(object = heap_alloc_zero(sizeof(*object))))
1156         return E_OUTOFMEMORY;
1157
1158     wined3d_query_init(&object->query, device, type, &object->timestamp,
1159             sizeof(object->timestamp), &timestamp_query_ops, parent, parent_ops);
1160
1161     TRACE("Created query %p.\n", object);
1162     *query = &object->query;
1163
1164     return WINED3D_OK;
1165 }
1166
1167 static void wined3d_timestamp_disjoint_query_ops_destroy(struct wined3d_query *query)
1168 {
1169     heap_free(query);
1170 }
1171
1172 static const struct wined3d_query_ops timestamp_disjoint_query_ops =
1173 {
1174     wined3d_timestamp_disjoint_query_ops_poll,
1175     wined3d_timestamp_disjoint_query_ops_issue,
1176     wined3d_timestamp_disjoint_query_ops_destroy,
1177 };
1178
1179 static HRESULT wined3d_timestamp_disjoint_query_create(struct wined3d_device *device,
1180         enum wined3d_query_type type, void *parent, const struct wined3d_parent_ops *parent_ops,
1181         struct wined3d_query **query)
1182 {
1183     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1184     struct wined3d_query *object;
1185
1186     TRACE("device %p, type %#x, parent %p, parent_ops %p, query %p.\n",
1187             device, type, parent, parent_ops, query);
1188
1189     if (!gl_info->supported[ARB_TIMER_QUERY])
1190     {
1191         WARN("Unsupported in local OpenGL implementation: ARB_TIMER_QUERY.\n");
1192         return WINED3DERR_NOTAVAILABLE;
1193     }
1194
1195     if (!(object = heap_alloc_zero(sizeof(*object))))
1196         return E_OUTOFMEMORY;
1197
1198     if (type == WINED3D_QUERY_TYPE_TIMESTAMP_DISJOINT)
1199     {
1200         static const struct wined3d_query_data_timestamp_disjoint disjoint_data = {1000 * 1000 * 1000, FALSE};
1201
1202         wined3d_query_init(object, device, type, &disjoint_data,
1203                 sizeof(disjoint_data), &timestamp_disjoint_query_ops, parent, parent_ops);
1204     }
1205     else
1206     {
1207         static const UINT64 freq = 1000 * 1000 * 1000;
1208
1209         wined3d_query_init(object, device, type, &freq,
1210                 sizeof(freq), &timestamp_disjoint_query_ops, parent, parent_ops);
1211     }
1212
1213     TRACE("Created query %p.\n", object);
1214     *query = object;
1215
1216     return WINED3D_OK;
1217 }
1218
1219 static void wined3d_so_statistics_query_ops_destroy(struct wined3d_query *query)
1220 {
1221     struct wined3d_so_statistics_query *pq = wined3d_so_statistics_query_from_query(query);
1222
1223     if (pq->context_gl)
1224         wined3d_context_gl_free_so_statistics_query(pq);
1225     heap_free(pq);
1226 }
1227
1228 static const struct wined3d_query_ops so_statistics_query_ops =
1229 {
1230     wined3d_so_statistics_query_ops_poll,
1231     wined3d_so_statistics_query_ops_issue,
1232     wined3d_so_statistics_query_ops_destroy,
1233 };
1234
1235 static HRESULT wined3d_so_statistics_query_create(struct wined3d_device *device,
1236         enum wined3d_query_type type, void *parent, const struct wined3d_parent_ops *parent_ops,
1237         struct wined3d_query **query)
1238 {
1239     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1240     struct wined3d_so_statistics_query *object;
1241     unsigned int stream_idx;
1242
1243     if (WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM0 <= type && type <= WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM3)
1244         stream_idx = type - WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM0;
1245     else if (type == WINED3D_QUERY_TYPE_SO_STATISTICS)
1246         stream_idx = 0;
1247     else
1248         return WINED3DERR_NOTAVAILABLE;
1249
1250     TRACE("device %p, type %#x, parent %p, parent_ops %p, query %p.\n",
1251             device, type, parent, parent_ops, query);
1252
1253     if (!gl_info->supported[WINED3D_GL_PRIMITIVE_QUERY])
1254     {
1255         WARN("OpenGL implementation does not support primitive queries.\n");
1256         return WINED3DERR_NOTAVAILABLE;
1257     }
1258     if (stream_idx && !gl_info->supported[ARB_TRANSFORM_FEEDBACK3])
1259     {
1260         WARN("OpenGL implementation does not support indexed queries.\n");
1261         return WINED3DERR_NOTAVAILABLE;
1262     }
1263
1264     if (!(object = heap_alloc_zero(sizeof(*object))))
1265         return E_OUTOFMEMORY;
1266
1267     wined3d_query_init(&object->query, device, type, &object->statistics,
1268             sizeof(object->statistics), &so_statistics_query_ops, parent, parent_ops);
1269     object->stream_idx = stream_idx;
1270
1271     TRACE("Created query %p.\n", object);
1272     *query = &object->query;
1273
1274     return WINED3D_OK;
1275 }
1276
1277 static void wined3d_pipeline_query_ops_destroy(struct wined3d_query *query)
1278 {
1279     struct wined3d_pipeline_statistics_query *pq = wined3d_pipeline_statistics_query_from_query(query);
1280     if (pq->context_gl)
1281         wined3d_context_gl_free_pipeline_statistics_query(pq);
1282     heap_free(pq);
1283 }
1284
1285 static const struct wined3d_query_ops pipeline_query_ops =
1286 {
1287     wined3d_pipeline_query_ops_poll,
1288     wined3d_pipeline_query_ops_issue,
1289     wined3d_pipeline_query_ops_destroy,
1290 };
1291
1292 static HRESULT wined3d_pipeline_query_create(struct wined3d_device *device,
1293         enum wined3d_query_type type, void *parent, const struct wined3d_parent_ops *parent_ops,
1294         struct wined3d_query **query)
1295 {
1296     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1297     struct wined3d_pipeline_statistics_query *object;
1298
1299     TRACE("device %p, type %#x, parent %p, parent_ops %p, query %p.\n",
1300             device, type, parent, parent_ops, query);
1301
1302     if (!gl_info->supported[ARB_PIPELINE_STATISTICS_QUERY])
1303     {
1304         WARN("OpenGL implementation does not support pipeline statistics queries.\n");
1305         return WINED3DERR_NOTAVAILABLE;
1306     }
1307
1308     if (!(object = heap_alloc_zero(sizeof(*object))))
1309         return E_OUTOFMEMORY;
1310
1311     wined3d_query_init(&object->query, device, type, &object->statistics,
1312             sizeof(object->statistics), &pipeline_query_ops, parent, parent_ops);
1313
1314     TRACE("Created query %p.\n", object);
1315     *query = &object->query;
1316
1317     return WINED3D_OK;
1318 }
1319
1320 HRESULT wined3d_query_gl_create(struct wined3d_device *device, enum wined3d_query_type type,
1321         void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_query **query)
1322 {
1323     TRACE("device %p, type %#x, parent %p, parent_ops %p, query %p.\n",
1324             device, type, parent, parent_ops, query);
1325
1326     switch (type)
1327     {
1328         case WINED3D_QUERY_TYPE_EVENT:
1329             return wined3d_event_query_create(device, type, parent, parent_ops, query);
1330
1331         case WINED3D_QUERY_TYPE_OCCLUSION:
1332             return wined3d_occlusion_query_create(device, type, parent, parent_ops, query);
1333
1334         case WINED3D_QUERY_TYPE_TIMESTAMP:
1335             return wined3d_timestamp_query_create(device, type, parent, parent_ops, query);
1336
1337         case WINED3D_QUERY_TYPE_TIMESTAMP_DISJOINT:
1338         case WINED3D_QUERY_TYPE_TIMESTAMP_FREQ:
1339             return wined3d_timestamp_disjoint_query_create(device, type, parent, parent_ops, query);
1340
1341         case WINED3D_QUERY_TYPE_SO_STATISTICS:
1342         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM0:
1343         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM1:
1344         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM2:
1345         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM3:
1346             return wined3d_so_statistics_query_create(device, type, parent, parent_ops, query);
1347
1348         case WINED3D_QUERY_TYPE_PIPELINE_STATISTICS:
1349             return wined3d_pipeline_query_create(device, type, parent, parent_ops, query);
1350
1351         default:
1352             FIXME("Unhandled query type %#x.\n", type);
1353             return WINED3DERR_NOTAVAILABLE;
1354     }
1355 }
1356
1357 void wined3d_query_pool_vk_free_query(struct wined3d_query_pool_vk *pool_vk, size_t idx)
1358 {
1359     wined3d_bitmap_clear(pool_vk->allocated, idx);
1360
1361     if (list_empty(&pool_vk->entry))
1362         list_add_tail(pool_vk->free_list, &pool_vk->entry);
1363 }
1364
1365 bool wined3d_query_pool_vk_allocate_query(struct wined3d_query_pool_vk *pool_vk, size_t *idx)
1366 {
1367     if ((*idx = wined3d_bitmap_ffz(pool_vk->allocated, WINED3D_QUERY_POOL_SIZE, 0)) > WINED3D_QUERY_POOL_SIZE)
1368         return false;
1369     wined3d_bitmap_set(pool_vk->allocated, *idx);
1370
1371     return true;
1372 }
1373
1374 void wined3d_query_pool_vk_cleanup(struct wined3d_query_pool_vk *pool_vk, struct wined3d_context_vk *context_vk)
1375 {
1376     struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
1377     const struct wined3d_vk_info *vk_info = context_vk->vk_info;
1378
1379     VK_CALL(vkDestroyQueryPool(device_vk->vk_device, pool_vk->vk_query_pool, NULL));
1380     list_remove(&pool_vk->entry);
1381 }
1382
1383 bool wined3d_query_pool_vk_init(struct wined3d_query_pool_vk *pool_vk,
1384         struct wined3d_context_vk *context_vk, enum wined3d_query_type type, struct list *free_pools)
1385 {
1386     struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
1387     const struct wined3d_vk_info *vk_info = context_vk->vk_info;
1388     VkQueryPoolCreateInfo pool_info;
1389     VkResult vr;
1390
1391     list_init(&pool_vk->entry);
1392     pool_vk->free_list = free_pools;
1393
1394     pool_info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
1395     pool_info.pNext = NULL;
1396     pool_info.flags = 0;
1397     pool_info.queryCount = WINED3D_QUERY_POOL_SIZE;
1398
1399     switch (type)
1400     {
1401         case WINED3D_QUERY_TYPE_OCCLUSION:
1402             pool_info.queryType = VK_QUERY_TYPE_OCCLUSION;
1403             pool_info.pipelineStatistics = 0;
1404             break;
1405
1406         case WINED3D_QUERY_TYPE_TIMESTAMP:
1407             pool_info.queryType = VK_QUERY_TYPE_TIMESTAMP;
1408             pool_info.pipelineStatistics = 0;
1409             break;
1410
1411         case WINED3D_QUERY_TYPE_PIPELINE_STATISTICS:
1412             pool_info.queryType = VK_QUERY_TYPE_PIPELINE_STATISTICS;
1413             pool_info.pipelineStatistics = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT
1414                     | VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT
1415                     | VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT
1416                     | VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT
1417                     | VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT
1418                     | VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT
1419                     | VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT
1420                     | VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT
1421                     | VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT
1422                     | VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT
1423                     | VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT;
1424             break;
1425
1426         case WINED3D_QUERY_TYPE_SO_STATISTICS:
1427         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM0:
1428         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM1:
1429         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM2:
1430         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM3:
1431             pool_info.queryType = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT;
1432             pool_info.pipelineStatistics = 0;
1433             break;
1434
1435         default:
1436             FIXME("Unhandled query type %#x.\n", type);
1437             return false;
1438     }
1439
1440     if ((vr = VK_CALL(vkCreateQueryPool(device_vk->vk_device, &pool_info, NULL, &pool_vk->vk_query_pool))) < 0)
1441     {
1442         ERR("Failed to create Vulkan query pool, vr %s.\n", wined3d_debug_vkresult(vr));
1443         return false;
1444     }
1445
1446     list_add_head(free_pools, &pool_vk->entry);
1447
1448     return true;
1449 }
1450
1451 bool wined3d_query_vk_accumulate_data(struct wined3d_query_vk *query_vk,
1452         struct wined3d_context_vk *context_vk, const struct wined3d_query_pool_idx_vk *pool_idx)
1453 {
1454     struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
1455     const struct wined3d_query_data_pipeline_statistics *ps_tmp;
1456     const struct wined3d_vk_info *vk_info = context_vk->vk_info;
1457     struct wined3d_query_data_pipeline_statistics *ps_result;
1458     VkResult vr;
1459     union
1460     {
1461         uint64_t occlusion;
1462         uint64_t timestamp;
1463         struct wined3d_query_data_pipeline_statistics pipeline_statistics;
1464         struct wined3d_query_data_so_statistics so_statistics;
1465     } tmp, *result;
1466
1467     if ((vr = VK_CALL(vkGetQueryPoolResults(device_vk->vk_device, pool_idx->pool_vk->vk_query_pool,
1468             pool_idx->idx, 1, sizeof(tmp), &tmp, sizeof(tmp), VK_QUERY_RESULT_64_BIT))) < 0)
1469     {
1470         ERR("Failed to get query results, vr %s.\n", wined3d_debug_vkresult(vr));
1471         return false;
1472     }
1473
1474     if (vr == VK_NOT_READY)
1475         return false;
1476
1477     result = (void *)query_vk->q.data;
1478     switch (query_vk->q.type)
1479     {
1480         case WINED3D_QUERY_TYPE_OCCLUSION:
1481             result->occlusion += tmp.occlusion;
1482             break;
1483
1484         case WINED3D_QUERY_TYPE_TIMESTAMP:
1485             result->timestamp = tmp.timestamp;
1486             break;
1487
1488         case WINED3D_QUERY_TYPE_PIPELINE_STATISTICS:
1489             ps_result = &result->pipeline_statistics;
1490             ps_tmp = &tmp.pipeline_statistics;
1491             ps_result->vertices_submitted += ps_tmp->vertices_submitted;
1492             ps_result->primitives_submitted += ps_tmp->primitives_submitted;
1493             ps_result->vs_invocations += ps_tmp->vs_invocations;
1494             ps_result->gs_invocations += ps_tmp->gs_invocations;
1495             ps_result->gs_primitives += ps_tmp->gs_primitives;
1496             ps_result->clipping_input_primitives += ps_tmp->clipping_input_primitives;
1497             ps_result->clipping_output_primitives += ps_tmp->clipping_output_primitives;
1498             ps_result->ps_invocations += ps_tmp->ps_invocations;
1499             ps_result->hs_invocations += ps_tmp->hs_invocations;
1500             ps_result->ds_invocations += ps_tmp->ds_invocations;
1501             ps_result->cs_invocations += ps_tmp->cs_invocations;
1502             break;
1503
1504         case WINED3D_QUERY_TYPE_SO_STATISTICS:
1505         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM0:
1506         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM1:
1507         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM2:
1508         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM3:
1509             result->so_statistics.primitives_written += tmp.so_statistics.primitives_written;
1510             result->so_statistics.primitives_generated += tmp.so_statistics.primitives_generated;
1511             break;
1512
1513         default:
1514             FIXME("Unhandled query type %#x.\n", query_vk->q.type);
1515             return false;
1516     }
1517
1518     return true;
1519 }
1520
1521 static void wined3d_query_vk_begin(struct wined3d_query_vk *query_vk,
1522         struct wined3d_context_vk *context_vk, VkCommandBuffer vk_command_buffer)
1523 {
1524     const struct wined3d_vk_info *vk_info = context_vk->vk_info;
1525     struct wined3d_query_pool_vk *pool_vk;
1526     size_t idx;
1527
1528     if (!query_vk->pool_idx.pool_vk
1529             && !wined3d_context_vk_allocate_query(context_vk, query_vk->q.type, &query_vk->pool_idx))
1530     {
1531         ERR("Failed to allocate new query.\n");
1532         return;
1533     }
1534     pool_vk = query_vk->pool_idx.pool_vk;
1535     idx = query_vk->pool_idx.idx;
1536
1537     VK_CALL(vkCmdResetQueryPool(vk_command_buffer, pool_vk->vk_query_pool, idx, 1));
1538     if (query_vk->q.type >= WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM1
1539             && query_vk->q.type <= WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM3)
1540         VK_CALL(vkCmdBeginQueryIndexedEXT(vk_command_buffer, pool_vk->vk_query_pool, idx,
1541                 query_vk->control_flags, query_vk->q.type - WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM0));
1542     else
1543         VK_CALL(vkCmdBeginQuery(vk_command_buffer, pool_vk->vk_query_pool, idx, query_vk->control_flags));
1544     wined3d_context_vk_reference_query(context_vk, query_vk);
1545 }
1546
1547 static void wined3d_query_vk_end(struct wined3d_query_vk *query_vk,
1548         struct wined3d_context_vk *context_vk, VkCommandBuffer vk_command_buffer)
1549 {
1550     const struct wined3d_vk_info *vk_info = context_vk->vk_info;
1551     struct wined3d_query_pool_vk *pool_vk;
1552     size_t idx;
1553
1554     pool_vk = query_vk->pool_idx.pool_vk;
1555     idx = query_vk->pool_idx.idx;
1556
1557     if (query_vk->q.type >= WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM1
1558             && query_vk->q.type <= WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM3)
1559         VK_CALL(vkCmdEndQueryIndexedEXT(vk_command_buffer, pool_vk->vk_query_pool,
1560                 idx, query_vk->q.type - WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM0));
1561     else
1562         VK_CALL(vkCmdEndQuery(vk_command_buffer, pool_vk->vk_query_pool, idx));
1563 }
1564
1565 void wined3d_query_vk_resume(struct wined3d_query_vk *query_vk, struct wined3d_context_vk *context_vk)
1566 {
1567     VkCommandBuffer vk_command_buffer = context_vk->current_command_buffer.vk_command_buffer;
1568
1569     wined3d_query_vk_begin(query_vk, context_vk, vk_command_buffer);
1570 }
1571
1572 void wined3d_query_vk_suspend(struct wined3d_query_vk *query_vk, struct wined3d_context_vk *context_vk)
1573 {
1574     VkCommandBuffer vk_command_buffer = context_vk->current_command_buffer.vk_command_buffer;
1575
1576     wined3d_query_vk_end(query_vk, context_vk, vk_command_buffer);
1577     wined3d_context_vk_add_pending_query(context_vk, query_vk);
1578     query_vk->pool_idx.pool_vk = NULL;
1579 }
1580
1581 static BOOL wined3d_query_vk_poll(struct wined3d_query *query, uint32_t flags)
1582 {
1583     struct wined3d_query_vk *query_vk = wined3d_query_vk(query);
1584     struct wined3d_context_vk *context_vk;
1585
1586     context_vk = wined3d_context_vk(context_acquire(query->device, NULL, 0));
1587
1588     if (flags & WINED3DGETDATA_FLUSH)
1589         wined3d_context_vk_submit_command_buffer(context_vk, 0, NULL, NULL, 0, NULL);
1590     if (query_vk->command_buffer_id == context_vk->current_command_buffer.id)
1591         goto unavailable;
1592
1593     if (query_vk->command_buffer_id > context_vk->completed_command_buffer_id)
1594         wined3d_context_vk_poll_command_buffers(context_vk);
1595     if (query_vk->command_buffer_id > context_vk->completed_command_buffer_id)
1596         goto unavailable;
1597
1598     if (query_vk->pending_count)
1599         wined3d_context_vk_accumulate_pending_queries(context_vk);
1600     if (query_vk->pending_count)
1601         goto unavailable;
1602
1603     /* If the query was suspended, and then ended before it was resumed,
1604      * there's no data to accumulate here. */
1605     if (query_vk->pool_idx.pool_vk && !wined3d_query_vk_accumulate_data(query_vk, context_vk, &query_vk->pool_idx))
1606         goto unavailable;
1607
1608     context_release(&context_vk->c);
1609
1610     return TRUE;
1611
1612 unavailable:
1613     context_release(&context_vk->c);
1614     return FALSE;
1615 }
1616
1617 static BOOL wined3d_query_vk_issue(struct wined3d_query *query, uint32_t flags)
1618 {
1619     struct wined3d_device_vk *device_vk = wined3d_device_vk(query->device);
1620     struct wined3d_query_vk *query_vk = wined3d_query_vk(query);
1621     struct wined3d_context_vk *context_vk;
1622     VkCommandBuffer vk_command_buffer;
1623     bool poll = false;
1624
1625     TRACE("query %p, flags %#x.\n", query, flags);
1626
1627     if (flags & WINED3DISSUE_BEGIN)
1628     {
1629         context_vk = wined3d_context_vk(context_acquire(&device_vk->d, NULL, 0));
1630
1631         wined3d_context_vk_end_current_render_pass(context_vk);
1632         list_remove(&query_vk->entry);
1633         if (query_vk->pending_count)
1634             wined3d_context_vk_remove_pending_queries(context_vk, query_vk);
1635         memset((void *)query->data, 0, query->data_size);
1636         vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk);
1637         wined3d_query_vk_begin(query_vk, context_vk, vk_command_buffer);
1638         list_add_head(&context_vk->active_queries, &query_vk->entry);
1639         query_vk->started = true;
1640
1641         context_release(&context_vk->c);
1642     }
1643     if (flags & WINED3DISSUE_END && query_vk->started)
1644     {
1645         context_vk = wined3d_context_vk(context_acquire(&device_vk->d, NULL, 0));
1646
1647         /* If the query was already ended because the command buffer was
1648          * flushed, we don't need to end it here. */
1649         if ((vk_command_buffer = context_vk->current_command_buffer.vk_command_buffer))
1650             wined3d_query_vk_end(query_vk, context_vk, vk_command_buffer);
1651         list_remove(&query_vk->entry);
1652         query_vk->started = false;
1653         poll = true;
1654
1655         context_release(&context_vk->c);
1656     }
1657
1658     return poll;
1659 }
1660
1661 static void wined3d_query_vk_destroy(struct wined3d_query *query)
1662 {
1663     struct wined3d_query_vk *query_vk = wined3d_query_vk(query);
1664     struct wined3d_context_vk *context_vk;
1665
1666     list_remove(&query_vk->entry);
1667     if (query_vk->pending_count)
1668     {
1669         context_vk = wined3d_context_vk(context_acquire(query_vk->q.device, NULL, 0));
1670         wined3d_context_vk_remove_pending_queries(context_vk, query_vk);
1671         context_release(&context_vk->c);
1672     }
1673     if (query_vk->pool_idx.pool_vk)
1674         wined3d_query_pool_vk_free_query(query_vk->pool_idx.pool_vk, query_vk->pool_idx.idx);
1675     heap_free(query_vk);
1676 }
1677
1678 static const struct wined3d_query_ops wined3d_query_vk_ops =
1679 {
1680     .query_poll = wined3d_query_vk_poll,
1681     .query_issue = wined3d_query_vk_issue,
1682     .query_destroy = wined3d_query_vk_destroy,
1683 };
1684
1685 static BOOL wined3d_query_event_vk_poll(struct wined3d_query *query, uint32_t flags)
1686 {
1687     struct wined3d_query_vk *query_vk = wined3d_query_vk(query);
1688     struct wined3d_context_vk *context_vk;
1689     BOOL *signalled;
1690
1691     context_vk = wined3d_context_vk(context_acquire(query->device, NULL, 0));
1692
1693     signalled = (BOOL *)query->data;
1694     if (flags & WINED3DGETDATA_FLUSH)
1695         wined3d_context_vk_submit_command_buffer(context_vk, 0, NULL, NULL, 0, NULL);
1696     if (query_vk->command_buffer_id == context_vk->current_command_buffer.id)
1697     {
1698         context_release(&context_vk->c);
1699         return *signalled = FALSE;
1700     }
1701
1702     if (query_vk->command_buffer_id > context_vk->completed_command_buffer_id)
1703         wined3d_context_vk_poll_command_buffers(context_vk);
1704     *signalled = context_vk->completed_command_buffer_id >= query_vk->command_buffer_id;
1705
1706     context_release(&context_vk->c);
1707
1708     return *signalled;
1709 }
1710
1711 static BOOL wined3d_query_event_vk_issue(struct wined3d_query *query, uint32_t flags)
1712 {
1713     struct wined3d_device_vk *device_vk = wined3d_device_vk(query->device);
1714     struct wined3d_query_vk *query_vk = wined3d_query_vk(query);
1715     struct wined3d_context_vk *context_vk;
1716
1717     TRACE("query %p, flags %#x.\n", query, flags);
1718
1719     if (flags & WINED3DISSUE_END)
1720     {
1721         context_vk = wined3d_context_vk(context_acquire(&device_vk->d, NULL, 0));
1722         wined3d_context_vk_reference_query(context_vk, query_vk);
1723         context_release(&context_vk->c);
1724
1725         return TRUE;
1726     }
1727
1728     return FALSE;
1729 }
1730
1731 static const struct wined3d_query_ops wined3d_query_event_vk_ops =
1732 {
1733     .query_poll = wined3d_query_event_vk_poll,
1734     .query_issue = wined3d_query_event_vk_issue,
1735     .query_destroy = wined3d_query_vk_destroy,
1736 };
1737
1738 static BOOL wined3d_query_timestamp_vk_issue(struct wined3d_query *query, uint32_t flags)
1739 {
1740     struct wined3d_device_vk *device_vk = wined3d_device_vk(query->device);
1741     struct wined3d_query_vk *query_vk = wined3d_query_vk(query);
1742     const struct wined3d_vk_info *vk_info;
1743     struct wined3d_context_vk *context_vk;
1744     VkCommandBuffer command_buffer;
1745
1746     TRACE("query %p, flags %#x.\n", query, flags);
1747
1748     if (flags & WINED3DISSUE_BEGIN)
1749         TRACE("Ignoring WINED3DISSUE_BEGIN.\n");
1750
1751     if (flags & WINED3DISSUE_END)
1752     {
1753         context_vk = wined3d_context_vk(context_acquire(&device_vk->d, NULL, 0));
1754         vk_info = context_vk->vk_info;
1755
1756         wined3d_context_vk_end_current_render_pass(context_vk);
1757         command_buffer = wined3d_context_vk_get_command_buffer(context_vk);
1758         if (!query_vk->pool_idx.pool_vk)
1759             wined3d_context_vk_allocate_query(context_vk, query_vk->q.type, &query_vk->pool_idx);
1760         VK_CALL(vkCmdResetQueryPool(command_buffer, query_vk->pool_idx.pool_vk->vk_query_pool,
1761                 query_vk->pool_idx.idx, 1));
1762         VK_CALL(vkCmdWriteTimestamp(command_buffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
1763                 query_vk->pool_idx.pool_vk->vk_query_pool, query_vk->pool_idx.idx));
1764         wined3d_context_vk_reference_query(context_vk, query_vk);
1765
1766         context_release(&context_vk->c);
1767
1768         return TRUE;
1769     }
1770
1771     return FALSE;
1772 }
1773
1774 static const struct wined3d_query_ops wined3d_query_timestamp_vk_ops =
1775 {
1776     .query_poll = wined3d_query_vk_poll,
1777     .query_issue = wined3d_query_timestamp_vk_issue,
1778     .query_destroy = wined3d_query_vk_destroy,
1779 };
1780
1781 static const struct wined3d_query_ops wined3d_query_timestamp_disjoint_vk_ops =
1782 {
1783     .query_poll = wined3d_timestamp_disjoint_query_ops_poll,
1784     .query_issue = wined3d_timestamp_disjoint_query_ops_issue,
1785     .query_destroy = wined3d_query_vk_destroy,
1786 };
1787
1788 HRESULT wined3d_query_vk_create(struct wined3d_device *device, enum wined3d_query_type type,
1789         void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_query **query)
1790 {
1791     struct wined3d_query_data_timestamp_disjoint *disjoint_data;
1792     const struct wined3d_query_ops *ops = &wined3d_query_vk_ops;
1793     struct wined3d_query_vk *query_vk;
1794     unsigned int data_size;
1795     void *data;
1796
1797     TRACE("device %p, type %#x, parent %p, parent_ops %p, query %p.\n",
1798             device, type, parent, parent_ops, query);
1799
1800     switch (type)
1801     {
1802         case WINED3D_QUERY_TYPE_EVENT:
1803             ops = &wined3d_query_event_vk_ops;
1804             data_size = sizeof(BOOL);
1805             break;
1806
1807         case WINED3D_QUERY_TYPE_OCCLUSION:
1808             data_size = sizeof(uint64_t);
1809             break;
1810
1811         case WINED3D_QUERY_TYPE_TIMESTAMP:
1812             if (!wined3d_device_vk(device)->timestamp_bits)
1813             {
1814                 WARN("Timestamp queries not supported.\n");
1815                 return WINED3DERR_NOTAVAILABLE;
1816             }
1817             ops = &wined3d_query_timestamp_vk_ops;
1818             data_size = sizeof(uint64_t);
1819             break;
1820
1821         case WINED3D_QUERY_TYPE_TIMESTAMP_DISJOINT:
1822             if (!wined3d_device_vk(device)->timestamp_bits)
1823             {
1824                 WARN("Timestamp queries not supported.\n");
1825                 return WINED3DERR_NOTAVAILABLE;
1826             }
1827             ops = &wined3d_query_timestamp_disjoint_vk_ops;
1828             data_size = sizeof(struct wined3d_query_data_timestamp_disjoint);
1829             break;
1830
1831         case WINED3D_QUERY_TYPE_PIPELINE_STATISTICS:
1832             data_size = sizeof(struct wined3d_query_data_pipeline_statistics);
1833             break;
1834
1835         case WINED3D_QUERY_TYPE_SO_STATISTICS:
1836         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM0:
1837         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM1:
1838         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM2:
1839         case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM3:
1840             if (!wined3d_adapter_vk(device->adapter)->vk_info.supported[WINED3D_VK_EXT_TRANSFORM_FEEDBACK])
1841             {
1842                 WARN("Stream output queries not supported.\n");
1843                 return WINED3DERR_NOTAVAILABLE;
1844             }
1845             data_size = sizeof(struct wined3d_query_data_so_statistics);
1846             break;
1847
1848         default:
1849             FIXME("Unhandled query type %#x.\n", type);
1850             return WINED3DERR_NOTAVAILABLE;
1851     }
1852
1853     if (!(query_vk = heap_alloc_zero(sizeof(*query_vk) + data_size)))
1854         return E_OUTOFMEMORY;
1855     data = query_vk + 1;
1856
1857     wined3d_query_init(&query_vk->q, device, type, data, data_size, ops, parent, parent_ops);
1858     list_init(&query_vk->entry);
1859
1860     switch (type)
1861     {
1862         case WINED3D_QUERY_TYPE_OCCLUSION:
1863             query_vk->control_flags = VK_QUERY_CONTROL_PRECISE_BIT;
1864             break;
1865
1866         case WINED3D_QUERY_TYPE_TIMESTAMP_DISJOINT:
1867             disjoint_data = data;
1868             disjoint_data->frequency = 1000000000 / wined3d_adapter_vk(device->adapter)->device_limits.timestampPeriod;
1869             disjoint_data->disjoint = FALSE;
1870             break;
1871
1872         default:
1873             break;
1874     }
1875
1876     TRACE("Created query %p.\n", query_vk);
1877     *query = &query_vk->q;
1878
1879     return WINED3D_OK;
1880 }
1881
1882 HRESULT CDECL wined3d_query_create(struct wined3d_device *device, enum wined3d_query_type type,
1883         void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_query **query)
1884 {
1885     TRACE("device %p, type %#x, parent %p, parent_ops %p, query %p.\n",
1886             device, type, parent, parent_ops, query);
1887
1888     return device->adapter->adapter_ops->adapter_create_query(device, type, parent, parent_ops, query);
1889 }