wininet: Support the Cache-Control max-age directive for setting url cache entry...
[wine/testsucceed.git] / dlls / wined3d / query.c
blob368b0308ac653d8d87affa5d666a644fa00e792d
1 /*
2 * IWineD3DQuery implementation
4 * Copyright 2005 Oliver Stieber
5 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
6 * Copyright 2009-2010 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
24 #include "config.h"
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;
45 BOOL fence_result;
47 TRACE("(%p) : device %p\n", query, device);
49 if (!query->context)
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;
64 ENTER_GL();
66 if (gl_info->supported[ARB_SYNC])
68 GLenum gl_ret = GL_EXTCALL(glClientWaitSync(query->object.sync, 0, 0));
69 checkGLcall("glClientWaitSync");
71 switch (gl_ret)
73 case GL_ALREADY_SIGNALED:
74 case GL_CONDITION_SATISFIED:
75 ret = WINED3D_EVENT_QUERY_OK;
76 break;
78 case GL_TIMEOUT_EXPIRED:
79 ret = WINED3D_EVENT_QUERY_WAITING;
80 break;
82 case GL_WAIT_FAILED:
83 default:
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;
102 else
104 ERR("Event query created despite lack of GL support\n");
105 ret = WINED3D_EVENT_QUERY_ERROR;
108 LEAVE_GL();
110 context_release(context);
111 return ret;
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);
122 if (!query->context)
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);
140 ENTER_GL();
141 if (gl_info->supported[ARB_SYNC])
143 GLenum gl_ret = GL_EXTCALL(glClientWaitSync(query->object.sync, 0, ~(GLuint64)0));
144 checkGLcall("glClientWaitSync");
146 switch (gl_ret)
148 case GL_ALREADY_SIGNALED:
149 case GL_CONDITION_SATISFIED:
150 ret = WINED3D_EVENT_QUERY_OK;
151 break;
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;
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;
171 else
173 ERR("Event query created without GL support\n");
174 ret = WINED3D_EVENT_QUERY_ERROR;
176 LEAVE_GL();
178 context_release(context);
179 return ret;
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;
187 if (query->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);
195 else
197 context = context_acquire(device, query->context->current_rt);
200 else
202 context = context_acquire(device, NULL);
203 context_alloc_event_query(context, query);
206 gl_info = context->gl_info;
208 ENTER_GL();
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");
228 LEAVE_GL();
230 context_release(context);
233 ULONG CDECL wined3d_query_incref(struct wined3d_query *query)
235 ULONG refcount = InterlockedIncrement(&query->ref);
237 TRACE("%p increasing refcount to %u.\n", query, refcount);
239 return refcount;
242 ULONG CDECL wined3d_query_decref(struct wined3d_query *query)
244 ULONG refcount = InterlockedIncrement(&query->ref);
246 TRACE("%p decreasing refcount to %u.\n", query, refcount);
248 if (!refcount)
250 /* Queries are specific to the GL context that created them. Not
251 * deleting the query will obviously leak it, but that's still better
252 * than potentially deleting a different query with the same id in this
253 * context, and (still) leaking the actual query. */
254 if (query->type == WINED3DQUERYTYPE_EVENT)
256 struct wined3d_event_query *event_query = query->extendedData;
257 if (event_query) wined3d_event_query_destroy(event_query);
259 else if (query->type == WINED3DQUERYTYPE_OCCLUSION)
261 struct wined3d_occlusion_query *oq = query->extendedData;
263 if (oq->context) context_free_occlusion_query(oq);
264 HeapFree(GetProcessHeap(), 0, query->extendedData);
267 HeapFree(GetProcessHeap(), 0, query);
270 return refcount;
273 HRESULT CDECL wined3d_query_get_data(struct wined3d_query *query,
274 void *data, UINT data_size, DWORD flags)
276 TRACE("query %p, data %p, data_size %u, flags %#x.\n",
277 query, data, data_size, flags);
279 return query->query_ops->query_get_data(query, data, data_size, flags);
282 UINT CDECL wined3d_query_get_data_size(const struct wined3d_query *query)
284 TRACE("query %p.\n", query);
286 return query->data_size;
289 HRESULT CDECL wined3d_query_issue(struct wined3d_query *query, DWORD flags)
291 TRACE("query %p, flags %#x.\n", query, flags);
293 return query->query_ops->query_issue(query, flags);
296 static HRESULT wined3d_occlusion_query_ops_get_data(struct wined3d_query *query,
297 void *pData, DWORD dwSize, DWORD flags)
299 struct wined3d_occlusion_query *oq = query->extendedData;
300 IWineD3DDeviceImpl *device = query->device;
301 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
302 struct wined3d_context *context;
303 DWORD* data = pData;
304 GLuint available;
305 GLuint samples;
306 HRESULT res;
308 TRACE("(%p) : type D3DQUERY_OCCLUSION, pData %p, dwSize %#x, flags %#x.\n", query, pData, dwSize, flags);
310 if (!oq->context)
311 query->state = QUERY_CREATED;
313 if (query->state == QUERY_CREATED)
315 /* D3D allows GetData on a new query, OpenGL doesn't. So just invent the data ourselves */
316 TRACE("Query wasn't yet started, returning S_OK\n");
317 if(data) *data = 0;
318 return S_OK;
321 if (query->state == QUERY_BUILDING)
323 /* Msdn says this returns an error, but our tests show that S_FALSE is returned */
324 TRACE("Query is building, returning S_FALSE\n");
325 return S_FALSE;
328 if (!gl_info->supported[ARB_OCCLUSION_QUERY])
330 WARN("%p Occlusion queries not supported. Returning 1.\n", query);
331 *data = 1;
332 return S_OK;
335 if (oq->context->tid != GetCurrentThreadId())
337 FIXME("%p Wrong thread, returning 1.\n", query);
338 *data = 1;
339 return S_OK;
342 context = context_acquire(query->device, oq->context->current_rt);
344 ENTER_GL();
346 GL_EXTCALL(glGetQueryObjectuivARB(oq->id, GL_QUERY_RESULT_AVAILABLE_ARB, &available));
347 checkGLcall("glGetQueryObjectuivARB(GL_QUERY_RESULT_AVAILABLE)");
348 TRACE("available %#x.\n", available);
350 if (available)
352 if (data)
354 GL_EXTCALL(glGetQueryObjectuivARB(oq->id, GL_QUERY_RESULT_ARB, &samples));
355 checkGLcall("glGetQueryObjectuivARB(GL_QUERY_RESULT)");
356 TRACE("Returning %d samples.\n", samples);
357 *data = samples;
359 res = S_OK;
361 else
363 res = S_FALSE;
366 LEAVE_GL();
368 context_release(context);
370 return res;
373 static HRESULT wined3d_event_query_ops_get_data(struct wined3d_query *query,
374 void *pData, DWORD dwSize, DWORD flags)
376 struct wined3d_event_query *event_query = query->extendedData;
377 BOOL *data = pData;
378 enum wined3d_event_query_result ret;
380 TRACE("query %p, pData %p, dwSize %#x, flags %#x.\n", query, pData, dwSize, flags);
382 if (!pData || !dwSize) return S_OK;
383 if (!event_query)
385 WARN("Event query not supported by GL, reporting GPU idle.\n");
386 *data = TRUE;
387 return S_OK;
390 ret = wined3d_event_query_test(event_query, query->device);
391 switch(ret)
393 case WINED3D_EVENT_QUERY_OK:
394 case WINED3D_EVENT_QUERY_NOT_STARTED:
395 *data = TRUE;
396 break;
398 case WINED3D_EVENT_QUERY_WAITING:
399 *data = FALSE;
400 break;
402 case WINED3D_EVENT_QUERY_WRONG_THREAD:
403 FIXME("(%p) Wrong thread, reporting GPU idle.\n", query);
404 *data = TRUE;
405 break;
407 case WINED3D_EVENT_QUERY_ERROR:
408 ERR("The GL event query failed, returning D3DERR_INVALIDCALL\n");
409 return WINED3DERR_INVALIDCALL;
412 return S_OK;
415 WINED3DQUERYTYPE CDECL wined3d_query_get_type(const struct wined3d_query *query)
417 TRACE("query %p.\n", query);
419 return query->type;
422 static HRESULT wined3d_event_query_ops_issue(struct wined3d_query *query, DWORD flags)
424 TRACE("query %p, flags %#x.\n", query, flags);
426 TRACE("(%p) : flags %#x, type D3DQUERY_EVENT\n", query, flags);
427 if (flags & WINED3DISSUE_END)
429 struct wined3d_event_query *event_query = query->extendedData;
431 /* Faked event query support */
432 if (!event_query) return WINED3D_OK;
434 wined3d_event_query_issue(event_query, query->device);
436 else if (flags & WINED3DISSUE_BEGIN)
438 /* Started implicitly at device creation */
439 ERR("Event query issued with START flag - what to do?\n");
442 if (flags & WINED3DISSUE_BEGIN)
443 query->state = QUERY_BUILDING;
444 else
445 query->state = QUERY_SIGNALLED;
447 return WINED3D_OK;
450 static HRESULT wined3d_occlusion_query_ops_issue(struct wined3d_query *query, DWORD flags)
452 IWineD3DDeviceImpl *device = query->device;
453 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
455 TRACE("query %p, flags %#x.\n", query, flags);
457 if (gl_info->supported[ARB_OCCLUSION_QUERY])
459 struct wined3d_occlusion_query *oq = query->extendedData;
460 struct wined3d_context *context;
462 /* This is allowed according to msdn and our tests. Reset the query and restart */
463 if (flags & WINED3DISSUE_BEGIN)
465 if (query->state == QUERY_BUILDING)
467 if (oq->context->tid != GetCurrentThreadId())
469 FIXME("Wrong thread, can't restart query.\n");
471 context_free_occlusion_query(oq);
472 context = context_acquire(query->device, NULL);
473 context_alloc_occlusion_query(context, oq);
475 else
477 context = context_acquire(query->device, oq->context->current_rt);
479 ENTER_GL();
480 GL_EXTCALL(glEndQueryARB(GL_SAMPLES_PASSED_ARB));
481 checkGLcall("glEndQuery()");
482 LEAVE_GL();
485 else
487 if (oq->context) context_free_occlusion_query(oq);
488 context = context_acquire(query->device, NULL);
489 context_alloc_occlusion_query(context, oq);
492 ENTER_GL();
493 GL_EXTCALL(glBeginQueryARB(GL_SAMPLES_PASSED_ARB, oq->id));
494 checkGLcall("glBeginQuery()");
495 LEAVE_GL();
497 context_release(context);
499 if (flags & WINED3DISSUE_END)
501 /* Msdn says _END on a non-building occlusion query returns an error, but
502 * our tests show that it returns OK. But OpenGL doesn't like it, so avoid
503 * generating an error
505 if (query->state == QUERY_BUILDING)
507 if (oq->context->tid != GetCurrentThreadId())
509 FIXME("Wrong thread, can't end query.\n");
511 else
513 context = context_acquire(query->device, oq->context->current_rt);
515 ENTER_GL();
516 GL_EXTCALL(glEndQueryARB(GL_SAMPLES_PASSED_ARB));
517 checkGLcall("glEndQuery()");
518 LEAVE_GL();
520 context_release(context);
525 else
527 FIXME("%p Occlusion queries not supported.\n", query);
530 if (flags & WINED3DISSUE_BEGIN)
531 query->state = QUERY_BUILDING;
532 else
533 query->state = QUERY_SIGNALLED;
535 return WINED3D_OK; /* can be WINED3DERR_INVALIDCALL. */
538 static const struct wined3d_query_ops event_query_ops =
540 wined3d_event_query_ops_get_data,
541 wined3d_event_query_ops_issue,
544 static const struct wined3d_query_ops occlusion_query_ops =
546 wined3d_occlusion_query_ops_get_data,
547 wined3d_occlusion_query_ops_issue,
550 HRESULT query_init(struct wined3d_query *query, IWineD3DDeviceImpl *device, WINED3DQUERYTYPE type)
552 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
554 switch (type)
556 case WINED3DQUERYTYPE_OCCLUSION:
557 TRACE("Occlusion query.\n");
558 if (!gl_info->supported[ARB_OCCLUSION_QUERY])
560 WARN("Unsupported in local OpenGL implementation: ARB_OCCLUSION_QUERY.\n");
561 return WINED3DERR_NOTAVAILABLE;
563 query->query_ops = &occlusion_query_ops;
564 query->data_size = sizeof(DWORD);
565 query->extendedData = HeapAlloc(GetProcessHeap(), 0, sizeof(struct wined3d_occlusion_query));
566 if (!query->extendedData)
568 ERR("Failed to allocate occlusion query extended data.\n");
569 return E_OUTOFMEMORY;
571 ((struct wined3d_occlusion_query *)query->extendedData)->context = NULL;
572 break;
574 case WINED3DQUERYTYPE_EVENT:
575 TRACE("Event query.\n");
576 if (!wined3d_event_query_supported(gl_info))
578 /* Half-Life 2 needs this query. It does not render the main
579 * menu correctly otherwise. Pretend to support it, faking
580 * this query does not do much harm except potentially
581 * lowering performance. */
582 FIXME("Event query: Unimplemented, but pretending to be supported.\n");
584 query->query_ops = &event_query_ops;
585 query->data_size = sizeof(BOOL);
586 query->extendedData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct wined3d_event_query));
587 if (!query->extendedData)
589 ERR("Failed to allocate event query memory.\n");
590 return E_OUTOFMEMORY;
592 break;
594 case WINED3DQUERYTYPE_VCACHE:
595 case WINED3DQUERYTYPE_RESOURCEMANAGER:
596 case WINED3DQUERYTYPE_VERTEXSTATS:
597 case WINED3DQUERYTYPE_TIMESTAMP:
598 case WINED3DQUERYTYPE_TIMESTAMPDISJOINT:
599 case WINED3DQUERYTYPE_TIMESTAMPFREQ:
600 case WINED3DQUERYTYPE_PIPELINETIMINGS:
601 case WINED3DQUERYTYPE_INTERFACETIMINGS:
602 case WINED3DQUERYTYPE_VERTEXTIMINGS:
603 case WINED3DQUERYTYPE_PIXELTIMINGS:
604 case WINED3DQUERYTYPE_BANDWIDTHTIMINGS:
605 case WINED3DQUERYTYPE_CACHEUTILIZATION:
606 default:
607 FIXME("Unhandled query type %#x.\n", type);
608 return WINED3DERR_NOTAVAILABLE;
611 query->type = type;
612 query->state = QUERY_CREATED;
613 query->device = device;
614 query->ref = 1;
616 return WINED3D_OK;