2 * IWineD3DQuery implementation
4 * Copyright 2005 Oliver Stieber
5 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
6 * Copyright 2009 Henri Verbeet for CodeWeavers.
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.
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.
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
25 #include "wined3d_private.h"
27 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
29 BOOL wined3d_event_query_supported(const struct wined3d_gl_info *gl_info)
31 return gl_info->supported[ARB_SYNC] || gl_info->supported[NV_FENCE] || gl_info->supported[APPLE_FENCE];
34 void wined3d_event_query_destroy(struct wined3d_event_query *query)
36 if (query->context) context_free_event_query(query);
37 HeapFree(GetProcessHeap(), 0, query);
40 enum wined3d_event_query_result wined3d_event_query_test(struct wined3d_event_query *query, IWineD3DDeviceImpl *device)
42 struct wined3d_context *context;
43 const struct wined3d_gl_info *gl_info;
44 enum wined3d_event_query_result ret;
47 TRACE("(%p) : device %p\n", query, device);
49 if (query->context == NULL)
51 TRACE("Query not started\n");
52 return WINED3D_EVENT_QUERY_NOT_STARTED;
55 if (!query->context->gl_info->supported[ARB_SYNC] && query->context->tid != GetCurrentThreadId())
57 WARN("Event query tested from wrong thread\n");
58 return WINED3D_EVENT_QUERY_WRONG_THREAD;
61 context = context_acquire(device, query->context->current_rt);
62 gl_info = context->gl_info;
66 if (gl_info->supported[ARB_SYNC])
68 GLenum gl_ret = GL_EXTCALL(glClientWaitSync(query->object.sync, 0, 0));
69 checkGLcall("glClientWaitSync");
73 case GL_ALREADY_SIGNALED:
74 case GL_CONDITION_SATISFIED:
75 ret = WINED3D_EVENT_QUERY_OK;
78 case GL_TIMEOUT_EXPIRED:
79 ret = WINED3D_EVENT_QUERY_WAITING;
84 ERR("glClientWaitSync returned %#x.\n", gl_ret);
85 ret = WINED3D_EVENT_QUERY_ERROR;
88 else if (gl_info->supported[APPLE_FENCE])
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;
95 else if (gl_info->supported[NV_FENCE])
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;
104 ERR("Event query created despite lack of GL support\n");
105 ret = WINED3D_EVENT_QUERY_ERROR;
110 context_release(context);
114 enum wined3d_event_query_result wined3d_event_query_finish(struct wined3d_event_query *query, IWineD3DDeviceImpl *device)
116 struct wined3d_context *context;
117 const struct wined3d_gl_info *gl_info;
118 enum wined3d_event_query_result ret;
120 TRACE("(%p)\n", query);
124 TRACE("Query not started\n");
125 return WINED3D_EVENT_QUERY_NOT_STARTED;
127 gl_info = query->context->gl_info;
129 if (query->context->tid != GetCurrentThreadId() && !gl_info->supported[ARB_SYNC])
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
134 WARN("Event query finished from wrong thread\n");
135 return WINED3D_EVENT_QUERY_WRONG_THREAD;
138 context = context_acquire(device, query->context->current_rt);
141 if (gl_info->supported[ARB_SYNC])
143 GLenum gl_ret = GL_EXTCALL(glClientWaitSync(query->object.sync, 0, ~(GLuint64)0));
144 checkGLcall("glClientWaitSync");
148 case GL_ALREADY_SIGNALED:
149 case GL_CONDITION_SATISFIED:
150 ret = WINED3D_EVENT_QUERY_OK;
153 /* We don't expect a timeout for a ~584 year wait */
155 ERR("glClientWaitSync returned %#x.\n", gl_ret);
156 ret = WINED3D_EVENT_QUERY_ERROR;
159 else if (context->gl_info->supported[APPLE_FENCE])
161 GL_EXTCALL(glFinishFenceAPPLE(query->object.id));
162 checkGLcall("glFinishFenceAPPLE");
163 ret = WINED3D_EVENT_QUERY_OK;
165 else if (context->gl_info->supported[NV_FENCE])
167 GL_EXTCALL(glFinishFenceNV(query->object.id));
168 checkGLcall("glFinishFenceNV");
169 ret = WINED3D_EVENT_QUERY_OK;
173 ERR("Event query created without GL support\n");
174 ret = WINED3D_EVENT_QUERY_ERROR;
178 context_release(context);
182 void wined3d_event_query_issue(struct wined3d_event_query *query, IWineD3DDeviceImpl *device)
184 const struct wined3d_gl_info *gl_info;
185 struct wined3d_context *context;
189 if (!query->context->gl_info->supported[ARB_SYNC] && query->context->tid != GetCurrentThreadId())
191 context_free_event_query(query);
192 context = context_acquire(device, NULL);
193 context_alloc_event_query(context, query);
197 context = context_acquire(device, query->context->current_rt);
202 context = context_acquire(device, NULL);
203 context_alloc_event_query(context, query);
206 gl_info = context->gl_info;
210 if (gl_info->supported[ARB_SYNC])
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");
217 else if (gl_info->supported[APPLE_FENCE])
219 GL_EXTCALL(glSetFenceAPPLE(query->object.id));
220 checkGLcall("glSetFenceAPPLE");
222 else if (gl_info->supported[NV_FENCE])
224 GL_EXTCALL(glSetFenceNV(query->object.id, GL_ALL_COMPLETED_NV));
225 checkGLcall("glSetFenceNV");
230 context_release(context);
233 static HRESULT WINAPI IWineD3DQueryImpl_QueryInterface(IWineD3DQuery *iface, REFIID riid, void **object)
235 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
237 if (IsEqualGUID(riid, &IID_IWineD3DQuery)
238 || IsEqualGUID(riid, &IID_IUnknown))
240 IUnknown_AddRef(iface);
245 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
248 return E_NOINTERFACE;
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);
257 static ULONG WINAPI IWineD3DQueryImpl_Release(IWineD3DQuery *iface) {
258 IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
260 TRACE("(%p) : Releasing from %d\n", This, This->ref);
261 ref = InterlockedDecrement(&This->ref);
263 /* Queries are specific to the GL context that created them. Not
264 * deleting the query will obviously leak it, but that's still better
265 * than potentially deleting a different query with the same id in this
266 * context, and (still) leaking the actual query. */
267 if (This->type == WINED3DQUERYTYPE_EVENT)
269 struct wined3d_event_query *query = This->extendedData;
270 if (query) wined3d_event_query_destroy(query);
272 else if (This->type == WINED3DQUERYTYPE_OCCLUSION)
274 struct wined3d_occlusion_query *query = This->extendedData;
276 if (query->context) context_free_occlusion_query(query);
277 HeapFree(GetProcessHeap(), 0, This->extendedData);
280 HeapFree(GetProcessHeap(), 0, This);
285 static HRESULT WINAPI IWineD3DOcclusionQueryImpl_GetData(IWineD3DQuery* iface, void* pData, DWORD dwSize, DWORD dwGetDataFlags) {
286 IWineD3DQueryImpl *This = (IWineD3DQueryImpl *) iface;
287 struct wined3d_occlusion_query *query = This->extendedData;
288 IWineD3DDeviceImpl *device = This->device;
289 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
290 struct wined3d_context *context;
296 TRACE("(%p) : type D3DQUERY_OCCLUSION, pData %p, dwSize %#x, dwGetDataFlags %#x\n", This, pData, dwSize, dwGetDataFlags);
298 if (!query->context) This->state = QUERY_CREATED;
300 if (This->state == QUERY_CREATED)
302 /* D3D allows GetData on a new query, OpenGL doesn't. So just invent the data ourselves */
303 TRACE("Query wasn't yet started, returning S_OK\n");
308 if (This->state == QUERY_BUILDING)
310 /* Msdn says this returns an error, but our tests show that S_FALSE is returned */
311 TRACE("Query is building, returning S_FALSE\n");
315 if (!gl_info->supported[ARB_OCCLUSION_QUERY])
317 WARN("(%p) : Occlusion queries not supported. Returning 1.\n", This);
322 if (query->context->tid != GetCurrentThreadId())
324 FIXME("%p Wrong thread, returning 1.\n", This);
329 context = context_acquire(This->device, query->context->current_rt);
333 GL_EXTCALL(glGetQueryObjectuivARB(query->id, GL_QUERY_RESULT_AVAILABLE_ARB, &available));
334 checkGLcall("glGetQueryObjectuivARB(GL_QUERY_RESULT_AVAILABLE)");
335 TRACE("(%p) : available %d.\n", This, available);
341 GL_EXTCALL(glGetQueryObjectuivARB(query->id, GL_QUERY_RESULT_ARB, &samples));
342 checkGLcall("glGetQueryObjectuivARB(GL_QUERY_RESULT)");
343 TRACE("(%p) : Returning %d samples.\n", This, samples);
355 context_release(context);
360 static HRESULT WINAPI IWineD3DEventQueryImpl_GetData(IWineD3DQuery* iface, void* pData, DWORD dwSize, DWORD dwGetDataFlags) {
361 IWineD3DQueryImpl *This = (IWineD3DQueryImpl *) iface;
362 struct wined3d_event_query *query = This->extendedData;
364 enum wined3d_event_query_result ret;
366 TRACE("(%p) : type D3DQUERY_EVENT, pData %p, dwSize %#x, dwGetDataFlags %#x\n", This, pData, dwSize, dwGetDataFlags);
368 if (!pData || !dwSize) return S_OK;
371 WARN("(%p): Event query not supported by GL, reporting GPU idle\n", This);
376 ret = wined3d_event_query_test(query, This->device);
379 case WINED3D_EVENT_QUERY_OK:
380 case WINED3D_EVENT_QUERY_NOT_STARTED:
384 case WINED3D_EVENT_QUERY_WAITING:
388 case WINED3D_EVENT_QUERY_WRONG_THREAD:
389 FIXME("(%p) Wrong thread, reporting GPU idle.\n", This);
393 case WINED3D_EVENT_QUERY_ERROR:
394 ERR("The GL event query failed, returning D3DERR_INVALIDCALL\n");
395 return WINED3DERR_INVALIDCALL;
401 static DWORD WINAPI IWineD3DEventQueryImpl_GetDataSize(IWineD3DQuery* iface){
402 TRACE("(%p) : type D3DQUERY_EVENT\n", iface);
407 static DWORD WINAPI IWineD3DOcclusionQueryImpl_GetDataSize(IWineD3DQuery* iface){
408 TRACE("(%p) : type D3DQUERY_OCCLUSION\n", iface);
410 return sizeof(DWORD);
413 static WINED3DQUERYTYPE WINAPI IWineD3DQueryImpl_GetType(IWineD3DQuery* iface){
414 IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
418 static HRESULT WINAPI IWineD3DEventQueryImpl_Issue(IWineD3DQuery* iface, DWORD dwIssueFlags) {
419 IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
421 TRACE("(%p) : dwIssueFlags %#x, type D3DQUERY_EVENT\n", This, dwIssueFlags);
422 if (dwIssueFlags & WINED3DISSUE_END)
424 struct wined3d_event_query *query = This->extendedData;
426 /* Faked event query support */
427 if (!query) return WINED3D_OK;
429 wined3d_event_query_issue(query, This->device);
431 else if(dwIssueFlags & WINED3DISSUE_BEGIN)
433 /* Started implicitly at device creation */
434 ERR("Event query issued with START flag - what to do?\n");
437 if(dwIssueFlags & WINED3DISSUE_BEGIN) {
438 This->state = QUERY_BUILDING;
440 This->state = QUERY_SIGNALLED;
446 static HRESULT WINAPI IWineD3DOcclusionQueryImpl_Issue(IWineD3DQuery* iface, DWORD dwIssueFlags) {
447 IWineD3DQueryImpl *This = (IWineD3DQueryImpl *)iface;
448 IWineD3DDeviceImpl *device = This->device;
449 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
451 if (gl_info->supported[ARB_OCCLUSION_QUERY])
453 struct wined3d_occlusion_query *query = This->extendedData;
454 struct wined3d_context *context;
456 /* This is allowed according to msdn and our tests. Reset the query and restart */
457 if (dwIssueFlags & WINED3DISSUE_BEGIN)
459 if (This->state == QUERY_BUILDING)
461 if (query->context->tid != GetCurrentThreadId())
463 FIXME("Wrong thread, can't restart query.\n");
465 context_free_occlusion_query(query);
466 context = context_acquire(This->device, NULL);
467 context_alloc_occlusion_query(context, query);
471 context = context_acquire(This->device, query->context->current_rt);
474 GL_EXTCALL(glEndQueryARB(GL_SAMPLES_PASSED_ARB));
475 checkGLcall("glEndQuery()");
481 if (query->context) context_free_occlusion_query(query);
482 context = context_acquire(This->device, NULL);
483 context_alloc_occlusion_query(context, query);
487 GL_EXTCALL(glBeginQueryARB(GL_SAMPLES_PASSED_ARB, query->id));
488 checkGLcall("glBeginQuery()");
491 context_release(context);
493 if (dwIssueFlags & WINED3DISSUE_END) {
494 /* Msdn says _END on a non-building occlusion query returns an error, but
495 * our tests show that it returns OK. But OpenGL doesn't like it, so avoid
496 * generating an error
498 if (This->state == QUERY_BUILDING)
500 if (query->context->tid != GetCurrentThreadId())
502 FIXME("Wrong thread, can't end query.\n");
506 context = context_acquire(This->device, query->context->current_rt);
509 GL_EXTCALL(glEndQueryARB(GL_SAMPLES_PASSED_ARB));
510 checkGLcall("glEndQuery()");
513 context_release(context);
518 FIXME("(%p) : Occlusion queries not supported\n", This);
521 if(dwIssueFlags & WINED3DISSUE_BEGIN) {
522 This->state = QUERY_BUILDING;
524 This->state = QUERY_SIGNALLED;
526 return WINED3D_OK; /* can be WINED3DERR_INVALIDCALL. */
529 static const IWineD3DQueryVtbl IWineD3DEventQuery_Vtbl =
531 /*** IUnknown methods ***/
532 IWineD3DQueryImpl_QueryInterface,
533 IWineD3DQueryImpl_AddRef,
534 IWineD3DQueryImpl_Release,
535 /*** IWineD3Dquery methods ***/
536 IWineD3DEventQueryImpl_GetData,
537 IWineD3DEventQueryImpl_GetDataSize,
538 IWineD3DQueryImpl_GetType,
539 IWineD3DEventQueryImpl_Issue
542 static const IWineD3DQueryVtbl IWineD3DOcclusionQuery_Vtbl =
544 /*** IUnknown methods ***/
545 IWineD3DQueryImpl_QueryInterface,
546 IWineD3DQueryImpl_AddRef,
547 IWineD3DQueryImpl_Release,
548 /*** IWineD3Dquery methods ***/
549 IWineD3DOcclusionQueryImpl_GetData,
550 IWineD3DOcclusionQueryImpl_GetDataSize,
551 IWineD3DQueryImpl_GetType,
552 IWineD3DOcclusionQueryImpl_Issue
555 HRESULT query_init(IWineD3DQueryImpl *query, IWineD3DDeviceImpl *device, WINED3DQUERYTYPE type)
557 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
561 case WINED3DQUERYTYPE_OCCLUSION:
562 TRACE("Occlusion query.\n");
563 if (!gl_info->supported[ARB_OCCLUSION_QUERY])
565 WARN("Unsupported in local OpenGL implementation: ARB_OCCLUSION_QUERY.\n");
566 return WINED3DERR_NOTAVAILABLE;
568 query->lpVtbl = &IWineD3DOcclusionQuery_Vtbl;
569 query->extendedData = HeapAlloc(GetProcessHeap(), 0, sizeof(struct wined3d_occlusion_query));
570 if (!query->extendedData)
572 ERR("Failed to allocate occlusion query extended data.\n");
573 return E_OUTOFMEMORY;
575 ((struct wined3d_occlusion_query *)query->extendedData)->context = NULL;
578 case WINED3DQUERYTYPE_EVENT:
579 TRACE("Event query.\n");
580 if (!wined3d_event_query_supported(gl_info))
582 /* Half-Life 2 needs this query. It does not render the main
583 * menu correctly otherwise. Pretend to support it, faking
584 * this query does not do much harm except potentially
585 * lowering performance. */
586 FIXME("Event query: Unimplemented, but pretending to be supported.\n");
588 query->lpVtbl = &IWineD3DEventQuery_Vtbl;
589 query->extendedData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct wined3d_event_query));
590 if (!query->extendedData)
592 ERR("Failed to allocate event query memory.\n");
593 return E_OUTOFMEMORY;
597 case WINED3DQUERYTYPE_VCACHE:
598 case WINED3DQUERYTYPE_RESOURCEMANAGER:
599 case WINED3DQUERYTYPE_VERTEXSTATS:
600 case WINED3DQUERYTYPE_TIMESTAMP:
601 case WINED3DQUERYTYPE_TIMESTAMPDISJOINT:
602 case WINED3DQUERYTYPE_TIMESTAMPFREQ:
603 case WINED3DQUERYTYPE_PIPELINETIMINGS:
604 case WINED3DQUERYTYPE_INTERFACETIMINGS:
605 case WINED3DQUERYTYPE_VERTEXTIMINGS:
606 case WINED3DQUERYTYPE_PIXELTIMINGS:
607 case WINED3DQUERYTYPE_BANDWIDTHTIMINGS:
608 case WINED3DQUERYTYPE_CACHEUTILIZATION:
610 FIXME("Unhandled query type %#x.\n", type);
611 return WINED3DERR_NOTAVAILABLE;
615 query->state = QUERY_CREATED;
616 query->device = device;