Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2010 Red Hat Inc. |
| 3 | * |
| 4 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 5 | * copy of this software and associated documentation files (the "Software"), |
| 6 | * to deal in the Software without restriction, including without limitation |
| 7 | * on the rights to use, copy, modify, merge, publish, distribute, sub |
| 8 | * license, and/or sell copies of the Software, and to permit persons to whom |
| 9 | * the Software is furnished to do so, subject to the following conditions: |
| 10 | * |
| 11 | * The above copyright notice and this permission notice (including the next |
| 12 | * paragraph) shall be included in all copies or substantial portions of the |
| 13 | * Software. |
| 14 | * |
| 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| 18 | * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| 19 | * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| 20 | * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| 21 | * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 22 | */ |
| 23 | #include <stdio.h> |
| 24 | #include <errno.h> |
Kai Wasserbäch | 625593f | 2011-08-27 17:51:50 +0200 | [diff] [blame] | 25 | #include "pipe/p_defines.h" |
| 26 | #include "pipe/p_state.h" |
| 27 | #include "pipe/p_context.h" |
| 28 | #include "pipe/p_screen.h" |
| 29 | #include "util/u_memory.h" |
| 30 | #include "util/u_inlines.h" |
| 31 | #include "util/u_format.h" |
Marek Olšák | 55ad59d | 2017-01-27 00:12:37 +0100 | [diff] [blame] | 32 | #include "util/u_upload_mgr.h" |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 33 | #include "noop_public.h" |
Jerome Glisse | 3349517 | 2011-01-09 21:04:41 -0500 | [diff] [blame] | 34 | |
| 35 | DEBUG_GET_ONCE_BOOL_OPTION(noop, "GALLIUM_NOOP", FALSE) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 36 | |
| 37 | void noop_init_state_functions(struct pipe_context *ctx); |
| 38 | |
Jerome Glisse | 3349517 | 2011-01-09 21:04:41 -0500 | [diff] [blame] | 39 | struct noop_pipe_screen { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 40 | struct pipe_screen pscreen; |
| 41 | struct pipe_screen *oscreen; |
Jerome Glisse | 3349517 | 2011-01-09 21:04:41 -0500 | [diff] [blame] | 42 | }; |
| 43 | |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 44 | /* |
| 45 | * query |
| 46 | */ |
| 47 | struct noop_query { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 48 | unsigned query; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 49 | }; |
Ilia Mirkin | 43e4b3e | 2014-06-26 19:33:07 -0400 | [diff] [blame] | 50 | static struct pipe_query *noop_create_query(struct pipe_context *ctx, unsigned query_type, unsigned index) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 51 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 52 | struct noop_query *query = CALLOC_STRUCT(noop_query); |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 53 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 54 | return (struct pipe_query *)query; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 55 | } |
| 56 | |
| 57 | static void noop_destroy_query(struct pipe_context *ctx, struct pipe_query *query) |
| 58 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 59 | FREE(query); |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 60 | } |
| 61 | |
Samuel Pitoiset | 96f164f | 2014-07-05 12:46:03 +0200 | [diff] [blame] | 62 | static boolean noop_begin_query(struct pipe_context *ctx, struct pipe_query *query) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 63 | { |
Samuel Pitoiset | 96f164f | 2014-07-05 12:46:03 +0200 | [diff] [blame] | 64 | return true; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 65 | } |
| 66 | |
Nicolai Hähnle | 32214e0 | 2016-04-20 09:22:48 -0500 | [diff] [blame] | 67 | static bool noop_end_query(struct pipe_context *ctx, struct pipe_query *query) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 68 | { |
Nicolai Hähnle | 32214e0 | 2016-04-20 09:22:48 -0500 | [diff] [blame] | 69 | return true; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 70 | } |
| 71 | |
| 72 | static boolean noop_get_query_result(struct pipe_context *ctx, |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 73 | struct pipe_query *query, |
| 74 | boolean wait, |
| 75 | union pipe_query_result *vresult) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 76 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 77 | uint64_t *result = (uint64_t*)vresult; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 78 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 79 | *result = 0; |
| 80 | return TRUE; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 81 | } |
| 82 | |
Marek Olšák | 26171bd | 2016-04-08 01:42:00 +0200 | [diff] [blame] | 83 | static void |
| 84 | noop_set_active_query_state(struct pipe_context *pipe, boolean enable) |
| 85 | { |
| 86 | } |
| 87 | |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 88 | |
| 89 | /* |
| 90 | * resource |
| 91 | */ |
| 92 | struct noop_resource { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 93 | struct pipe_resource base; |
| 94 | unsigned size; |
| 95 | char *data; |
| 96 | struct sw_displaytarget *dt; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 97 | }; |
| 98 | |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 99 | static struct pipe_resource *noop_resource_create(struct pipe_screen *screen, |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 100 | const struct pipe_resource *templ) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 101 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 102 | struct noop_resource *nresource; |
| 103 | unsigned stride; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 104 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 105 | nresource = CALLOC_STRUCT(noop_resource); |
| 106 | if (!nresource) |
| 107 | return NULL; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 108 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 109 | stride = util_format_get_stride(templ->format, templ->width0); |
| 110 | nresource->base = *templ; |
| 111 | nresource->base.screen = screen; |
| 112 | nresource->size = stride * templ->height0 * templ->depth0; |
| 113 | nresource->data = MALLOC(nresource->size); |
| 114 | pipe_reference_init(&nresource->base.reference, 1); |
| 115 | if (nresource->data == NULL) { |
| 116 | FREE(nresource); |
| 117 | return NULL; |
| 118 | } |
| 119 | return &nresource->base; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 120 | } |
| 121 | |
Jerome Glisse | 3349517 | 2011-01-09 21:04:41 -0500 | [diff] [blame] | 122 | static struct pipe_resource *noop_resource_from_handle(struct pipe_screen *screen, |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 123 | const struct pipe_resource *templ, |
| 124 | struct winsys_handle *handle, |
Marek Olšák | 82db518 | 2016-02-24 18:51:15 +0100 | [diff] [blame] | 125 | unsigned usage) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 126 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 127 | struct noop_pipe_screen *noop_screen = (struct noop_pipe_screen*)screen; |
| 128 | struct pipe_screen *oscreen = noop_screen->oscreen; |
| 129 | struct pipe_resource *result; |
| 130 | struct pipe_resource *noop_resource; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 131 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 132 | result = oscreen->resource_from_handle(oscreen, templ, handle, usage); |
| 133 | noop_resource = noop_resource_create(screen, result); |
| 134 | pipe_resource_reference(&result, NULL); |
| 135 | return noop_resource; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 136 | } |
| 137 | |
Marek Olšák | b012a13 | 2016-08-28 18:50:19 +0200 | [diff] [blame] | 138 | static boolean noop_resource_get_handle(struct pipe_screen *pscreen, |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 139 | struct pipe_context *ctx, |
| 140 | struct pipe_resource *resource, |
| 141 | struct winsys_handle *handle, |
Marek Olšák | 82db518 | 2016-02-24 18:51:15 +0100 | [diff] [blame] | 142 | unsigned usage) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 143 | { |
Marek Olšák | b012a13 | 2016-08-28 18:50:19 +0200 | [diff] [blame] | 144 | struct noop_pipe_screen *noop_screen = (struct noop_pipe_screen*)pscreen; |
| 145 | struct pipe_screen *screen = noop_screen->oscreen; |
| 146 | struct pipe_resource *tex; |
| 147 | bool result; |
| 148 | |
| 149 | /* resource_get_handle musn't fail. Just create something and return it. */ |
| 150 | tex = screen->resource_create(screen, resource); |
| 151 | if (!tex) |
| 152 | return false; |
| 153 | |
| 154 | result = screen->resource_get_handle(screen, NULL, tex, handle, usage); |
| 155 | pipe_resource_reference(&tex, NULL); |
| 156 | return result; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 157 | } |
| 158 | |
| 159 | static void noop_resource_destroy(struct pipe_screen *screen, |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 160 | struct pipe_resource *resource) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 161 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 162 | struct noop_resource *nresource = (struct noop_resource *)resource; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 163 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 164 | FREE(nresource->data); |
| 165 | FREE(resource); |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 166 | } |
| 167 | |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 168 | |
| 169 | /* |
| 170 | * transfer |
| 171 | */ |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 172 | static void *noop_transfer_map(struct pipe_context *pipe, |
Marek Olšák | 369e468 | 2012-10-08 04:06:42 +0200 | [diff] [blame] | 173 | struct pipe_resource *resource, |
| 174 | unsigned level, |
| 175 | enum pipe_transfer_usage usage, |
| 176 | const struct pipe_box *box, |
| 177 | struct pipe_transfer **ptransfer) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 178 | { |
Marek Olšák | 369e468 | 2012-10-08 04:06:42 +0200 | [diff] [blame] | 179 | struct pipe_transfer *transfer; |
| 180 | struct noop_resource *nresource = (struct noop_resource *)resource; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 181 | |
Marek Olšák | 369e468 | 2012-10-08 04:06:42 +0200 | [diff] [blame] | 182 | transfer = CALLOC_STRUCT(pipe_transfer); |
Edward O'Callaghan | 13eb5f5 | 2015-12-04 22:08:22 +1100 | [diff] [blame] | 183 | if (!transfer) |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 184 | return NULL; |
Marek Olšák | 369e468 | 2012-10-08 04:06:42 +0200 | [diff] [blame] | 185 | pipe_resource_reference(&transfer->resource, resource); |
| 186 | transfer->level = level; |
| 187 | transfer->usage = usage; |
| 188 | transfer->box = *box; |
| 189 | transfer->stride = 1; |
| 190 | transfer->layer_stride = 1; |
| 191 | *ptransfer = transfer; |
| 192 | |
| 193 | return nresource->data; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 194 | } |
| 195 | |
| 196 | static void noop_transfer_flush_region(struct pipe_context *pipe, |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 197 | struct pipe_transfer *transfer, |
| 198 | const struct pipe_box *box) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 199 | { |
| 200 | } |
| 201 | |
| 202 | static void noop_transfer_unmap(struct pipe_context *pipe, |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 203 | struct pipe_transfer *transfer) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 204 | { |
Marek Olšák | 369e468 | 2012-10-08 04:06:42 +0200 | [diff] [blame] | 205 | pipe_resource_reference(&transfer->resource, NULL); |
| 206 | FREE(transfer); |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 207 | } |
| 208 | |
Marek Olšák | 1ffe77e | 2016-07-16 21:19:48 +0200 | [diff] [blame] | 209 | static void noop_buffer_subdata(struct pipe_context *pipe, |
| 210 | struct pipe_resource *resource, |
| 211 | unsigned usage, unsigned offset, |
| 212 | unsigned size, const void *data) |
| 213 | { |
| 214 | } |
| 215 | |
| 216 | static void noop_texture_subdata(struct pipe_context *pipe, |
| 217 | struct pipe_resource *resource, |
| 218 | unsigned level, |
| 219 | unsigned usage, |
| 220 | const struct pipe_box *box, |
| 221 | const void *data, |
| 222 | unsigned stride, |
| 223 | unsigned layer_stride) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 224 | { |
| 225 | } |
| 226 | |
| 227 | |
| 228 | /* |
| 229 | * clear/copy |
| 230 | */ |
| 231 | static void noop_clear(struct pipe_context *ctx, unsigned buffers, |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 232 | const union pipe_color_union *color, double depth, unsigned stencil) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 233 | { |
| 234 | } |
| 235 | |
| 236 | static void noop_clear_render_target(struct pipe_context *ctx, |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 237 | struct pipe_surface *dst, |
| 238 | const union pipe_color_union *color, |
| 239 | unsigned dstx, unsigned dsty, |
| 240 | unsigned width, unsigned height, |
| 241 | bool render_condition_enabled) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 242 | { |
| 243 | } |
| 244 | |
| 245 | static void noop_clear_depth_stencil(struct pipe_context *ctx, |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 246 | struct pipe_surface *dst, |
| 247 | unsigned clear_flags, |
| 248 | double depth, |
| 249 | unsigned stencil, |
| 250 | unsigned dstx, unsigned dsty, |
| 251 | unsigned width, unsigned height, |
| 252 | bool render_condition_enabled) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 253 | { |
| 254 | } |
| 255 | |
| 256 | static void noop_resource_copy_region(struct pipe_context *ctx, |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 257 | struct pipe_resource *dst, |
| 258 | unsigned dst_level, |
| 259 | unsigned dstx, unsigned dsty, unsigned dstz, |
| 260 | struct pipe_resource *src, |
| 261 | unsigned src_level, |
| 262 | const struct pipe_box *src_box) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 263 | { |
| 264 | } |
| 265 | |
| 266 | |
Marek Olšák | 2a309dc | 2012-09-13 00:12:22 +0200 | [diff] [blame] | 267 | static void noop_blit(struct pipe_context *ctx, |
| 268 | const struct pipe_blit_info *info) |
| 269 | { |
| 270 | } |
| 271 | |
| 272 | |
Marek Olšák | 419cd5f | 2013-09-20 15:08:29 +0200 | [diff] [blame] | 273 | static void |
| 274 | noop_flush_resource(struct pipe_context *ctx, |
| 275 | struct pipe_resource *resource) |
| 276 | { |
| 277 | } |
| 278 | |
| 279 | |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 280 | /* |
| 281 | * context |
| 282 | */ |
Marek Olšák | 7e02303 | 2011-03-08 00:57:48 +0100 | [diff] [blame] | 283 | static void noop_flush(struct pipe_context *ctx, |
Marek Olšák | 598cc1f | 2012-12-21 17:03:22 +0100 | [diff] [blame] | 284 | struct pipe_fence_handle **fence, |
Chia-I Wu | 8c347d4 | 2013-05-02 16:25:15 +0800 | [diff] [blame] | 285 | unsigned flags) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 286 | { |
Marek Olšák | 1c71bcc | 2016-08-28 13:58:16 +0200 | [diff] [blame] | 287 | if (fence) |
| 288 | *fence = NULL; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 289 | } |
| 290 | |
| 291 | static void noop_destroy_context(struct pipe_context *ctx) |
| 292 | { |
Marek Olšák | 55ad59d | 2017-01-27 00:12:37 +0100 | [diff] [blame] | 293 | if (ctx->stream_uploader) |
| 294 | u_upload_destroy(ctx->stream_uploader); |
| 295 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 296 | FREE(ctx); |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 297 | } |
| 298 | |
Marek Olšák | 1c71bcc | 2016-08-28 13:58:16 +0200 | [diff] [blame] | 299 | static boolean noop_generate_mipmap(struct pipe_context *ctx, |
| 300 | struct pipe_resource *resource, |
| 301 | enum pipe_format format, |
| 302 | unsigned base_level, |
| 303 | unsigned last_level, |
| 304 | unsigned first_layer, |
| 305 | unsigned last_layer) |
| 306 | { |
| 307 | return true; |
| 308 | } |
| 309 | |
Marek Olšák | 0fc21ec | 2015-07-25 18:40:59 +0200 | [diff] [blame] | 310 | static struct pipe_context *noop_create_context(struct pipe_screen *screen, |
| 311 | void *priv, unsigned flags) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 312 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 313 | struct pipe_context *ctx = CALLOC_STRUCT(pipe_context); |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 314 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 315 | if (!ctx) |
| 316 | return NULL; |
Marek Olšák | 55ad59d | 2017-01-27 00:12:37 +0100 | [diff] [blame] | 317 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 318 | ctx->screen = screen; |
| 319 | ctx->priv = priv; |
Marek Olšák | 55ad59d | 2017-01-27 00:12:37 +0100 | [diff] [blame] | 320 | |
| 321 | ctx->stream_uploader = u_upload_create_default(ctx); |
| 322 | if (!ctx->stream_uploader) { |
| 323 | FREE(ctx); |
| 324 | return NULL; |
| 325 | } |
| 326 | ctx->const_uploader = ctx->stream_uploader; |
| 327 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 328 | ctx->destroy = noop_destroy_context; |
| 329 | ctx->flush = noop_flush; |
| 330 | ctx->clear = noop_clear; |
| 331 | ctx->clear_render_target = noop_clear_render_target; |
| 332 | ctx->clear_depth_stencil = noop_clear_depth_stencil; |
| 333 | ctx->resource_copy_region = noop_resource_copy_region; |
Marek Olšák | 1c71bcc | 2016-08-28 13:58:16 +0200 | [diff] [blame] | 334 | ctx->generate_mipmap = noop_generate_mipmap; |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 335 | ctx->blit = noop_blit; |
| 336 | ctx->flush_resource = noop_flush_resource; |
| 337 | ctx->create_query = noop_create_query; |
| 338 | ctx->destroy_query = noop_destroy_query; |
| 339 | ctx->begin_query = noop_begin_query; |
| 340 | ctx->end_query = noop_end_query; |
| 341 | ctx->get_query_result = noop_get_query_result; |
| 342 | ctx->set_active_query_state = noop_set_active_query_state; |
| 343 | ctx->transfer_map = noop_transfer_map; |
| 344 | ctx->transfer_flush_region = noop_transfer_flush_region; |
| 345 | ctx->transfer_unmap = noop_transfer_unmap; |
| 346 | ctx->buffer_subdata = noop_buffer_subdata; |
| 347 | ctx->texture_subdata = noop_texture_subdata; |
| 348 | noop_init_state_functions(ctx); |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 349 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 350 | return ctx; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 351 | } |
| 352 | |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 353 | |
| 354 | /* |
| 355 | * pipe_screen |
| 356 | */ |
| 357 | static void noop_flush_frontbuffer(struct pipe_screen *_screen, |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 358 | struct pipe_resource *resource, |
| 359 | unsigned level, unsigned layer, |
| 360 | void *context_private, struct pipe_box *box) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 361 | { |
| 362 | } |
| 363 | |
| 364 | static const char *noop_get_vendor(struct pipe_screen* pscreen) |
| 365 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 366 | return "X.Org"; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 367 | } |
| 368 | |
Giuseppe Bilotta | 76039b3 | 2015-03-22 07:21:01 +0100 | [diff] [blame] | 369 | static const char *noop_get_device_vendor(struct pipe_screen* pscreen) |
| 370 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 371 | return "NONE"; |
Giuseppe Bilotta | 76039b3 | 2015-03-22 07:21:01 +0100 | [diff] [blame] | 372 | } |
| 373 | |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 374 | static const char *noop_get_name(struct pipe_screen* pscreen) |
| 375 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 376 | return "NOOP"; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 377 | } |
| 378 | |
| 379 | static int noop_get_param(struct pipe_screen* pscreen, enum pipe_cap param) |
| 380 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 381 | struct pipe_screen *screen = ((struct noop_pipe_screen*)pscreen)->oscreen; |
Dave Airlie | 185d862 | 2010-11-18 18:10:55 +1000 | [diff] [blame] | 382 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 383 | return screen->get_param(screen, param); |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 384 | } |
| 385 | |
Marek Olšák | bb71f92 | 2011-11-19 22:38:22 +0100 | [diff] [blame] | 386 | static float noop_get_paramf(struct pipe_screen* pscreen, |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 387 | enum pipe_capf param) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 388 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 389 | struct pipe_screen *screen = ((struct noop_pipe_screen*)pscreen)->oscreen; |
Marek Olšák | 21c5d11 | 2011-08-15 19:37:33 +0200 | [diff] [blame] | 390 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 391 | return screen->get_paramf(screen, param); |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 392 | } |
| 393 | |
Brian Paul | 637e571 | 2017-03-05 12:13:02 -0700 | [diff] [blame] | 394 | static int noop_get_shader_param(struct pipe_screen* pscreen, |
| 395 | enum pipe_shader_type shader, |
| 396 | enum pipe_shader_cap param) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 397 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 398 | struct pipe_screen *screen = ((struct noop_pipe_screen*)pscreen)->oscreen; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 399 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 400 | return screen->get_shader_param(screen, shader, param); |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 401 | } |
| 402 | |
Marek Olšák | 1c71bcc | 2016-08-28 13:58:16 +0200 | [diff] [blame] | 403 | static int noop_get_compute_param(struct pipe_screen *pscreen, |
| 404 | enum pipe_shader_ir ir_type, |
| 405 | enum pipe_compute_cap param, |
| 406 | void *ret) |
| 407 | { |
| 408 | struct pipe_screen *screen = ((struct noop_pipe_screen*)pscreen)->oscreen; |
| 409 | |
| 410 | return screen->get_compute_param(screen, ir_type, param, ret); |
| 411 | } |
| 412 | |
Marek Olšák | 21c5d11 | 2011-08-15 19:37:33 +0200 | [diff] [blame] | 413 | static boolean noop_is_format_supported(struct pipe_screen* pscreen, |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 414 | enum pipe_format format, |
| 415 | enum pipe_texture_target target, |
| 416 | unsigned sample_count, |
Marek Olšák | e968975 | 2011-03-08 00:01:58 +0100 | [diff] [blame] | 417 | unsigned usage) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 418 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 419 | struct pipe_screen *screen = ((struct noop_pipe_screen*)pscreen)->oscreen; |
Marek Olšák | 21c5d11 | 2011-08-15 19:37:33 +0200 | [diff] [blame] | 420 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 421 | return screen->is_format_supported(screen, format, target, sample_count, usage); |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 422 | } |
| 423 | |
Marek Olšák | e66d90e | 2012-07-10 18:46:08 +0200 | [diff] [blame] | 424 | static uint64_t noop_get_timestamp(struct pipe_screen *pscreen) |
| 425 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 426 | return 0; |
Marek Olšák | e66d90e | 2012-07-10 18:46:08 +0200 | [diff] [blame] | 427 | } |
| 428 | |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 429 | static void noop_destroy_screen(struct pipe_screen *screen) |
| 430 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 431 | struct noop_pipe_screen *noop_screen = (struct noop_pipe_screen*)screen; |
| 432 | struct pipe_screen *oscreen = noop_screen->oscreen; |
Jerome Glisse | 3349517 | 2011-01-09 21:04:41 -0500 | [diff] [blame] | 433 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 434 | oscreen->destroy(oscreen); |
| 435 | FREE(screen); |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 436 | } |
| 437 | |
Marek Olšák | 1c71bcc | 2016-08-28 13:58:16 +0200 | [diff] [blame] | 438 | static void noop_fence_reference(struct pipe_screen *screen, |
| 439 | struct pipe_fence_handle **ptr, |
| 440 | struct pipe_fence_handle *fence) |
| 441 | { |
| 442 | } |
| 443 | |
| 444 | static boolean noop_fence_finish(struct pipe_screen *screen, |
| 445 | struct pipe_context *ctx, |
| 446 | struct pipe_fence_handle *fence, |
| 447 | uint64_t timeout) |
| 448 | { |
| 449 | return true; |
| 450 | } |
| 451 | |
| 452 | static void noop_query_memory_info(struct pipe_screen *pscreen, |
| 453 | struct pipe_memory_info *info) |
| 454 | { |
| 455 | struct noop_pipe_screen *noop_screen = (struct noop_pipe_screen*)pscreen; |
| 456 | struct pipe_screen *screen = noop_screen->oscreen; |
| 457 | |
| 458 | screen->query_memory_info(screen, info); |
| 459 | } |
| 460 | |
Jerome Glisse | 3349517 | 2011-01-09 21:04:41 -0500 | [diff] [blame] | 461 | struct pipe_screen *noop_screen_create(struct pipe_screen *oscreen) |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 462 | { |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 463 | struct noop_pipe_screen *noop_screen; |
| 464 | struct pipe_screen *screen; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 465 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 466 | if (!debug_get_option_noop()) { |
| 467 | return oscreen; |
| 468 | } |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 469 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 470 | noop_screen = CALLOC_STRUCT(noop_pipe_screen); |
| 471 | if (!noop_screen) { |
| 472 | return NULL; |
| 473 | } |
| 474 | noop_screen->oscreen = oscreen; |
| 475 | screen = &noop_screen->pscreen; |
Jerome Glisse | 3349517 | 2011-01-09 21:04:41 -0500 | [diff] [blame] | 476 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 477 | screen->destroy = noop_destroy_screen; |
| 478 | screen->get_name = noop_get_name; |
| 479 | screen->get_vendor = noop_get_vendor; |
| 480 | screen->get_device_vendor = noop_get_device_vendor; |
| 481 | screen->get_param = noop_get_param; |
| 482 | screen->get_shader_param = noop_get_shader_param; |
Marek Olšák | 1c71bcc | 2016-08-28 13:58:16 +0200 | [diff] [blame] | 483 | screen->get_compute_param = noop_get_compute_param; |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 484 | screen->get_paramf = noop_get_paramf; |
| 485 | screen->is_format_supported = noop_is_format_supported; |
| 486 | screen->context_create = noop_create_context; |
| 487 | screen->resource_create = noop_resource_create; |
| 488 | screen->resource_from_handle = noop_resource_from_handle; |
| 489 | screen->resource_get_handle = noop_resource_get_handle; |
| 490 | screen->resource_destroy = noop_resource_destroy; |
| 491 | screen->flush_frontbuffer = noop_flush_frontbuffer; |
| 492 | screen->get_timestamp = noop_get_timestamp; |
Marek Olšák | 1c71bcc | 2016-08-28 13:58:16 +0200 | [diff] [blame] | 493 | screen->fence_reference = noop_fence_reference; |
| 494 | screen->fence_finish = noop_fence_finish; |
| 495 | screen->query_memory_info = noop_query_memory_info; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 496 | |
Marek Olšák | 1276316 | 2016-08-21 12:41:29 +0200 | [diff] [blame] | 497 | return screen; |
Jerome Glisse | 5da2469 | 2010-11-15 14:53:21 -0500 | [diff] [blame] | 498 | } |