Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /**************************************************************************
  2.  *
  3.  * Copyright 2011 Lauri Kasanen
  4.  * All Rights Reserved.
  5.  *
  6.  * Permission is hereby granted, free of charge, to any person obtaining a
  7.  * copy of this software and associated documentation files (the
  8.  * "Software"), to deal in the Software without restriction, including
  9.  * without limitation the rights to use, copy, modify, merge, publish,
  10.  * distribute, sub license, and/or sell copies of the Software, and to
  11.  * permit persons to whom the Software is furnished to do so, subject to
  12.  * the following conditions:
  13.  *
  14.  * The above copyright notice and this permission notice (including the
  15.  * next paragraph) shall be included in all copies or substantial portions
  16.  * of the Software.
  17.  *
  18.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21.  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
  22.  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23.  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24.  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  *
  26.  **************************************************************************/
  27.  
  28. #include "postprocess.h"
  29. #include "postprocess/pp_filters.h"
  30. #include "postprocess/pp_private.h"
  31.  
  32. #include "util/u_inlines.h"
  33. #include "util/u_sampler.h"
  34.  
  35. #include "tgsi/tgsi_parse.h"
  36.  
  37.  
  38. void
  39. pp_blit(struct pipe_context *pipe,
  40.         struct pipe_resource *src_tex,
  41.         int srcX0, int srcY0,
  42.         int srcX1, int srcY1,
  43.         int srcZ0,
  44.         struct pipe_surface *dst,
  45.         int dstX0, int dstY0,
  46.         int dstX1, int dstY1)
  47. {
  48.    struct pipe_blit_info blit;
  49.  
  50.    memset(&blit, 0, sizeof(blit));
  51.  
  52.    blit.src.resource = src_tex;
  53.    blit.src.level = 0;
  54.    blit.src.format = src_tex->format;
  55.    blit.src.box.x = srcX0;
  56.    blit.src.box.y = srcY0;
  57.    blit.src.box.z = srcZ0;
  58.    blit.src.box.width = srcX1 - srcX0;
  59.    blit.src.box.height = srcY1 - srcY0;
  60.    blit.src.box.depth = 1;
  61.  
  62.    blit.dst.resource = dst->texture;
  63.    blit.dst.level = dst->u.tex.level;
  64.    blit.dst.format = dst->format;
  65.    blit.dst.box.x = dstX0;
  66.    blit.dst.box.y = dstY0;
  67.    blit.dst.box.z = 0;
  68.    blit.dst.box.width = dstX1 - dstX0;
  69.    blit.dst.box.height = dstY1 - dstY0;
  70.    blit.dst.box.depth = 1;
  71.  
  72.    blit.mask = PIPE_MASK_RGBA;
  73.  
  74.    pipe->blit(pipe, &blit);
  75. }
  76.  
  77. /**
  78. *       Main run function of the PP queue. Called on swapbuffers/flush.
  79. *
  80. *       Runs all requested filters in order and handles shuffling the temp
  81. *       buffers in between.
  82. */
  83. void
  84. pp_run(struct pp_queue_t *ppq, struct pipe_resource *in,
  85.        struct pipe_resource *out, struct pipe_resource *indepth)
  86. {
  87.    struct pipe_resource *refin = NULL, *refout = NULL;
  88.    unsigned int i;
  89.    struct cso_context *cso = ppq->p->cso;
  90.  
  91.    if (ppq->n_filters == 0)
  92.       return;
  93.  
  94.    assert(ppq->pp_queue);
  95.    assert(ppq->tmp[0]);
  96.  
  97.    if (in->width0 != ppq->p->framebuffer.width ||
  98.        in->height0 != ppq->p->framebuffer.height) {
  99.       pp_debug("Resizing the temp pp buffers\n");
  100.       pp_free_fbos(ppq);
  101.       pp_init_fbos(ppq, in->width0, in->height0);
  102.    }
  103.  
  104.    if (in == out && ppq->n_filters == 1) {
  105.       /* Make a copy of in to tmp[0] in this case. */
  106.       unsigned int w = ppq->p->framebuffer.width;
  107.       unsigned int h = ppq->p->framebuffer.height;
  108.  
  109.  
  110.       pp_blit(ppq->p->pipe, in, 0, 0,
  111.               w, h, 0, ppq->tmps[0],
  112.               0, 0, w, h);
  113.  
  114.       in = ppq->tmp[0];
  115.    }
  116.  
  117.    /* save state (restored below) */
  118.    cso_save_blend(cso);
  119.    cso_save_depth_stencil_alpha(cso);
  120.    cso_save_fragment_shader(cso);
  121.    cso_save_framebuffer(cso);
  122.    cso_save_tessctrl_shader(cso);
  123.    cso_save_tesseval_shader(cso);
  124.    cso_save_geometry_shader(cso);
  125.    cso_save_rasterizer(cso);
  126.    cso_save_sample_mask(cso);
  127.    cso_save_min_samples(cso);
  128.    cso_save_samplers(cso, PIPE_SHADER_FRAGMENT);
  129.    cso_save_sampler_views(cso, PIPE_SHADER_FRAGMENT);
  130.    cso_save_stencil_ref(cso);
  131.    cso_save_stream_outputs(cso);
  132.    cso_save_vertex_elements(cso);
  133.    cso_save_vertex_shader(cso);
  134.    cso_save_viewport(cso);
  135.    cso_save_aux_vertex_buffer_slot(cso);
  136.    cso_save_constant_buffer_slot0(cso, PIPE_SHADER_VERTEX);
  137.    cso_save_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT);
  138.    cso_save_render_condition(cso);
  139.  
  140.    /* set default state */
  141.    cso_set_sample_mask(cso, ~0);
  142.    cso_set_min_samples(cso, 1);
  143.    cso_set_stream_outputs(cso, 0, NULL, NULL);
  144.    cso_set_tessctrl_shader_handle(cso, NULL);
  145.    cso_set_tesseval_shader_handle(cso, NULL);
  146.    cso_set_geometry_shader_handle(cso, NULL);
  147.    cso_set_render_condition(cso, NULL, FALSE, 0);
  148.  
  149.    // Kept only for this frame.
  150.    pipe_resource_reference(&ppq->depth, indepth);
  151.    pipe_resource_reference(&refin, in);
  152.    pipe_resource_reference(&refout, out);
  153.  
  154.    switch (ppq->n_filters) {
  155.    case 0:
  156.       /* Failsafe, but never reached. */
  157.       break;
  158.    case 1:                     /* No temp buf */
  159.       ppq->pp_queue[0] (ppq, in, out, 0);
  160.       break;
  161.    case 2:                     /* One temp buf */
  162.  
  163.       ppq->pp_queue[0] (ppq, in, ppq->tmp[0], 0);
  164.       ppq->pp_queue[1] (ppq, ppq->tmp[0], out, 1);
  165.  
  166.       break;
  167.    default:                    /* Two temp bufs */
  168.       assert(ppq->tmp[1]);
  169.       ppq->pp_queue[0] (ppq, in, ppq->tmp[0], 0);
  170.  
  171.       for (i = 1; i < (ppq->n_filters - 1); i++) {
  172.          if (i % 2 == 0)
  173.             ppq->pp_queue[i] (ppq, ppq->tmp[1], ppq->tmp[0], i);
  174.  
  175.          else
  176.             ppq->pp_queue[i] (ppq, ppq->tmp[0], ppq->tmp[1], i);
  177.       }
  178.  
  179.       if (i % 2 == 0)
  180.          ppq->pp_queue[i] (ppq, ppq->tmp[1], out, i);
  181.  
  182.       else
  183.          ppq->pp_queue[i] (ppq, ppq->tmp[0], out, i);
  184.  
  185.       break;
  186.    }
  187.  
  188.    /* restore state we changed */
  189.    cso_restore_blend(cso);
  190.    cso_restore_depth_stencil_alpha(cso);
  191.    cso_restore_fragment_shader(cso);
  192.    cso_restore_framebuffer(cso);
  193.    cso_restore_tessctrl_shader(cso);
  194.    cso_restore_tesseval_shader(cso);
  195.    cso_restore_geometry_shader(cso);
  196.    cso_restore_rasterizer(cso);
  197.    cso_restore_sample_mask(cso);
  198.    cso_restore_min_samples(cso);
  199.    cso_restore_samplers(cso, PIPE_SHADER_FRAGMENT);
  200.    cso_restore_sampler_views(cso, PIPE_SHADER_FRAGMENT);
  201.    cso_restore_stencil_ref(cso);
  202.    cso_restore_stream_outputs(cso);
  203.    cso_restore_vertex_elements(cso);
  204.    cso_restore_vertex_shader(cso);
  205.    cso_restore_viewport(cso);
  206.    cso_restore_aux_vertex_buffer_slot(cso);
  207.    cso_restore_constant_buffer_slot0(cso, PIPE_SHADER_VERTEX);
  208.    cso_restore_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT);
  209.    cso_restore_render_condition(cso);
  210.  
  211.    pipe_resource_reference(&ppq->depth, NULL);
  212.    pipe_resource_reference(&refin, NULL);
  213.    pipe_resource_reference(&refout, NULL);
  214. }
  215.  
  216.  
  217. /* Utility functions for the filters. You're not forced to use these if */
  218. /* your filter is more complicated. */
  219.  
  220. /** Setup this resource as the filter input. */
  221. void
  222. pp_filter_setup_in(struct pp_program *p, struct pipe_resource *in)
  223. {
  224.    struct pipe_sampler_view v_tmp;
  225.    u_sampler_view_default_template(&v_tmp, in, in->format);
  226.    p->view = p->pipe->create_sampler_view(p->pipe, in, &v_tmp);
  227. }
  228.  
  229. /** Setup this resource as the filter output. */
  230. void
  231. pp_filter_setup_out(struct pp_program *p, struct pipe_resource *out)
  232. {
  233.    p->surf.format = out->format;
  234.  
  235.    p->framebuffer.cbufs[0] = p->pipe->create_surface(p->pipe, out, &p->surf);
  236. }
  237.  
  238. /** Clean up the input and output set with the above. */
  239. void
  240. pp_filter_end_pass(struct pp_program *p)
  241. {
  242.    pipe_surface_reference(&p->framebuffer.cbufs[0], NULL);
  243.    pipe_sampler_view_reference(&p->view, NULL);
  244. }
  245.  
  246. /**
  247. *       Convert the TGSI assembly to a runnable shader.
  248. *
  249. * We need not care about geometry shaders. All we have is screen quads.
  250. */
  251. void *
  252. pp_tgsi_to_state(struct pipe_context *pipe, const char *text, bool isvs,
  253.                  const char *name)
  254. {
  255.    struct pipe_shader_state state;
  256.    struct tgsi_token *tokens = NULL;
  257.    void *ret_state = NULL;
  258.  
  259.    /*
  260.     * Allocate temporary token storage. State creation will duplicate
  261.     * tokens so we must free them on exit.
  262.     */
  263.    tokens = tgsi_alloc_tokens(PP_MAX_TOKENS);
  264.  
  265.    if (tokens == NULL) {
  266.       pp_debug("Failed to allocate temporary token storage.\n");
  267.       return NULL;
  268.    }
  269.  
  270.    if (tgsi_text_translate(text, tokens, PP_MAX_TOKENS) == FALSE) {
  271.       _debug_printf("pp: Failed to translate a shader for %s\n", name);
  272.       return NULL;
  273.    }
  274.  
  275.    state.tokens = tokens;
  276.    memset(&state.stream_output, 0, sizeof(state.stream_output));
  277.  
  278.    if (isvs) {
  279.       ret_state = pipe->create_vs_state(pipe, &state);
  280.       FREE(tokens);
  281.    } else {
  282.       ret_state = pipe->create_fs_state(pipe, &state);
  283.       FREE(tokens);
  284.    }
  285.  
  286.    return ret_state;
  287. }
  288.  
  289. /** Setup misc state for the filter. */
  290. void
  291. pp_filter_misc_state(struct pp_program *p)
  292. {
  293.    cso_set_blend(p->cso, &p->blend);
  294.    cso_set_depth_stencil_alpha(p->cso, &p->depthstencil);
  295.    cso_set_rasterizer(p->cso, &p->rasterizer);
  296.    cso_set_viewport(p->cso, &p->viewport);
  297.  
  298.    cso_set_vertex_elements(p->cso, 2, p->velem);
  299. }
  300.  
  301. /** Draw with the filter to the set output. */
  302. void
  303. pp_filter_draw(struct pp_program *p)
  304. {
  305.    util_draw_vertex_buffer(p->pipe, p->cso, p->vbuf, 0, 0,
  306.                            PIPE_PRIM_QUADS, 4, 2);
  307. }
  308.  
  309. /** Set the framebuffer as active. */
  310. void
  311. pp_filter_set_fb(struct pp_program *p)
  312. {
  313.    cso_set_framebuffer(p->cso, &p->framebuffer);
  314. }
  315.  
  316. /** Set the framebuffer as active and clear it. */
  317. void
  318. pp_filter_set_clear_fb(struct pp_program *p)
  319. {
  320.    cso_set_framebuffer(p->cso, &p->framebuffer);
  321.    p->pipe->clear(p->pipe, PIPE_CLEAR_COLOR0, &p->clear_color, 0, 0);
  322. }
  323.