dlls/wined3d/query.c

   1 /*
   2  * IWineD3DQuery implementation
   3  *
   4  * Copyright 2005 Oliver Stieber
   5  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
   6  * Copyright 2009-2010 Henri Verbeet for CodeWeavers.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23
  24 #include "config.h"
  25 #include "wined3d_private.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  28
  29 BOOL wined3d_event_query_supported(const struct wined3d_gl_info *gl_info)
  30 {
  31     return gl_info->supported[ARB_SYNC] || gl_info->supported[NV_FENCE] || gl_info->supported[APPLE_FENCE];
  32 }
  33
  34 void wined3d_event_query_destroy(struct wined3d_event_query *query)
  35 {
  36     if (query->context) context_free_event_query(query);
  37     HeapFree(GetProcessHeap(), 0, query);
  38 }
  39
  40 enum wined3d_event_query_result wined3d_event_query_test(struct wined3d_event_query *query, IWineD3DDeviceImpl *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     ENTER_GL();
  65
  66     if (gl_info->supported[ARB_SYNC])
  67     {
  68         GLenum gl_ret = GL_EXTCALL(glClientWaitSync(query->object.sync, 0, 0));
  69         checkGLcall("glClientWaitSync");
  70
  71         switch (gl_ret)
  72         {
  73             case GL_ALREADY_SIGNALED:
  74             case GL_CONDITION_SATISFIED:
  75                 ret = WINED3D_EVENT_QUERY_OK;
  76                 break;
  77
  78             case GL_TIMEOUT_EXPIRED:
  79                 ret = WINED3D_EVENT_QUERY_WAITING;
  80                 break;
  81
  82             case GL_WAIT_FAILED:
  83             default:
  84                 ERR("glClientWaitSync returned %#x.\n", gl_ret);
  85                 ret = WINED3D_EVENT_QUERY_ERROR;
  86         }
  87     }
  88     else if (gl_info->supported[APPLE_FENCE])
  89     {
  90         fence_result = GL_EXTCALL(glTestFenceAPPLE(query->object.id));
  91         checkGLcall("glTestFenceAPPLE");
  92         if (fence_result) ret = WINED3D_EVENT_QUERY_OK;
  93         else ret = WINED3D_EVENT_QUERY_WAITING;
  94     }
  95     else if (gl_info->supported[NV_FENCE])
  96     {
  97         fence_result = GL_EXTCALL(glTestFenceNV(query->object.id));
  98         checkGLcall("glTestFenceNV");
  99         if (fence_result) ret = WINED3D_EVENT_QUERY_OK;
 100         else ret = WINED3D_EVENT_QUERY_WAITING;
 101     }
 102     else
 103     {
 104         ERR("Event query created despite lack of GL support\n");
 105         ret = WINED3D_EVENT_QUERY_ERROR;
 106     }
 107
 108     LEAVE_GL();
 109
 110     context_release(context);
 111     return ret;
 112 }
 113
 114 enum wined3d_event_query_result wined3d_event_query_finish(struct wined3d_event_query *query, IWineD3DDeviceImpl *device)
 115 {
 116     struct wined3d_context *context;
 117     const struct wined3d_gl_info *gl_info;
 118     enum wined3d_event_query_result ret;
 119
 120     TRACE("(%p)\n", query);
 121
 122     if (!query->context)
 123     {
 124         TRACE("Query not started\n");
 125         return WINED3D_EVENT_QUERY_NOT_STARTED;
 126     }
 127     gl_info = query->context->gl_info;
 128
 129     if (query->context->tid != GetCurrentThreadId() && !gl_info->supported[ARB_SYNC])
 130     {
 131         /* A glFinish does not reliably wait for draws in other contexts. The caller has
 132          * to find its own way to cope with the thread switch
 133          */
 134         WARN("Event query finished from wrong thread\n");
 135         return WINED3D_EVENT_QUERY_WRONG_THREAD;
 136     }
 137
 138     context = context_acquire(device, query->context->current_rt);
 139
 140     ENTER_GL();
 141     if (gl_info->supported[ARB_SYNC])
 142     {
 143         GLenum gl_ret = GL_EXTCALL(glClientWaitSync(query->object.sync, 0, ~(GLuint64)0));
 144         checkGLcall("glClientWaitSync");
 145
 146         switch (gl_ret)
 147         {
 148             case GL_ALREADY_SIGNALED:
 149             case GL_CONDITION_SATISFIED:
 150                 ret = WINED3D_EVENT_QUERY_OK;
 151                 break;
 152
 153                 /* We don't expect a timeout for a ~584 year wait */
 154             default:
 155                 ERR("glClientWaitSync returned %#x.\n", gl_ret);
 156                 ret = WINED3D_EVENT_QUERY_ERROR;
 157         }
 158     }
 159     else if (context->gl_info->supported[APPLE_FENCE])
 160     {
 161         GL_EXTCALL(glFinishFenceAPPLE(query->object.id));
 162         checkGLcall("glFinishFenceAPPLE");
 163         ret = WINED3D_EVENT_QUERY_OK;
 164     }
 165     else if (context->gl_info->supported[NV_FENCE])
 166     {
 167         GL_EXTCALL(glFinishFenceNV(query->object.id));
 168         checkGLcall("glFinishFenceNV");
 169         ret = WINED3D_EVENT_QUERY_OK;
 170     }
 171     else
 172     {
 173         ERR("Event query created without GL support\n");
 174         ret = WINED3D_EVENT_QUERY_ERROR;
 175     }
 176     LEAVE_GL();
 177
 178     context_release(context);
 179     return ret;
 180 }
 181
 182 void wined3d_event_query_issue(struct wined3d_event_query *query, IWineD3DDeviceImpl *device)
 183 {
 184     const struct wined3d_gl_info *gl_info;
 185     struct wined3d_context *context;
 186
 187     if (query->context)
 188     {
 189         if (!query->context->gl_info->supported[ARB_SYNC] && query->context->tid != GetCurrentThreadId())
 190         {
 191             context_free_event_query(query);
 192             context = context_acquire(device, NULL);
 193             context_alloc_event_query(context, query);
 194         }
 195         else
 196         {
 197             context = context_acquire(device, query->context->current_rt);
 198         }
 199     }
 200     else
 201     {
 202         context = context_acquire(device, NULL);
 203         context_alloc_event_query(context, query);
 204     }
 205
 206     gl_info = context->gl_info;
 207
 208     ENTER_GL();
 209
 210     if (gl_info->supported[ARB_SYNC])
 211     {
 212         if (query->object.sync) GL_EXTCALL(glDeleteSync(query->object.sync));
 213         checkGLcall("glDeleteSync");
 214         query->object.sync = GL_EXTCALL(glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0));
 215         checkGLcall("glFenceSync");
 216     }
 217     else if (gl_info->supported[APPLE_FENCE])
 218     {
 219         GL_EXTCALL(glSetFenceAPPLE(query->object.id));
 220         checkGLcall("glSetFenceAPPLE");
 221     }
 222     else if (gl_info->supported[NV_FENCE])
 223     {
 224         GL_EXTCALL(glSetFenceNV(query->object.id, GL_ALL_COMPLETED_NV));
 225         checkGLcall("glSetFenceNV");
 226     }
 227
 228     LEAVE_GL();
 229
 230     context_release(context);
 231 }
 232
 233 static HRESULT  WINAPI IWineD3DQueryImpl_QueryInterface(IWineD3DQuery *iface, REFIID riid, void **object)
 234 {
 235     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 236
 237     if (IsEqualGUID(riid, &IID_IWineD3DQuery)
 238             || IsEqualGUID(riid, &IID_IUnknown))
 239     {
 240         IUnknown_AddRef(iface);
 241         *object = iface;
 242         return S_OK;
 243     }
 244
 245     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 246
 247     *object = NULL;
 248     return E_NOINTERFACE;
 249 }
 250
 251 static ULONG  WINAPI IWineD3DQueryImpl_AddRef(IWineD3DQuery *iface) {
 252     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
 253     TRACE("(%p) : AddRef increasing from %d\n", This, This->ref);
 254     return InterlockedIncrement(&This->ref);
 255 }
 256
 257 static ULONG  WINAPI IWineD3DQueryImpl_Release(IWineD3DQuery *iface) {
 258     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
 259     ULONG ref;
 260     TRACE("(%p) : Releasing from %d\n", This, This->ref);
 261     ref = InterlockedDecrement(&This->ref);
 262
 263     if (!ref)
 264     {
 265         /* Queries are specific to the GL context that created them. Not
 266          * deleting the query will obviously leak it, but that's still better
 267          * than potentially deleting a different query with the same id in this
 268          * context, and (still) leaking the actual query. */
 269         if (This->type == WINED3DQUERYTYPE_EVENT)
 270         {
 271             struct wined3d_event_query *query = This->extendedData;
 272             if (query) wined3d_event_query_destroy(query);
 273         }
 274         else if (This->type == WINED3DQUERYTYPE_OCCLUSION)
 275         {
 276             struct wined3d_occlusion_query *query = This->extendedData;
 277
 278             if (query->context) context_free_occlusion_query(query);
 279             HeapFree(GetProcessHeap(), 0, This->extendedData);
 280         }
 281
 282         HeapFree(GetProcessHeap(), 0, This);
 283     }
 284     return ref;
 285 }
 286
 287 static HRESULT WINAPI IWineD3DQueryImpl_GetData(IWineD3DQuery *iface,
 288         void *data, DWORD data_size, DWORD flags)
 289 {
 290     struct IWineD3DQueryImpl *query = (struct IWineD3DQueryImpl *)iface;
 291
 292     TRACE("iface %p, data %p, data_size %u, flags %#x.\n",
 293             iface, data, data_size, flags);
 294
 295     return query->query_ops->query_get_data(query, data, data_size, flags);
 296 }
 297
 298 static DWORD WINAPI IWineD3DQueryImpl_GetDataSize(IWineD3DQuery *iface)
 299 {
 300     struct IWineD3DQueryImpl *query = (struct IWineD3DQueryImpl *)iface;
 301
 302     TRACE("iface %p.\n", iface);
 303
 304     return query->data_size;
 305 }
 306
 307 static HRESULT WINAPI IWineD3DQueryImpl_Issue(IWineD3DQuery *iface, DWORD flags)
 308 {
 309     struct IWineD3DQueryImpl *query = (struct IWineD3DQueryImpl *)iface;
 310
 311     TRACE("iface %p, flags %#x.\n", iface, flags);
 312
 313     return query->query_ops->query_issue(query, flags);
 314 }
 315
 316 static HRESULT wined3d_occlusion_query_ops_get_data(struct IWineD3DQueryImpl *query,
 317         void *pData, DWORD dwSize, DWORD flags)
 318 {
 319     struct wined3d_occlusion_query *oq = query->extendedData;
 320     IWineD3DDeviceImpl *device = query->device;
 321     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 322     struct wined3d_context *context;
 323     DWORD* data = pData;
 324     GLuint available;
 325     GLuint samples;
 326     HRESULT res;
 327
 328     TRACE("(%p) : type D3DQUERY_OCCLUSION, pData %p, dwSize %#x, flags %#x.\n", query, pData, dwSize, flags);
 329
 330     if (!oq->context)
 331         query->state = QUERY_CREATED;
 332
 333     if (query->state == QUERY_CREATED)
 334     {
 335         /* D3D allows GetData on a new query, OpenGL doesn't. So just invent the data ourselves */
 336         TRACE("Query wasn't yet started, returning S_OK\n");
 337         if(data) *data = 0;
 338         return S_OK;
 339     }
 340
 341     if (query->state == QUERY_BUILDING)
 342     {
 343         /* Msdn says this returns an error, but our tests show that S_FALSE is returned */
 344         TRACE("Query is building, returning S_FALSE\n");
 345         return S_FALSE;
 346     }
 347
 348     if (!gl_info->supported[ARB_OCCLUSION_QUERY])
 349     {
 350         WARN("%p Occlusion queries not supported. Returning 1.\n", query);
 351         *data = 1;
 352         return S_OK;
 353     }
 354
 355     if (oq->context->tid != GetCurrentThreadId())
 356     {
 357         FIXME("%p Wrong thread, returning 1.\n", query);
 358         *data = 1;
 359         return S_OK;
 360     }
 361
 362     context = context_acquire(query->device, oq->context->current_rt);
 363
 364     ENTER_GL();
 365
 366     GL_EXTCALL(glGetQueryObjectuivARB(oq->id, GL_QUERY_RESULT_AVAILABLE_ARB, &available));
 367     checkGLcall("glGetQueryObjectuivARB(GL_QUERY_RESULT_AVAILABLE)");
 368     TRACE("available %#x.\n", available);
 369
 370     if (available)
 371     {
 372         if (data)
 373         {
 374             GL_EXTCALL(glGetQueryObjectuivARB(oq->id, GL_QUERY_RESULT_ARB, &samples));
 375             checkGLcall("glGetQueryObjectuivARB(GL_QUERY_RESULT)");
 376             TRACE("Returning %d samples.\n", samples);
 377             *data = samples;
 378         }
 379         res = S_OK;
 380     }
 381     else
 382     {
 383         res = S_FALSE;
 384     }
 385
 386     LEAVE_GL();
 387
 388     context_release(context);
 389
 390     return res;
 391 }
 392
 393 static HRESULT wined3d_event_query_ops_get_data(IWineD3DQueryImpl *query,
 394         void *pData, DWORD dwSize, DWORD flags)
 395 {
 396     struct wined3d_event_query *event_query = query->extendedData;
 397     BOOL *data = pData;
 398     enum wined3d_event_query_result ret;
 399
 400     TRACE("query %p, pData %p, dwSize %#x, flags %#x.\n", query, pData, dwSize, flags);
 401
 402     if (!pData || !dwSize) return S_OK;
 403     if (!event_query)
 404     {
 405         WARN("Event query not supported by GL, reporting GPU idle.\n");
 406         *data = TRUE;
 407         return S_OK;
 408     }
 409
 410     ret = wined3d_event_query_test(event_query, query->device);
 411     switch(ret)
 412     {
 413         case WINED3D_EVENT_QUERY_OK:
 414         case WINED3D_EVENT_QUERY_NOT_STARTED:
 415             *data = TRUE;
 416             break;
 417
 418         case WINED3D_EVENT_QUERY_WAITING:
 419             *data = FALSE;
 420             break;
 421
 422         case WINED3D_EVENT_QUERY_WRONG_THREAD:
 423             FIXME("(%p) Wrong thread, reporting GPU idle.\n", query);
 424             *data = TRUE;
 425             break;
 426
 427         case WINED3D_EVENT_QUERY_ERROR:
 428             ERR("The GL event query failed, returning D3DERR_INVALIDCALL\n");
 429             return WINED3DERR_INVALIDCALL;
 430     }
 431
 432     return S_OK;
 433 }
 434
 435 static WINED3DQUERYTYPE  WINAPI IWineD3DQueryImpl_GetType(IWineD3DQuery* iface){
 436     IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
 437     return This->type;
 438 }
 439
 440 static HRESULT wined3d_event_query_ops_issue(struct IWineD3DQueryImpl *query, DWORD flags)
 441 {
 442     TRACE("query %p, flags %#x.\n", query, flags);
 443
 444     TRACE("(%p) : flags %#x, type D3DQUERY_EVENT\n", query, flags);
 445     if (flags & WINED3DISSUE_END)
 446     {
 447         struct wined3d_event_query *event_query = query->extendedData;
 448
 449         /* Faked event query support */
 450         if (!event_query) return WINED3D_OK;
 451
 452         wined3d_event_query_issue(event_query, query->device);
 453     }
 454     else if (flags & WINED3DISSUE_BEGIN)
 455     {
 456         /* Started implicitly at device creation */
 457         ERR("Event query issued with START flag - what to do?\n");
 458     }
 459
 460     if (flags & WINED3DISSUE_BEGIN)
 461         query->state = QUERY_BUILDING;
 462     else
 463         query->state = QUERY_SIGNALLED;
 464
 465     return WINED3D_OK;
 466 }
 467
 468 static HRESULT wined3d_occlusion_query_ops_issue(struct IWineD3DQueryImpl *query, DWORD flags)
 469 {
 470     IWineD3DDeviceImpl *device = query->device;
 471     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 472
 473     TRACE("query %p, flags %#x.\n", query, flags);
 474
 475     if (gl_info->supported[ARB_OCCLUSION_QUERY])
 476     {
 477         struct wined3d_occlusion_query *oq = query->extendedData;
 478         struct wined3d_context *context;
 479
 480         /* This is allowed according to msdn and our tests. Reset the query and restart */
 481         if (flags & WINED3DISSUE_BEGIN)
 482         {
 483             if (query->state == QUERY_BUILDING)
 484             {
 485                 if (oq->context->tid != GetCurrentThreadId())
 486                 {
 487                     FIXME("Wrong thread, can't restart query.\n");
 488
 489                     context_free_occlusion_query(oq);
 490                     context = context_acquire(query->device, NULL);
 491                     context_alloc_occlusion_query(context, oq);
 492                 }
 493                 else
 494                 {
 495                     context = context_acquire(query->device, oq->context->current_rt);
 496
 497                     ENTER_GL();
 498                     GL_EXTCALL(glEndQueryARB(GL_SAMPLES_PASSED_ARB));
 499                     checkGLcall("glEndQuery()");
 500                     LEAVE_GL();
 501                 }
 502             }
 503             else
 504             {
 505                 if (oq->context) context_free_occlusion_query(oq);
 506                 context = context_acquire(query->device, NULL);
 507                 context_alloc_occlusion_query(context, oq);
 508             }
 509
 510             ENTER_GL();
 511             GL_EXTCALL(glBeginQueryARB(GL_SAMPLES_PASSED_ARB, oq->id));
 512             checkGLcall("glBeginQuery()");
 513             LEAVE_GL();
 514
 515             context_release(context);
 516         }
 517         if (flags & WINED3DISSUE_END)
 518         {
 519             /* Msdn says _END on a non-building occlusion query returns an error, but
 520              * our tests show that it returns OK. But OpenGL doesn't like it, so avoid
 521              * generating an error
 522              */
 523             if (query->state == QUERY_BUILDING)
 524             {
 525                 if (oq->context->tid != GetCurrentThreadId())
 526                 {
 527                     FIXME("Wrong thread, can't end query.\n");
 528                 }
 529                 else
 530                 {
 531                     context = context_acquire(query->device, oq->context->current_rt);
 532
 533                     ENTER_GL();
 534                     GL_EXTCALL(glEndQueryARB(GL_SAMPLES_PASSED_ARB));
 535                     checkGLcall("glEndQuery()");
 536                     LEAVE_GL();
 537
 538                     context_release(context);
 539                 }
 540             }
 541         }
 542     }
 543     else
 544     {
 545         FIXME("%p Occlusion queries not supported.\n", query);
 546     }
 547
 548     if (flags & WINED3DISSUE_BEGIN)
 549         query->state = QUERY_BUILDING;
 550     else
 551         query->state = QUERY_SIGNALLED;
 552
 553     return WINED3D_OK; /* can be WINED3DERR_INVALIDCALL.    */
 554 }
 555
 556 static const struct wined3d_query_ops event_query_ops =
 557 {
 558     wined3d_event_query_ops_get_data,
 559     wined3d_event_query_ops_issue,
 560 };
 561
 562 static const struct wined3d_query_ops occlusion_query_ops =
 563 {
 564     wined3d_occlusion_query_ops_get_data,
 565     wined3d_occlusion_query_ops_issue,
 566 };
 567
 568 static const struct IWineD3DQueryVtbl IWineD3DQuery_Vtbl =
 569 {
 570     /*** IUnknown methods ***/
 571     IWineD3DQueryImpl_QueryInterface,
 572     IWineD3DQueryImpl_AddRef,
 573     IWineD3DQueryImpl_Release,
 574     /*** IWineD3Dquery methods ***/
 575     IWineD3DQueryImpl_GetData,
 576     IWineD3DQueryImpl_GetDataSize,
 577     IWineD3DQueryImpl_GetType,
 578     IWineD3DQueryImpl_Issue,
 579 };
 580
 581 HRESULT query_init(IWineD3DQueryImpl *query, IWineD3DDeviceImpl *device, WINED3DQUERYTYPE type)
 582 {
 583     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 584
 585     switch (type)
 586     {
 587         case WINED3DQUERYTYPE_OCCLUSION:
 588             TRACE("Occlusion query.\n");
 589             if (!gl_info->supported[ARB_OCCLUSION_QUERY])
 590             {
 591                 WARN("Unsupported in local OpenGL implementation: ARB_OCCLUSION_QUERY.\n");
 592                 return WINED3DERR_NOTAVAILABLE;
 593             }
 594             query->query_ops = &occlusion_query_ops;
 595             query->data_size = sizeof(DWORD);
 596             query->extendedData = HeapAlloc(GetProcessHeap(), 0, sizeof(struct wined3d_occlusion_query));
 597             if (!query->extendedData)
 598             {
 599                 ERR("Failed to allocate occlusion query extended data.\n");
 600                 return E_OUTOFMEMORY;
 601             }
 602             ((struct wined3d_occlusion_query *)query->extendedData)->context = NULL;
 603             break;
 604
 605         case WINED3DQUERYTYPE_EVENT:
 606             TRACE("Event query.\n");
 607             if (!wined3d_event_query_supported(gl_info))
 608             {
 609                 /* Half-Life 2 needs this query. It does not render the main
 610                  * menu correctly otherwise. Pretend to support it, faking
 611                  * this query does not do much harm except potentially
 612                  * lowering performance. */
 613                 FIXME("Event query: Unimplemented, but pretending to be supported.\n");
 614             }
 615             query->query_ops = &event_query_ops;
 616             query->data_size = sizeof(BOOL);
 617             query->extendedData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct wined3d_event_query));
 618             if (!query->extendedData)
 619             {
 620                 ERR("Failed to allocate event query memory.\n");
 621                 return E_OUTOFMEMORY;
 622             }
 623             break;
 624
 625         case WINED3DQUERYTYPE_VCACHE:
 626         case WINED3DQUERYTYPE_RESOURCEMANAGER:
 627         case WINED3DQUERYTYPE_VERTEXSTATS:
 628         case WINED3DQUERYTYPE_TIMESTAMP:
 629         case WINED3DQUERYTYPE_TIMESTAMPDISJOINT:
 630         case WINED3DQUERYTYPE_TIMESTAMPFREQ:
 631         case WINED3DQUERYTYPE_PIPELINETIMINGS:
 632         case WINED3DQUERYTYPE_INTERFACETIMINGS:
 633         case WINED3DQUERYTYPE_VERTEXTIMINGS:
 634         case WINED3DQUERYTYPE_PIXELTIMINGS:
 635         case WINED3DQUERYTYPE_BANDWIDTHTIMINGS:
 636         case WINED3DQUERYTYPE_CACHEUTILIZATION:
 637         default:
 638             FIXME("Unhandled query type %#x.\n", type);
 639             return WINED3DERR_NOTAVAILABLE;
 640     }
 641
 642     query->lpVtbl = &IWineD3DQuery_Vtbl;
 643     query->type = type;
 644     query->state = QUERY_CREATED;
 645     query->device = device;
 646     query->ref = 1;
 647
 648     return WINED3D_OK;
 649 }