"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.8/src/gallium/auxiliary/driver_noop/noop_pipe.c" (16 Sep 2020, 18482 Bytes) of package /linux/misc/mesa-20.1.8.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "noop_pipe.c" see the Fossies "Dox" file reference documentation.

    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>
   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/format/u_format.h"
   32 #include "util/u_upload_mgr.h"
   33 #include "noop_public.h"
   34 
   35 DEBUG_GET_ONCE_BOOL_OPTION(noop, "GALLIUM_NOOP", false)
   36 
   37 void noop_init_state_functions(struct pipe_context *ctx);
   38 
   39 struct noop_pipe_screen {
   40    struct pipe_screen   pscreen;
   41    struct pipe_screen   *oscreen;
   42 };
   43 
   44 /*
   45  * query
   46  */
   47 struct noop_query {
   48    unsigned query;
   49 };
   50 static struct pipe_query *noop_create_query(struct pipe_context *ctx, unsigned query_type, unsigned index)
   51 {
   52    struct noop_query *query = CALLOC_STRUCT(noop_query);
   53 
   54    return (struct pipe_query *)query;
   55 }
   56 
   57 static void noop_destroy_query(struct pipe_context *ctx, struct pipe_query *query)
   58 {
   59    FREE(query);
   60 }
   61 
   62 static bool noop_begin_query(struct pipe_context *ctx, struct pipe_query *query)
   63 {
   64    return true;
   65 }
   66 
   67 static bool noop_end_query(struct pipe_context *ctx, struct pipe_query *query)
   68 {
   69    return true;
   70 }
   71 
   72 static bool noop_get_query_result(struct pipe_context *ctx,
   73                                   struct pipe_query *query,
   74                                   bool wait,
   75                                   union pipe_query_result *vresult)
   76 {
   77    uint64_t *result = (uint64_t*)vresult;
   78 
   79    *result = 0;
   80    return true;
   81 }
   82 
   83 static void
   84 noop_set_active_query_state(struct pipe_context *pipe, bool enable)
   85 {
   86 }
   87 
   88 
   89 /*
   90  * resource
   91  */
   92 struct noop_resource {
   93    struct pipe_resource base;
   94    unsigned     size;
   95    char         *data;
   96    struct sw_displaytarget  *dt;
   97 };
   98 
   99 static struct pipe_resource *noop_resource_create(struct pipe_screen *screen,
  100                                                   const struct pipe_resource *templ)
  101 {
  102    struct noop_resource *nresource;
  103    unsigned stride;
  104 
  105    nresource = CALLOC_STRUCT(noop_resource);
  106    if (!nresource)
  107       return NULL;
  108 
  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;
  120 }
  121 
  122 static struct pipe_resource *noop_resource_from_handle(struct pipe_screen *screen,
  123                                                        const struct pipe_resource *templ,
  124                                                        struct winsys_handle *handle,
  125                                                        unsigned usage)
  126 {
  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;
  131 
  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;
  136 }
  137 
  138 static bool noop_resource_get_handle(struct pipe_screen *pscreen,
  139                                      struct pipe_context *ctx,
  140                                      struct pipe_resource *resource,
  141                                      struct winsys_handle *handle,
  142                                      unsigned usage)
  143 {
  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;
  157 }
  158 
  159 static bool noop_resource_get_param(struct pipe_screen *pscreen,
  160                                     struct pipe_context *ctx,
  161                                     struct pipe_resource *resource,
  162                                     unsigned plane,
  163                                     unsigned layer,
  164                                     enum pipe_resource_param param,
  165                                     unsigned handle_usage,
  166                                     uint64_t *value)
  167 {
  168    struct noop_pipe_screen *noop_screen = (struct noop_pipe_screen*)pscreen;
  169    struct pipe_screen *screen = noop_screen->oscreen;
  170    struct pipe_resource *tex;
  171    bool result;
  172 
  173    /* resource_get_param mustn't fail. Just create something and return it. */
  174    tex = screen->resource_create(screen, resource);
  175    if (!tex)
  176       return false;
  177 
  178    result = screen->resource_get_param(screen, NULL, tex, 0, 0, param,
  179                                        handle_usage, value);
  180    pipe_resource_reference(&tex, NULL);
  181    return result;
  182 }
  183 
  184 static void noop_resource_destroy(struct pipe_screen *screen,
  185                                   struct pipe_resource *resource)
  186 {
  187    struct noop_resource *nresource = (struct noop_resource *)resource;
  188 
  189    FREE(nresource->data);
  190    FREE(resource);
  191 }
  192 
  193 
  194 /*
  195  * transfer
  196  */
  197 static void *noop_transfer_map(struct pipe_context *pipe,
  198                                struct pipe_resource *resource,
  199                                unsigned level,
  200                                unsigned usage,
  201                                const struct pipe_box *box,
  202                                struct pipe_transfer **ptransfer)
  203 {
  204    struct pipe_transfer *transfer;
  205    struct noop_resource *nresource = (struct noop_resource *)resource;
  206 
  207    transfer = CALLOC_STRUCT(pipe_transfer);
  208    if (!transfer)
  209       return NULL;
  210    pipe_resource_reference(&transfer->resource, resource);
  211    transfer->level = level;
  212    transfer->usage = usage;
  213    transfer->box = *box;
  214    transfer->stride = 1;
  215    transfer->layer_stride = 1;
  216    *ptransfer = transfer;
  217 
  218    return nresource->data;
  219 }
  220 
  221 static void noop_transfer_flush_region(struct pipe_context *pipe,
  222                                        struct pipe_transfer *transfer,
  223                                        const struct pipe_box *box)
  224 {
  225 }
  226 
  227 static void noop_transfer_unmap(struct pipe_context *pipe,
  228                                 struct pipe_transfer *transfer)
  229 {
  230    pipe_resource_reference(&transfer->resource, NULL);
  231    FREE(transfer);
  232 }
  233 
  234 static void noop_buffer_subdata(struct pipe_context *pipe,
  235                                 struct pipe_resource *resource,
  236                                 unsigned usage, unsigned offset,
  237                                 unsigned size, const void *data)
  238 {
  239 }
  240 
  241 static void noop_texture_subdata(struct pipe_context *pipe,
  242                                  struct pipe_resource *resource,
  243                                  unsigned level,
  244                                  unsigned usage,
  245                                  const struct pipe_box *box,
  246                                  const void *data,
  247                                  unsigned stride,
  248                                  unsigned layer_stride)
  249 {
  250 }
  251 
  252 
  253 /*
  254  * clear/copy
  255  */
  256 static void noop_clear(struct pipe_context *ctx, unsigned buffers, const struct pipe_scissor_state *scissor_state,
  257                        const union pipe_color_union *color, double depth, unsigned stencil)
  258 {
  259 }
  260 
  261 static void noop_clear_render_target(struct pipe_context *ctx,
  262                                      struct pipe_surface *dst,
  263                                      const union pipe_color_union *color,
  264                                      unsigned dstx, unsigned dsty,
  265                                      unsigned width, unsigned height,
  266                                      bool render_condition_enabled)
  267 {
  268 }
  269 
  270 static void noop_clear_depth_stencil(struct pipe_context *ctx,
  271                                      struct pipe_surface *dst,
  272                                      unsigned clear_flags,
  273                                      double depth,
  274                                      unsigned stencil,
  275                                      unsigned dstx, unsigned dsty,
  276                                      unsigned width, unsigned height,
  277                                      bool render_condition_enabled)
  278 {
  279 }
  280 
  281 static void noop_resource_copy_region(struct pipe_context *ctx,
  282                                       struct pipe_resource *dst,
  283                                       unsigned dst_level,
  284                                       unsigned dstx, unsigned dsty, unsigned dstz,
  285                                       struct pipe_resource *src,
  286                                       unsigned src_level,
  287                                       const struct pipe_box *src_box)
  288 {
  289 }
  290 
  291 
  292 static void noop_blit(struct pipe_context *ctx,
  293                       const struct pipe_blit_info *info)
  294 {
  295 }
  296 
  297 
  298 static void
  299 noop_flush_resource(struct pipe_context *ctx,
  300                     struct pipe_resource *resource)
  301 {
  302 }
  303 
  304 
  305 /*
  306  * context
  307  */
  308 static void noop_flush(struct pipe_context *ctx,
  309                        struct pipe_fence_handle **fence,
  310                        unsigned flags)
  311 {
  312    if (fence)
  313       *fence = NULL;
  314 }
  315 
  316 static void noop_destroy_context(struct pipe_context *ctx)
  317 {
  318    if (ctx->stream_uploader)
  319       u_upload_destroy(ctx->stream_uploader);
  320 
  321    FREE(ctx);
  322 }
  323 
  324 static bool noop_generate_mipmap(struct pipe_context *ctx,
  325                                  struct pipe_resource *resource,
  326                                  enum pipe_format format,
  327                                  unsigned base_level,
  328                                  unsigned last_level,
  329                                  unsigned first_layer,
  330                                  unsigned last_layer)
  331 {
  332    return true;
  333 }
  334 
  335 static void noop_invalidate_resource(struct pipe_context *ctx,
  336                                      struct pipe_resource *resource)
  337 {
  338 }
  339 
  340 static void noop_set_context_param(struct pipe_context *ctx,
  341                                    enum pipe_context_param param,
  342                                    unsigned value)
  343 {
  344 }
  345 
  346 static struct pipe_context *noop_create_context(struct pipe_screen *screen,
  347                                                 void *priv, unsigned flags)
  348 {
  349    struct pipe_context *ctx = CALLOC_STRUCT(pipe_context);
  350 
  351    if (!ctx)
  352       return NULL;
  353 
  354    ctx->screen = screen;
  355    ctx->priv = priv;
  356 
  357    ctx->stream_uploader = u_upload_create_default(ctx);
  358    if (!ctx->stream_uploader) {
  359       FREE(ctx);
  360       return NULL;
  361    }
  362    ctx->const_uploader = ctx->stream_uploader;
  363 
  364    ctx->destroy = noop_destroy_context;
  365    ctx->flush = noop_flush;
  366    ctx->clear = noop_clear;
  367    ctx->clear_render_target = noop_clear_render_target;
  368    ctx->clear_depth_stencil = noop_clear_depth_stencil;
  369    ctx->resource_copy_region = noop_resource_copy_region;
  370    ctx->generate_mipmap = noop_generate_mipmap;
  371    ctx->blit = noop_blit;
  372    ctx->flush_resource = noop_flush_resource;
  373    ctx->create_query = noop_create_query;
  374    ctx->destroy_query = noop_destroy_query;
  375    ctx->begin_query = noop_begin_query;
  376    ctx->end_query = noop_end_query;
  377    ctx->get_query_result = noop_get_query_result;
  378    ctx->set_active_query_state = noop_set_active_query_state;
  379    ctx->transfer_map = noop_transfer_map;
  380    ctx->transfer_flush_region = noop_transfer_flush_region;
  381    ctx->transfer_unmap = noop_transfer_unmap;
  382    ctx->buffer_subdata = noop_buffer_subdata;
  383    ctx->texture_subdata = noop_texture_subdata;
  384    ctx->invalidate_resource = noop_invalidate_resource;
  385    ctx->set_context_param = noop_set_context_param;
  386    noop_init_state_functions(ctx);
  387 
  388    return ctx;
  389 }
  390 
  391 
  392 /*
  393  * pipe_screen
  394  */
  395 static void noop_flush_frontbuffer(struct pipe_screen *_screen,
  396                                    struct pipe_resource *resource,
  397                                    unsigned level, unsigned layer,
  398                                    void *context_private, struct pipe_box *box)
  399 {
  400 }
  401 
  402 static const char *noop_get_vendor(struct pipe_screen* pscreen)
  403 {
  404    return "X.Org";
  405 }
  406 
  407 static const char *noop_get_device_vendor(struct pipe_screen* pscreen)
  408 {
  409    return "NONE";
  410 }
  411 
  412 static const char *noop_get_name(struct pipe_screen* pscreen)
  413 {
  414    return "NOOP";
  415 }
  416 
  417 static int noop_get_param(struct pipe_screen* pscreen, enum pipe_cap param)
  418 {
  419    struct pipe_screen *screen = ((struct noop_pipe_screen*)pscreen)->oscreen;
  420 
  421    return screen->get_param(screen, param);
  422 }
  423 
  424 static float noop_get_paramf(struct pipe_screen* pscreen,
  425                              enum pipe_capf param)
  426 {
  427    struct pipe_screen *screen = ((struct noop_pipe_screen*)pscreen)->oscreen;
  428 
  429    return screen->get_paramf(screen, param);
  430 }
  431 
  432 static int noop_get_shader_param(struct pipe_screen* pscreen,
  433                                  enum pipe_shader_type shader,
  434                                  enum pipe_shader_cap param)
  435 {
  436    struct pipe_screen *screen = ((struct noop_pipe_screen*)pscreen)->oscreen;
  437 
  438    return screen->get_shader_param(screen, shader, param);
  439 }
  440 
  441 static int noop_get_compute_param(struct pipe_screen *pscreen,
  442                                   enum pipe_shader_ir ir_type,
  443                                   enum pipe_compute_cap param,
  444                                   void *ret)
  445 {
  446    struct pipe_screen *screen = ((struct noop_pipe_screen*)pscreen)->oscreen;
  447 
  448    return screen->get_compute_param(screen, ir_type, param, ret);
  449 }
  450 
  451 static bool noop_is_format_supported(struct pipe_screen* pscreen,
  452                                      enum pipe_format format,
  453                                      enum pipe_texture_target target,
  454                                      unsigned sample_count,
  455                                      unsigned storage_sample_count,
  456                                      unsigned usage)
  457 {
  458    struct pipe_screen *screen = ((struct noop_pipe_screen*)pscreen)->oscreen;
  459 
  460    return screen->is_format_supported(screen, format, target, sample_count,
  461                                       storage_sample_count, usage);
  462 }
  463 
  464 static uint64_t noop_get_timestamp(struct pipe_screen *pscreen)
  465 {
  466    return 0;
  467 }
  468 
  469 static void noop_destroy_screen(struct pipe_screen *screen)
  470 {
  471    struct noop_pipe_screen *noop_screen = (struct noop_pipe_screen*)screen;
  472    struct pipe_screen *oscreen = noop_screen->oscreen;
  473 
  474    oscreen->destroy(oscreen);
  475    FREE(screen);
  476 }
  477 
  478 static void noop_fence_reference(struct pipe_screen *screen,
  479                           struct pipe_fence_handle **ptr,
  480                           struct pipe_fence_handle *fence)
  481 {
  482 }
  483 
  484 static bool noop_fence_finish(struct pipe_screen *screen,
  485                               struct pipe_context *ctx,
  486                               struct pipe_fence_handle *fence,
  487                               uint64_t timeout)
  488 {
  489    return true;
  490 }
  491 
  492 static void noop_query_memory_info(struct pipe_screen *pscreen,
  493                                    struct pipe_memory_info *info)
  494 {
  495    struct noop_pipe_screen *noop_screen = (struct noop_pipe_screen*)pscreen;
  496    struct pipe_screen *screen = noop_screen->oscreen;
  497 
  498    screen->query_memory_info(screen, info);
  499 }
  500 
  501 static struct disk_cache *noop_get_disk_shader_cache(struct pipe_screen *pscreen)
  502 {
  503    struct pipe_screen *screen = ((struct noop_pipe_screen*)pscreen)->oscreen;
  504 
  505    return screen->get_disk_shader_cache(screen);
  506 }
  507 
  508 static const void *noop_get_compiler_options(struct pipe_screen *pscreen,
  509                                              enum pipe_shader_ir ir,
  510                                              enum pipe_shader_type shader)
  511 {
  512    struct pipe_screen *screen = ((struct noop_pipe_screen*)pscreen)->oscreen;
  513 
  514    return screen->get_compiler_options(screen, ir, shader);
  515 }
  516 
  517 static void noop_finalize_nir(struct pipe_screen *pscreen, void *nir, bool optimize)
  518 {
  519    struct pipe_screen *screen = ((struct noop_pipe_screen*)pscreen)->oscreen;
  520 
  521    screen->finalize_nir(screen, nir, optimize);
  522 }
  523 
  524 struct pipe_screen *noop_screen_create(struct pipe_screen *oscreen)
  525 {
  526    struct noop_pipe_screen *noop_screen;
  527    struct pipe_screen *screen;
  528 
  529    if (!debug_get_option_noop()) {
  530       return oscreen;
  531    }
  532 
  533    noop_screen = CALLOC_STRUCT(noop_pipe_screen);
  534    if (!noop_screen) {
  535       return NULL;
  536    }
  537    noop_screen->oscreen = oscreen;
  538    screen = &noop_screen->pscreen;
  539 
  540    screen->destroy = noop_destroy_screen;
  541    screen->get_name = noop_get_name;
  542    screen->get_vendor = noop_get_vendor;
  543    screen->get_device_vendor = noop_get_device_vendor;
  544    screen->get_param = noop_get_param;
  545    screen->get_shader_param = noop_get_shader_param;
  546    screen->get_compute_param = noop_get_compute_param;
  547    screen->get_paramf = noop_get_paramf;
  548    screen->is_format_supported = noop_is_format_supported;
  549    screen->context_create = noop_create_context;
  550    screen->resource_create = noop_resource_create;
  551    screen->resource_from_handle = noop_resource_from_handle;
  552    screen->resource_get_handle = noop_resource_get_handle;
  553    if (oscreen->resource_get_param)
  554       screen->resource_get_param = noop_resource_get_param;
  555    screen->resource_destroy = noop_resource_destroy;
  556    screen->flush_frontbuffer = noop_flush_frontbuffer;
  557    screen->get_timestamp = noop_get_timestamp;
  558    screen->fence_reference = noop_fence_reference;
  559    screen->fence_finish = noop_fence_finish;
  560    screen->query_memory_info = noop_query_memory_info;
  561    screen->get_disk_shader_cache = noop_get_disk_shader_cache;
  562    screen->get_compiler_options = noop_get_compiler_options;
  563    screen->finalize_nir = noop_finalize_nir;
  564 
  565    return screen;
  566 }