src/mesa/state_tracker/st_pbo.c

   1 /*
   2  * Copyright 2007 VMware, Inc.
   3  * Copyright 2016 Advanced Micro Devices, Inc.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * on the rights to use, copy, modify, merge, publish, distribute, sub
   9  * license, and/or sell copies of the Software, and to permit persons to whom
  10  * the Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  22  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /**
  26  * \file
  27  *
  28  * Common helper functions for PBO up- and downloads.
  29  */
  30
  31 #include "state_tracker/st_context.h"
  32 #include "state_tracker/st_pbo.h"
  33 #include "state_tracker/st_cb_bufferobjects.h"
  34
  35 #include "pipe/p_context.h"
  36 #include "pipe/p_defines.h"
  37 #include "pipe/p_screen.h"
  38 #include "cso_cache/cso_context.h"
  39 #include "tgsi/tgsi_ureg.h"
  40 #include "util/u_inlines.h"
  41 #include "util/u_upload_mgr.h"
  42
  43 /* Final setup of buffer addressing information.
  44  *
  45  * buf_offset is in pixels.
  46  *
  47  * Returns false if something (e.g. alignment) prevents PBO upload/download.
  48  */
  49 bool
  50 st_pbo_addresses_setup(struct st_context *st,
  51                        struct pipe_resource *buf, intptr_t buf_offset,
  52                        struct st_pbo_addresses *addr)
  53 {
  54    unsigned skip_pixels;
  55
  56    /* Check alignment against texture buffer requirements. */
  57    {
  58       unsigned ofs = (buf_offset * addr->bytes_per_pixel) % st->ctx->Const.TextureBufferOffsetAlignment;
  59       if (ofs != 0) {
  60          if (ofs % addr->bytes_per_pixel != 0)
  61             return false;
  62
  63          skip_pixels = ofs / addr->bytes_per_pixel;
  64          buf_offset -= skip_pixels;
  65       } else {
  66          skip_pixels = 0;
  67       }
  68    }
  69
  70    assert(buf_offset >= 0);
  71
  72    addr->buffer = buf;
  73    addr->first_element = buf_offset;
  74    addr->last_element = buf_offset + skip_pixels + addr->width - 1
  75          + (addr->height - 1 + (addr->depth - 1) * addr->image_height) * addr->pixels_per_row;
  76
  77    if (addr->last_element - addr->first_element > st->ctx->Const.MaxTextureBufferSize - 1)
  78       return false;
  79
  80    /* This should be ensured by Mesa before calling our callbacks */
  81    assert((addr->last_element + 1) * addr->bytes_per_pixel <= buf->width0);
  82
  83    addr->constants.xoffset = -addr->xoffset + skip_pixels;
  84    addr->constants.yoffset = -addr->yoffset;
  85    addr->constants.stride = addr->pixels_per_row;
  86    addr->constants.image_size = addr->pixels_per_row * addr->image_height;
  87
  88    return true;
  89 }
  90
  91 /* Validate and fill buffer addressing information based on GL pixelstore
  92  * attributes.
  93  *
  94  * Returns false if some aspect of the addressing (e.g. alignment) prevents
  95  * PBO upload/download.
  96  */
  97 bool
  98 st_pbo_addresses_pixelstore(struct st_context *st,
  99                             GLenum gl_target, bool skip_images,
 100                             const struct gl_pixelstore_attrib *store,
 101                             const void *pixels,
 102                             struct st_pbo_addresses *addr)
 103 {
 104    struct pipe_resource *buf = st_buffer_object(store->BufferObj)->buffer;
 105    intptr_t buf_offset = (intptr_t) pixels;
 106
 107    if (buf_offset % addr->bytes_per_pixel)
 108       return false;
 109
 110    /* Convert to texels */
 111    buf_offset = buf_offset / addr->bytes_per_pixel;
 112
 113    /* Determine image height */
 114    if (gl_target == GL_TEXTURE_1D_ARRAY) {
 115       addr->image_height = 1;
 116    } else {
 117       addr->image_height = store->ImageHeight > 0 ? store->ImageHeight : addr->height;
 118    }
 119
 120    /* Compute the stride, taking store->Alignment into account */
 121    {
 122        unsigned pixels_per_row = store->RowLength > 0 ?
 123                            store->RowLength : addr->width;
 124        unsigned bytes_per_row = pixels_per_row * addr->bytes_per_pixel;
 125        unsigned remainder = bytes_per_row % store->Alignment;
 126        unsigned offset_rows;
 127
 128        if (remainder > 0)
 129           bytes_per_row += store->Alignment - remainder;
 130
 131        if (bytes_per_row % addr->bytes_per_pixel)
 132           return false;
 133
 134        addr->pixels_per_row = bytes_per_row / addr->bytes_per_pixel;
 135
 136        offset_rows = store->SkipRows;
 137        if (skip_images)
 138           offset_rows += addr->image_height * store->SkipImages;
 139
 140        buf_offset += store->SkipPixels + addr->pixels_per_row * offset_rows;
 141    }
 142
 143    if (!st_pbo_addresses_setup(st, buf, buf_offset, addr))
 144       return false;
 145
 146    /* Support GL_PACK_INVERT_MESA */
 147    if (store->Invert) {
 148       addr->constants.xoffset += (addr->height - 1) * addr->constants.stride;
 149       addr->constants.stride = -addr->constants.stride;
 150    }
 151
 152    return true;
 153 }
 154
 155 /* Setup all vertex pipeline state, rasterizer state, and fragment shader
 156  * constants, and issue the draw call for PBO upload/download.
 157  *
 158  * The caller is responsible for saving and restoring state, as well as for
 159  * setting other fragment shader state (fragment shader, samplers), and
 160  * framebuffer/viewport/DSA/blend state.
 161  */
 162 bool
 163 st_pbo_draw(struct st_context *st, const struct st_pbo_addresses *addr,
 164             unsigned surface_width, unsigned surface_height)
 165 {
 166    struct cso_context *cso = st->cso_context;
 167
 168    /* Setup vertex and geometry shaders */
 169    if (!st->pbo.vs) {
 170       st->pbo.vs = st_pbo_create_vs(st);
 171       if (!st->pbo.vs)
 172          return false;
 173    }
 174
 175    if (addr->depth != 1 && st->pbo.use_gs && !st->pbo.gs) {
 176       st->pbo.gs = st_pbo_create_gs(st);
 177       if (!st->pbo.gs)
 178          return false;
 179    }
 180
 181    cso_set_vertex_shader_handle(cso, st->pbo.vs);
 182
 183    cso_set_geometry_shader_handle(cso, addr->depth != 1 ? st->pbo.gs : NULL);
 184
 185    cso_set_tessctrl_shader_handle(cso, NULL);
 186
 187    cso_set_tesseval_shader_handle(cso, NULL);
 188
 189    /* Upload vertices */
 190    {
 191       struct pipe_vertex_buffer vbo;
 192       struct pipe_vertex_element velem;
 193
 194       float x0 = (float) addr->xoffset / surface_width * 2.0f - 1.0f;
 195       float y0 = (float) addr->yoffset / surface_height * 2.0f - 1.0f;
 196       float x1 = (float) (addr->xoffset + addr->width) / surface_width * 2.0f - 1.0f;
 197       float y1 = (float) (addr->yoffset + addr->height) / surface_height * 2.0f - 1.0f;
 198
 199       float *verts = NULL;
 200
 201       vbo.user_buffer = NULL;
 202       vbo.buffer = NULL;
 203       vbo.stride = 2 * sizeof(float);
 204
 205       u_upload_alloc(st->uploader, 0, 8 * sizeof(float), 4,
 206                      &vbo.buffer_offset, &vbo.buffer, (void **) &verts);
 207       if (!verts)
 208          return false;
 209
 210       verts[0] = x0;
 211       verts[1] = y0;
 212       verts[2] = x0;
 213       verts[3] = y1;
 214       verts[4] = x1;
 215       verts[5] = y0;
 216       verts[6] = x1;
 217       verts[7] = y1;
 218
 219       u_upload_unmap(st->uploader);
 220
 221       velem.src_offset = 0;
 222       velem.instance_divisor = 0;
 223       velem.vertex_buffer_index = cso_get_aux_vertex_buffer_slot(cso);
 224       velem.src_format = PIPE_FORMAT_R32G32_FLOAT;
 225
 226       cso_set_vertex_elements(cso, 1, &velem);
 227
 228       cso_set_vertex_buffers(cso, velem.vertex_buffer_index, 1, &vbo);
 229
 230       pipe_resource_reference(&vbo.buffer, NULL);
 231    }
 232
 233    /* Upload constants */
 234    {
 235       struct pipe_constant_buffer cb;
 236
 237       if (st->constbuf_uploader) {
 238          cb.buffer = NULL;
 239          cb.user_buffer = NULL;
 240          u_upload_data(st->constbuf_uploader, 0, sizeof(addr->constants),
 241                        st->ctx->Const.UniformBufferOffsetAlignment,
 242                        &addr->constants, &cb.buffer_offset, &cb.buffer);
 243          if (!cb.buffer)
 244             return false;
 245
 246          u_upload_unmap(st->constbuf_uploader);
 247       } else {
 248          cb.buffer = NULL;
 249          cb.user_buffer = &addr->constants;
 250          cb.buffer_offset = 0;
 251       }
 252       cb.buffer_size = sizeof(addr->constants);
 253
 254       cso_set_constant_buffer(cso, PIPE_SHADER_FRAGMENT, 0, &cb);
 255
 256       pipe_resource_reference(&cb.buffer, NULL);
 257    }
 258
 259    /* Rasterizer state */
 260    cso_set_rasterizer(cso, &st->pbo.raster);
 261
 262    /* Disable stream output */
 263    cso_set_stream_outputs(cso, 0, NULL, 0);
 264
 265    if (addr->depth == 1) {
 266       cso_draw_arrays(cso, PIPE_PRIM_TRIANGLE_STRIP, 0, 4);
 267    } else {
 268       cso_draw_arrays_instanced(cso, PIPE_PRIM_TRIANGLE_STRIP,
 269                                 0, 4, 0, addr->depth);
 270    }
 271
 272    return true;
 273 }
 274
 275 void *
 276 st_pbo_create_vs(struct st_context *st)
 277 {
 278    struct ureg_program *ureg;
 279    struct ureg_src in_pos;
 280    struct ureg_src in_instanceid;
 281    struct ureg_dst out_pos;
 282    struct ureg_dst out_layer;
 283
 284    ureg = ureg_create(PIPE_SHADER_VERTEX);
 285    if (!ureg)
 286       return NULL;
 287
 288    in_pos = ureg_DECL_vs_input(ureg, TGSI_SEMANTIC_POSITION);
 289
 290    out_pos = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
 291
 292    if (st->pbo.layers) {
 293       in_instanceid = ureg_DECL_system_value(ureg, TGSI_SEMANTIC_INSTANCEID, 0);
 294
 295       if (!st->pbo.use_gs)
 296          out_layer = ureg_DECL_output(ureg, TGSI_SEMANTIC_LAYER, 0);
 297    }
 298
 299    /* out_pos = in_pos */
 300    ureg_MOV(ureg, out_pos, in_pos);
 301
 302    if (st->pbo.layers) {
 303       if (st->pbo.use_gs) {
 304          /* out_pos.z = i2f(gl_InstanceID) */
 305          ureg_I2F(ureg, ureg_writemask(out_pos, TGSI_WRITEMASK_Z),
 306                         ureg_scalar(in_instanceid, TGSI_SWIZZLE_X));
 307       } else {
 308          /* out_layer = gl_InstanceID */
 309          ureg_MOV(ureg, out_layer, in_instanceid);
 310       }
 311    }
 312
 313    ureg_END(ureg);
 314
 315    return ureg_create_shader_and_destroy(ureg, st->pipe);
 316 }
 317
 318 void *
 319 st_pbo_create_gs(struct st_context *st)
 320 {
 321    static const int zero = 0;
 322    struct ureg_program *ureg;
 323    struct ureg_dst out_pos;
 324    struct ureg_dst out_layer;
 325    struct ureg_src in_pos;
 326    struct ureg_src imm;
 327    unsigned i;
 328
 329    ureg = ureg_create(PIPE_SHADER_GEOMETRY);
 330    if (!ureg)
 331       return NULL;
 332
 333    ureg_property(ureg, TGSI_PROPERTY_GS_INPUT_PRIM, PIPE_PRIM_TRIANGLES);
 334    ureg_property(ureg, TGSI_PROPERTY_GS_OUTPUT_PRIM, PIPE_PRIM_TRIANGLE_STRIP);
 335    ureg_property(ureg, TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES, 3);
 336
 337    out_pos = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
 338    out_layer = ureg_DECL_output(ureg, TGSI_SEMANTIC_LAYER, 0);
 339
 340    in_pos = ureg_DECL_input(ureg, TGSI_SEMANTIC_POSITION, 0, 0, 1);
 341
 342    imm = ureg_DECL_immediate_int(ureg, &zero, 1);
 343
 344    for (i = 0; i < 3; ++i) {
 345       struct ureg_src in_pos_vertex = ureg_src_dimension(in_pos, i);
 346
 347       /* out_pos = in_pos[i] */
 348       ureg_MOV(ureg, out_pos, in_pos_vertex);
 349
 350       /* out_layer.x = f2i(in_pos[i].z) */
 351       ureg_F2I(ureg, ureg_writemask(out_layer, TGSI_WRITEMASK_X),
 352                      ureg_scalar(in_pos_vertex, TGSI_SWIZZLE_Z));
 353
 354       ureg_EMIT(ureg, ureg_scalar(imm, TGSI_SWIZZLE_X));
 355    }
 356
 357    ureg_END(ureg);
 358
 359    return ureg_create_shader_and_destroy(ureg, st->pipe);
 360 }
 361
 362 static void *
 363 create_fs(struct st_context *st, bool download, enum pipe_texture_target target)
 364 {
 365    struct pipe_context *pipe = st->pipe;
 366    struct pipe_screen *screen = pipe->screen;
 367    struct ureg_program *ureg;
 368    bool have_layer;
 369    struct ureg_dst out;
 370    struct ureg_src sampler;
 371    struct ureg_src pos;
 372    struct ureg_src layer;
 373    struct ureg_src const0;
 374    struct ureg_dst temp0;
 375
 376    have_layer =
 377       st->pbo.layers &&
 378       (!download || target == PIPE_TEXTURE_1D_ARRAY
 379                  || target == PIPE_TEXTURE_2D_ARRAY
 380                  || target == PIPE_TEXTURE_3D
 381                  || target == PIPE_TEXTURE_CUBE
 382                  || target == PIPE_TEXTURE_CUBE_ARRAY);
 383
 384    ureg = ureg_create(PIPE_SHADER_FRAGMENT);
 385    if (!ureg)
 386       return NULL;
 387
 388    if (!download) {
 389       out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
 390    } else {
 391       struct ureg_src image;
 392
 393       /* writeonly images do not require an explicitly given format. */
 394       image = ureg_DECL_image(ureg, 0, TGSI_TEXTURE_BUFFER, PIPE_FORMAT_NONE,
 395                                     true, false);
 396       out = ureg_dst(image);
 397    }
 398
 399    sampler = ureg_DECL_sampler(ureg, 0);
 400    if (screen->get_param(screen, PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL)) {
 401       pos = ureg_DECL_system_value(ureg, TGSI_SEMANTIC_POSITION, 0);
 402    } else {
 403       pos = ureg_DECL_fs_input(ureg, TGSI_SEMANTIC_POSITION, 0,
 404                                TGSI_INTERPOLATE_LINEAR);
 405    }
 406    if (have_layer) {
 407       layer = ureg_DECL_fs_input(ureg, TGSI_SEMANTIC_LAYER, 0,
 408                                        TGSI_INTERPOLATE_CONSTANT);
 409    }
 410    const0  = ureg_DECL_constant(ureg, 0);
 411    temp0   = ureg_DECL_temporary(ureg);
 412
 413    /* Note: const0 = [ -xoffset + skip_pixels, -yoffset, stride, image_height ] */
 414
 415    /* temp0.xy = f2i(temp0.xy) */
 416    ureg_F2I(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_XY),
 417                   ureg_swizzle(pos,
 418                                TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y,
 419                                TGSI_SWIZZLE_Y, TGSI_SWIZZLE_Y));
 420
 421    /* temp0.xy = temp0.xy + const0.xy */
 422    ureg_UADD(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_XY),
 423                    ureg_swizzle(ureg_src(temp0),
 424                                 TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y,
 425                                 TGSI_SWIZZLE_Y, TGSI_SWIZZLE_Y),
 426                    ureg_swizzle(const0,
 427                                 TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y,
 428                                 TGSI_SWIZZLE_Y, TGSI_SWIZZLE_Y));
 429
 430    /* temp0.x = const0.z * temp0.y + temp0.x */
 431    ureg_UMAD(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_X),
 432                    ureg_scalar(const0, TGSI_SWIZZLE_Z),
 433                    ureg_scalar(ureg_src(temp0), TGSI_SWIZZLE_Y),
 434                    ureg_scalar(ureg_src(temp0), TGSI_SWIZZLE_X));
 435
 436    if (have_layer) {
 437       /* temp0.x = const0.w * layer + temp0.x */
 438       ureg_UMAD(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_X),
 439                       ureg_scalar(const0, TGSI_SWIZZLE_W),
 440                       ureg_scalar(layer, TGSI_SWIZZLE_X),
 441                       ureg_scalar(ureg_src(temp0), TGSI_SWIZZLE_X));
 442    }
 443
 444    /* temp0.w = 0 */
 445    ureg_MOV(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_W), ureg_imm1u(ureg, 0));
 446
 447    if (download) {
 448       struct ureg_dst temp1;
 449       struct ureg_src op[2];
 450
 451       temp1 = ureg_DECL_temporary(ureg);
 452
 453       /* temp1.xy = pos.xy */
 454       ureg_F2I(ureg, ureg_writemask(temp1, TGSI_WRITEMASK_XY), pos);
 455
 456       /* temp1.zw = 0 */
 457       ureg_MOV(ureg, ureg_writemask(temp1, TGSI_WRITEMASK_ZW), ureg_imm1u(ureg, 0));
 458
 459       if (have_layer) {
 460          /* temp1.y/z = layer */
 461          ureg_MOV(ureg, ureg_writemask(temp1,
 462                                        target == PIPE_TEXTURE_1D_ARRAY ? TGSI_WRITEMASK_Y
 463                                                                        : TGSI_WRITEMASK_Z),
 464                         ureg_scalar(layer, TGSI_SWIZZLE_X));
 465       }
 466
 467       /* temp1 = txf(sampler, temp1) */
 468       ureg_TXF(ureg, temp1, util_pipe_tex_to_tgsi_tex(target, 1),
 469                      ureg_src(temp1), sampler);
 470
 471       /* store(out, temp0, temp1) */
 472       op[0] = ureg_src(temp0);
 473       op[1] = ureg_src(temp1);
 474       ureg_memory_insn(ureg, TGSI_OPCODE_STORE, &out, 1, op, 2, 0,
 475                              TGSI_TEXTURE_BUFFER, PIPE_FORMAT_NONE);
 476
 477       ureg_release_temporary(ureg, temp1);
 478    } else {
 479       /* out = txf(sampler, temp0.x) */
 480       ureg_TXF(ureg, out, TGSI_TEXTURE_BUFFER, ureg_src(temp0), sampler);
 481    }
 482
 483    ureg_release_temporary(ureg, temp0);
 484
 485    ureg_END(ureg);
 486
 487    return ureg_create_shader_and_destroy(ureg, pipe);
 488 }
 489
 490 void *
 491 st_pbo_create_upload_fs(struct st_context *st)
 492 {
 493    return create_fs(st, false, 0);
 494 }
 495
 496 void *
 497 st_pbo_get_download_fs(struct st_context *st, enum pipe_texture_target target)
 498 {
 499    assert(target < PIPE_MAX_TEXTURE_TYPES);
 500
 501    if (!st->pbo.download_fs[target])
 502       st->pbo.download_fs[target] = create_fs(st, true, target);
 503
 504    return st->pbo.download_fs[target];
 505 }
 506
 507 void
 508 st_init_pbo_helpers(struct st_context *st)
 509 {
 510    struct pipe_context *pipe = st->pipe;
 511    struct pipe_screen *screen = pipe->screen;
 512
 513    st->pbo.upload_enabled =
 514       screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OBJECTS) &&
 515       screen->get_param(screen, PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT) >= 1 &&
 516       screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_INTEGERS);
 517    if (!st->pbo.upload_enabled)
 518       return;
 519
 520    st->pbo.download_enabled =
 521       st->pbo.upload_enabled &&
 522       screen->get_param(screen, PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT) &&
 523       screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
 524                                        PIPE_SHADER_CAP_MAX_SHADER_IMAGES) >= 1;
 525
 526    st->pbo.rgba_only =
 527       screen->get_param(screen, PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY);
 528
 529    if (screen->get_param(screen, PIPE_CAP_TGSI_INSTANCEID)) {
 530       if (screen->get_param(screen, PIPE_CAP_TGSI_VS_LAYER_VIEWPORT)) {
 531          st->pbo.layers = true;
 532       } else if (screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES) >= 3) {
 533          st->pbo.layers = true;
 534          st->pbo.use_gs = true;
 535       }
 536    }
 537
 538    /* Blend state */
 539    memset(&st->pbo.upload_blend, 0, sizeof(struct pipe_blend_state));
 540    st->pbo.upload_blend.rt[0].colormask = PIPE_MASK_RGBA;
 541
 542    /* Rasterizer state */
 543    memset(&st->pbo.raster, 0, sizeof(struct pipe_rasterizer_state));
 544    st->pbo.raster.half_pixel_center = 1;
 545 }
 546
 547 void
 548 st_destroy_pbo_helpers(struct st_context *st)
 549 {
 550    unsigned i;
 551
 552    if (st->pbo.upload_fs) {
 553       cso_delete_fragment_shader(st->cso_context, st->pbo.upload_fs);
 554       st->pbo.upload_fs = NULL;
 555    }
 556
 557    for (i = 0; i < ARRAY_SIZE(st->pbo.download_fs); ++i) {
 558       if (st->pbo.download_fs[i]) {
 559          cso_delete_fragment_shader(st->cso_context, st->pbo.download_fs[i]);
 560          st->pbo.download_fs[i] = NULL;
 561       }
 562    }
 563
 564    if (st->pbo.gs) {
 565       cso_delete_geometry_shader(st->cso_context, st->pbo.gs);
 566       st->pbo.gs = NULL;
 567    }
 568
 569    if (st->pbo.vs) {
 570       cso_delete_vertex_shader(st->cso_context, st->pbo.vs);
 571       st->pbo.vs = NULL;
 572    }
 573 }