Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /**************************************************************************
  2.  *
  3.  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
  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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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 "util/u_inlines.h"
  29. #include "util/u_memory.h"
  30. #include "util/u_simple_list.h"
  31.  
  32. #include "pipe/p_format.h"
  33. #include "pipe/p_screen.h"
  34.  
  35. #include "tr_dump.h"
  36. #include "tr_dump_state.h"
  37. #include "tr_public.h"
  38. #include "tr_screen.h"
  39. #include "tr_texture.h"
  40. #include "tr_context.h"
  41.  
  42.  
  43.  
  44.  
  45.  
  46. static INLINE struct pipe_resource *
  47. trace_resource_unwrap(struct trace_context *tr_ctx,
  48.                      struct pipe_resource *resource)
  49. {
  50.    struct trace_resource *tr_res;
  51.  
  52.    if(!resource)
  53.       return NULL;
  54.  
  55.    tr_res = trace_resource(resource);
  56.  
  57.    assert(tr_res->resource);
  58.    return tr_res->resource;
  59. }
  60.  
  61.  
  62. static INLINE struct pipe_surface *
  63. trace_surface_unwrap(struct trace_context *tr_ctx,
  64.                      struct pipe_surface *surface)
  65. {
  66.    struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
  67.    struct trace_surface *tr_surf;
  68.  
  69.    if(!surface)
  70.       return NULL;
  71.  
  72.    assert(surface->texture);
  73.    if(!surface->texture)
  74.       return surface;
  75.  
  76.    tr_surf = trace_surface(surface);
  77.  
  78.    assert(tr_surf->surface);
  79.    assert(tr_surf->surface->texture->screen == tr_scr->screen);
  80.    (void) tr_scr;
  81.    return tr_surf->surface;
  82. }
  83.  
  84.  
  85. static INLINE void
  86. trace_context_draw_vbo(struct pipe_context *_pipe,
  87.                        const struct pipe_draw_info *info)
  88. {
  89.    struct trace_context *tr_ctx = trace_context(_pipe);
  90.    struct pipe_context *pipe = tr_ctx->pipe;
  91.  
  92.    trace_dump_call_begin("pipe_context", "draw_vbo");
  93.  
  94.    trace_dump_arg(ptr,  pipe);
  95.    trace_dump_arg(draw_info, info);
  96.  
  97.    trace_dump_trace_flush();
  98.  
  99.    pipe->draw_vbo(pipe, info);
  100.  
  101.    trace_dump_call_end();
  102. }
  103.  
  104.  
  105. static INLINE struct pipe_query *
  106. trace_context_create_query(struct pipe_context *_pipe,
  107.                            unsigned query_type)
  108. {
  109.    struct trace_context *tr_ctx = trace_context(_pipe);
  110.    struct pipe_context *pipe = tr_ctx->pipe;
  111.    struct pipe_query *result;
  112.  
  113.    trace_dump_call_begin("pipe_context", "create_query");
  114.  
  115.    trace_dump_arg(ptr, pipe);
  116.    trace_dump_arg(uint, query_type);
  117.  
  118.    result = pipe->create_query(pipe, query_type);
  119.  
  120.    trace_dump_ret(ptr, result);
  121.  
  122.    trace_dump_call_end();
  123.  
  124.    return result;
  125. }
  126.  
  127.  
  128. static INLINE void
  129. trace_context_destroy_query(struct pipe_context *_pipe,
  130.                             struct pipe_query *query)
  131. {
  132.    struct trace_context *tr_ctx = trace_context(_pipe);
  133.    struct pipe_context *pipe = tr_ctx->pipe;
  134.  
  135.    trace_dump_call_begin("pipe_context", "destroy_query");
  136.  
  137.    trace_dump_arg(ptr, pipe);
  138.    trace_dump_arg(ptr, query);
  139.  
  140.    pipe->destroy_query(pipe, query);
  141.  
  142.    trace_dump_call_end();
  143. }
  144.  
  145.  
  146. static INLINE void
  147. trace_context_begin_query(struct pipe_context *_pipe,
  148.                           struct pipe_query *query)
  149. {
  150.    struct trace_context *tr_ctx = trace_context(_pipe);
  151.    struct pipe_context *pipe = tr_ctx->pipe;
  152.  
  153.    trace_dump_call_begin("pipe_context", "begin_query");
  154.  
  155.    trace_dump_arg(ptr, pipe);
  156.    trace_dump_arg(ptr, query);
  157.  
  158.    pipe->begin_query(pipe, query);
  159.  
  160.    trace_dump_call_end();
  161. }
  162.  
  163.  
  164. static INLINE void
  165. trace_context_end_query(struct pipe_context *_pipe,
  166.                         struct pipe_query *query)
  167. {
  168.    struct trace_context *tr_ctx = trace_context(_pipe);
  169.    struct pipe_context *pipe = tr_ctx->pipe;
  170.  
  171.    trace_dump_call_begin("pipe_context", "end_query");
  172.  
  173.    trace_dump_arg(ptr, pipe);
  174.    trace_dump_arg(ptr, query);
  175.  
  176.    pipe->end_query(pipe, query);
  177.  
  178.    trace_dump_call_end();
  179. }
  180.  
  181.  
  182. static INLINE boolean
  183. trace_context_get_query_result(struct pipe_context *_pipe,
  184.                                struct pipe_query *query,
  185.                                boolean wait,
  186.                                union pipe_query_result *presult)
  187. {
  188.    struct trace_context *tr_ctx = trace_context(_pipe);
  189.    struct pipe_context *pipe = tr_ctx->pipe;
  190.    uint64_t result;
  191.    boolean _result;
  192.  
  193.    trace_dump_call_begin("pipe_context", "get_query_result");
  194.  
  195.    trace_dump_arg(ptr, pipe);
  196.  
  197.    _result = pipe->get_query_result(pipe, query, wait, presult);
  198.    /* XXX this depends on the query type */
  199.    result = *((uint64_t*)presult);
  200.  
  201.    trace_dump_arg(uint, result);
  202.    trace_dump_ret(bool, _result);
  203.  
  204.    trace_dump_call_end();
  205.  
  206.    return _result;
  207. }
  208.  
  209.  
  210. static INLINE void *
  211. trace_context_create_blend_state(struct pipe_context *_pipe,
  212.                                  const struct pipe_blend_state *state)
  213. {
  214.    struct trace_context *tr_ctx = trace_context(_pipe);
  215.    struct pipe_context *pipe = tr_ctx->pipe;
  216.    void * result;
  217.  
  218.    trace_dump_call_begin("pipe_context", "create_blend_state");
  219.  
  220.    trace_dump_arg(ptr, pipe);
  221.    trace_dump_arg(blend_state, state);
  222.  
  223.    result = pipe->create_blend_state(pipe, state);
  224.  
  225.    trace_dump_ret(ptr, result);
  226.  
  227.    trace_dump_call_end();
  228.  
  229.    return result;
  230. }
  231.  
  232.  
  233. static INLINE void
  234. trace_context_bind_blend_state(struct pipe_context *_pipe,
  235.                                void *state)
  236. {
  237.    struct trace_context *tr_ctx = trace_context(_pipe);
  238.    struct pipe_context *pipe = tr_ctx->pipe;
  239.  
  240.    trace_dump_call_begin("pipe_context", "bind_blend_state");
  241.  
  242.    trace_dump_arg(ptr, pipe);
  243.    trace_dump_arg(ptr, state);
  244.  
  245.    pipe->bind_blend_state(pipe, state);
  246.  
  247.    trace_dump_call_end();
  248. }
  249.  
  250.  
  251. static INLINE void
  252. trace_context_delete_blend_state(struct pipe_context *_pipe,
  253.                                  void *state)
  254. {
  255.    struct trace_context *tr_ctx = trace_context(_pipe);
  256.    struct pipe_context *pipe = tr_ctx->pipe;
  257.  
  258.    trace_dump_call_begin("pipe_context", "delete_blend_state");
  259.  
  260.    trace_dump_arg(ptr, pipe);
  261.    trace_dump_arg(ptr, state);
  262.  
  263.    pipe->delete_blend_state(pipe, state);
  264.  
  265.    trace_dump_call_end();
  266. }
  267.  
  268.  
  269. static INLINE void *
  270. trace_context_create_sampler_state(struct pipe_context *_pipe,
  271.                                    const struct pipe_sampler_state *state)
  272. {
  273.    struct trace_context *tr_ctx = trace_context(_pipe);
  274.    struct pipe_context *pipe = tr_ctx->pipe;
  275.    void * result;
  276.  
  277.    trace_dump_call_begin("pipe_context", "create_sampler_state");
  278.  
  279.    trace_dump_arg(ptr, pipe);
  280.    trace_dump_arg(sampler_state, state);
  281.  
  282.    result = pipe->create_sampler_state(pipe, state);
  283.  
  284.    trace_dump_ret(ptr, result);
  285.  
  286.    trace_dump_call_end();
  287.  
  288.    return result;
  289. }
  290.  
  291.  
  292. static INLINE void
  293. trace_context_bind_sampler_states(struct pipe_context *_pipe,
  294.                                   unsigned shader,
  295.                                   unsigned start,
  296.                                   unsigned num_states,
  297.                                   void **states)
  298. {
  299.    struct trace_context *tr_ctx = trace_context(_pipe);
  300.    struct pipe_context *pipe = tr_ctx->pipe;
  301.  
  302.    /* remove this when we have pipe->bind_sampler_states(..., start, ...) */
  303.    assert(start == 0);
  304.  
  305.    switch (shader) {
  306.    case PIPE_SHADER_VERTEX:
  307.       trace_dump_call_begin("pipe_context", "bind_vertex_sampler_states");
  308.       break;
  309.    case PIPE_SHADER_GEOMETRY:
  310.       trace_dump_call_begin("pipe_context", "bind_geometry_sampler_states");
  311.       break;
  312.    case PIPE_SHADER_FRAGMENT:
  313.       trace_dump_call_begin("pipe_context", "bind_fragment_sampler_states");
  314.       break;
  315.    default:
  316.       debug_error("Unexpected shader in trace_context_bind_sampler_states()");
  317.    }
  318.  
  319.    trace_dump_arg(ptr, pipe);
  320.    trace_dump_arg(uint, num_states);
  321.    trace_dump_arg_array(ptr, states, num_states);
  322.  
  323.    switch (shader) {
  324.    case PIPE_SHADER_VERTEX:
  325.       pipe->bind_vertex_sampler_states(pipe, num_states, states);
  326.       break;
  327.    case PIPE_SHADER_GEOMETRY:
  328.       pipe->bind_geometry_sampler_states(pipe, num_states, states);
  329.       break;
  330.    case PIPE_SHADER_FRAGMENT:
  331.       pipe->bind_fragment_sampler_states(pipe, num_states, states);
  332.       break;
  333.    default:
  334.       debug_error("Unexpected shader in trace_context_bind_sampler_states()");
  335.    }
  336.  
  337.    trace_dump_call_end();
  338. }
  339.  
  340.  
  341. static INLINE void
  342. trace_context_bind_fragment_sampler_states(struct pipe_context *_pipe,
  343.                                            unsigned num,
  344.                                            void **states)
  345. {
  346.    trace_context_bind_sampler_states(_pipe, PIPE_SHADER_FRAGMENT,
  347.                                      0, num, states);
  348. }
  349.  
  350.  
  351. static INLINE void
  352. trace_context_bind_vertex_sampler_states(struct pipe_context *_pipe,
  353.                                          unsigned num,
  354.                                          void **states)
  355. {
  356.    trace_context_bind_sampler_states(_pipe, PIPE_SHADER_VERTEX,
  357.                                      0, num, states);
  358. }
  359.  
  360.  
  361. static INLINE void
  362. trace_context_bind_geometry_sampler_states(struct pipe_context *_pipe,
  363.                                          unsigned num,
  364.                                          void **states)
  365. {
  366.    trace_context_bind_sampler_states(_pipe, PIPE_SHADER_GEOMETRY,
  367.                                      0, num, states);
  368. }
  369.  
  370.  
  371. static INLINE void
  372. trace_context_delete_sampler_state(struct pipe_context *_pipe,
  373.                                    void *state)
  374. {
  375.    struct trace_context *tr_ctx = trace_context(_pipe);
  376.    struct pipe_context *pipe = tr_ctx->pipe;
  377.  
  378.    trace_dump_call_begin("pipe_context", "delete_sampler_state");
  379.  
  380.    trace_dump_arg(ptr, pipe);
  381.    trace_dump_arg(ptr, state);
  382.  
  383.    pipe->delete_sampler_state(pipe, state);
  384.  
  385.    trace_dump_call_end();
  386. }
  387.  
  388.  
  389. static INLINE void *
  390. trace_context_create_rasterizer_state(struct pipe_context *_pipe,
  391.                                       const struct pipe_rasterizer_state *state)
  392. {
  393.    struct trace_context *tr_ctx = trace_context(_pipe);
  394.    struct pipe_context *pipe = tr_ctx->pipe;
  395.    void * result;
  396.  
  397.    trace_dump_call_begin("pipe_context", "create_rasterizer_state");
  398.  
  399.    trace_dump_arg(ptr, pipe);
  400.    trace_dump_arg(rasterizer_state, state);
  401.  
  402.    result = pipe->create_rasterizer_state(pipe, state);
  403.  
  404.    trace_dump_ret(ptr, result);
  405.  
  406.    trace_dump_call_end();
  407.  
  408.    return result;
  409. }
  410.  
  411.  
  412. static INLINE void
  413. trace_context_bind_rasterizer_state(struct pipe_context *_pipe,
  414.                                     void *state)
  415. {
  416.    struct trace_context *tr_ctx = trace_context(_pipe);
  417.    struct pipe_context *pipe = tr_ctx->pipe;
  418.  
  419.    trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
  420.  
  421.    trace_dump_arg(ptr, pipe);
  422.    trace_dump_arg(ptr, state);
  423.  
  424.    pipe->bind_rasterizer_state(pipe, state);
  425.  
  426.    trace_dump_call_end();
  427. }
  428.  
  429.  
  430. static INLINE void
  431. trace_context_delete_rasterizer_state(struct pipe_context *_pipe,
  432.                                       void *state)
  433. {
  434.    struct trace_context *tr_ctx = trace_context(_pipe);
  435.    struct pipe_context *pipe = tr_ctx->pipe;
  436.  
  437.    trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
  438.  
  439.    trace_dump_arg(ptr, pipe);
  440.    trace_dump_arg(ptr, state);
  441.  
  442.    pipe->delete_rasterizer_state(pipe, state);
  443.  
  444.    trace_dump_call_end();
  445. }
  446.  
  447.  
  448. static INLINE void *
  449. trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
  450.                                                const struct pipe_depth_stencil_alpha_state *state)
  451. {
  452.    struct trace_context *tr_ctx = trace_context(_pipe);
  453.    struct pipe_context *pipe = tr_ctx->pipe;
  454.    void * result;
  455.  
  456.    trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
  457.  
  458.    result = pipe->create_depth_stencil_alpha_state(pipe, state);
  459.  
  460.    trace_dump_arg(ptr, pipe);
  461.    trace_dump_arg(depth_stencil_alpha_state, state);
  462.  
  463.    trace_dump_ret(ptr, result);
  464.  
  465.    trace_dump_call_end();
  466.  
  467.    return result;
  468. }
  469.  
  470.  
  471. static INLINE void
  472. trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
  473.                                              void *state)
  474. {
  475.    struct trace_context *tr_ctx = trace_context(_pipe);
  476.    struct pipe_context *pipe = tr_ctx->pipe;
  477.  
  478.    trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
  479.  
  480.    trace_dump_arg(ptr, pipe);
  481.    trace_dump_arg(ptr, state);
  482.  
  483.    pipe->bind_depth_stencil_alpha_state(pipe, state);
  484.  
  485.    trace_dump_call_end();
  486. }
  487.  
  488.  
  489. static INLINE void
  490. trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
  491.                                                void *state)
  492. {
  493.    struct trace_context *tr_ctx = trace_context(_pipe);
  494.    struct pipe_context *pipe = tr_ctx->pipe;
  495.  
  496.    trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
  497.  
  498.    trace_dump_arg(ptr, pipe);
  499.    trace_dump_arg(ptr, state);
  500.  
  501.    pipe->delete_depth_stencil_alpha_state(pipe, state);
  502.  
  503.    trace_dump_call_end();
  504. }
  505.  
  506.  
  507. #define TRACE_SHADER_STATE(shader_type) \
  508.    static INLINE void * \
  509.    trace_context_create_##shader_type##_state(struct pipe_context *_pipe, \
  510.                                  const struct pipe_shader_state *state) \
  511.    { \
  512.       struct trace_context *tr_ctx = trace_context(_pipe); \
  513.       struct pipe_context *pipe = tr_ctx->pipe; \
  514.       void * result; \
  515.       trace_dump_call_begin("pipe_context", "create_" #shader_type "_state"); \
  516.       trace_dump_arg(ptr, pipe); \
  517.       trace_dump_arg(shader_state, state); \
  518.       result = pipe->create_##shader_type##_state(pipe, state); \
  519.       trace_dump_ret(ptr, result); \
  520.       trace_dump_call_end(); \
  521.       return result; \
  522.    } \
  523.     \
  524.    static INLINE void \
  525.    trace_context_bind_##shader_type##_state(struct pipe_context *_pipe, \
  526.                                void *state) \
  527.    { \
  528.       struct trace_context *tr_ctx = trace_context(_pipe); \
  529.       struct pipe_context *pipe = tr_ctx->pipe; \
  530.       trace_dump_call_begin("pipe_context", "bind_" #shader_type "_state"); \
  531.       trace_dump_arg(ptr, pipe); \
  532.       trace_dump_arg(ptr, state); \
  533.       pipe->bind_##shader_type##_state(pipe, state); \
  534.       trace_dump_call_end(); \
  535.    } \
  536.     \
  537.    static INLINE void \
  538.    trace_context_delete_##shader_type##_state(struct pipe_context *_pipe, \
  539.                                  void *state) \
  540.    { \
  541.       struct trace_context *tr_ctx = trace_context(_pipe); \
  542.       struct pipe_context *pipe = tr_ctx->pipe; \
  543.       trace_dump_call_begin("pipe_context", "delete_" #shader_type "_state"); \
  544.       trace_dump_arg(ptr, pipe); \
  545.       trace_dump_arg(ptr, state); \
  546.       pipe->delete_##shader_type##_state(pipe, state); \
  547.       trace_dump_call_end(); \
  548.    }
  549.  
  550. TRACE_SHADER_STATE(fs)
  551. TRACE_SHADER_STATE(vs)
  552. TRACE_SHADER_STATE(gs)
  553.  
  554. #undef TRACE_SHADER_STATE
  555.  
  556.  
  557. static INLINE void *
  558. trace_context_create_vertex_elements_state(struct pipe_context *_pipe,
  559.                                            unsigned num_elements,
  560.                                            const struct  pipe_vertex_element *elements)
  561. {
  562.    struct trace_context *tr_ctx = trace_context(_pipe);
  563.    struct pipe_context *pipe = tr_ctx->pipe;
  564.    void * result;
  565.  
  566.    trace_dump_call_begin("pipe_context", "create_vertex_elements_state");
  567.  
  568.    trace_dump_arg(ptr, pipe);
  569.    trace_dump_arg(uint, num_elements);
  570.  
  571.    trace_dump_arg_begin("elements");
  572.    trace_dump_struct_array(vertex_element, elements, num_elements);
  573.    trace_dump_arg_end();
  574.  
  575.    result = pipe->create_vertex_elements_state(pipe, num_elements, elements);
  576.  
  577.    trace_dump_ret(ptr, result);
  578.  
  579.    trace_dump_call_end();
  580.  
  581.    return result;
  582. }
  583.  
  584.  
  585. static INLINE void
  586. trace_context_bind_vertex_elements_state(struct pipe_context *_pipe,
  587.                                          void *state)
  588. {
  589.    struct trace_context *tr_ctx = trace_context(_pipe);
  590.    struct pipe_context *pipe = tr_ctx->pipe;
  591.  
  592.    trace_dump_call_begin("pipe_context", "bind_vertex_elements_state");
  593.  
  594.    trace_dump_arg(ptr, pipe);
  595.    trace_dump_arg(ptr, state);
  596.  
  597.    pipe->bind_vertex_elements_state(pipe, state);
  598.  
  599.    trace_dump_call_end();
  600. }
  601.  
  602.  
  603. static INLINE void
  604. trace_context_delete_vertex_elements_state(struct pipe_context *_pipe,
  605.                                            void *state)
  606. {
  607.    struct trace_context *tr_ctx = trace_context(_pipe);
  608.    struct pipe_context *pipe = tr_ctx->pipe;
  609.  
  610.    trace_dump_call_begin("pipe_context", "delete_vertex_elements_state");
  611.  
  612.    trace_dump_arg(ptr, pipe);
  613.    trace_dump_arg(ptr, state);
  614.  
  615.    pipe->delete_vertex_elements_state(pipe, state);
  616.  
  617.    trace_dump_call_end();
  618. }
  619.  
  620.  
  621. static INLINE void
  622. trace_context_set_blend_color(struct pipe_context *_pipe,
  623.                               const struct pipe_blend_color *state)
  624. {
  625.    struct trace_context *tr_ctx = trace_context(_pipe);
  626.    struct pipe_context *pipe = tr_ctx->pipe;
  627.  
  628.    trace_dump_call_begin("pipe_context", "set_blend_color");
  629.  
  630.    trace_dump_arg(ptr, pipe);
  631.    trace_dump_arg(blend_color, state);
  632.  
  633.    pipe->set_blend_color(pipe, state);
  634.  
  635.    trace_dump_call_end();
  636. }
  637.  
  638.  
  639. static INLINE void
  640. trace_context_set_stencil_ref(struct pipe_context *_pipe,
  641.                               const struct pipe_stencil_ref *state)
  642. {
  643.    struct trace_context *tr_ctx = trace_context(_pipe);
  644.    struct pipe_context *pipe = tr_ctx->pipe;
  645.  
  646.    trace_dump_call_begin("pipe_context", "set_stencil_ref");
  647.  
  648.    trace_dump_arg(ptr, pipe);
  649.    trace_dump_arg(stencil_ref, state);
  650.  
  651.    pipe->set_stencil_ref(pipe, state);
  652.  
  653.    trace_dump_call_end();
  654. }
  655.  
  656.  
  657. static INLINE void
  658. trace_context_set_clip_state(struct pipe_context *_pipe,
  659.                              const struct pipe_clip_state *state)
  660. {
  661.    struct trace_context *tr_ctx = trace_context(_pipe);
  662.    struct pipe_context *pipe = tr_ctx->pipe;
  663.  
  664.    trace_dump_call_begin("pipe_context", "set_clip_state");
  665.  
  666.    trace_dump_arg(ptr, pipe);
  667.    trace_dump_arg(clip_state, state);
  668.  
  669.    pipe->set_clip_state(pipe, state);
  670.  
  671.    trace_dump_call_end();
  672. }
  673.  
  674. static INLINE void
  675. trace_context_set_sample_mask(struct pipe_context *_pipe,
  676.                               unsigned sample_mask)
  677. {
  678.    struct trace_context *tr_ctx = trace_context(_pipe);
  679.    struct pipe_context *pipe = tr_ctx->pipe;
  680.  
  681.    trace_dump_call_begin("pipe_context", "set_sample_mask");
  682.  
  683.    trace_dump_arg(ptr, pipe);
  684.    trace_dump_arg(uint, sample_mask);
  685.  
  686.    pipe->set_sample_mask(pipe, sample_mask);
  687.  
  688.    trace_dump_call_end();
  689. }
  690.  
  691. static INLINE void
  692. trace_context_set_constant_buffer(struct pipe_context *_pipe,
  693.                                   uint shader, uint index,
  694.                                   struct pipe_constant_buffer *constant_buffer)
  695. {
  696.    struct trace_context *tr_ctx = trace_context(_pipe);
  697.    struct pipe_context *pipe = tr_ctx->pipe;
  698.    struct pipe_constant_buffer cb;
  699.  
  700.    if (constant_buffer) {
  701.       cb = *constant_buffer;
  702.       cb.buffer = trace_resource_unwrap(tr_ctx, constant_buffer->buffer);
  703.       constant_buffer = &cb;
  704.    }
  705.  
  706.    trace_dump_call_begin("pipe_context", "set_constant_buffer");
  707.  
  708.    trace_dump_arg(ptr, pipe);
  709.    trace_dump_arg(uint, shader);
  710.    trace_dump_arg(uint, index);
  711.    trace_dump_arg(constant_buffer, constant_buffer);
  712.  
  713.    pipe->set_constant_buffer(pipe, shader, index, constant_buffer);
  714.  
  715.    trace_dump_call_end();
  716. }
  717.  
  718.  
  719. static INLINE void
  720. trace_context_set_framebuffer_state(struct pipe_context *_pipe,
  721.                                     const struct pipe_framebuffer_state *state)
  722. {
  723.    struct trace_context *tr_ctx = trace_context(_pipe);
  724.    struct pipe_context *pipe = tr_ctx->pipe;
  725.    struct pipe_framebuffer_state unwrapped_state;
  726.    unsigned i;
  727.  
  728.  
  729.    /* Unwrap the input state */
  730.    memcpy(&unwrapped_state, state, sizeof(unwrapped_state));
  731.    for(i = 0; i < state->nr_cbufs; ++i)
  732.       unwrapped_state.cbufs[i] = trace_surface_unwrap(tr_ctx, state->cbufs[i]);
  733.    for(i = state->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; ++i)
  734.       unwrapped_state.cbufs[i] = NULL;
  735.    unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf);
  736.    state = &unwrapped_state;
  737.  
  738.    trace_dump_call_begin("pipe_context", "set_framebuffer_state");
  739.  
  740.    trace_dump_arg(ptr, pipe);
  741.    trace_dump_arg(framebuffer_state, state);
  742.  
  743.    pipe->set_framebuffer_state(pipe, state);
  744.  
  745.    trace_dump_call_end();
  746. }
  747.  
  748.  
  749. static INLINE void
  750. trace_context_set_polygon_stipple(struct pipe_context *_pipe,
  751.                                   const struct pipe_poly_stipple *state)
  752. {
  753.    struct trace_context *tr_ctx = trace_context(_pipe);
  754.    struct pipe_context *pipe = tr_ctx->pipe;
  755.  
  756.    trace_dump_call_begin("pipe_context", "set_polygon_stipple");
  757.  
  758.    trace_dump_arg(ptr, pipe);
  759.    trace_dump_arg(poly_stipple, state);
  760.  
  761.    pipe->set_polygon_stipple(pipe, state);
  762.  
  763.    trace_dump_call_end();
  764. }
  765.  
  766.  
  767. static INLINE void
  768. trace_context_set_scissor_states(struct pipe_context *_pipe,
  769.                                  unsigned start_slot,
  770.                                  unsigned num_scissors,
  771.                                  const struct pipe_scissor_state *states)
  772. {
  773.    struct trace_context *tr_ctx = trace_context(_pipe);
  774.    struct pipe_context *pipe = tr_ctx->pipe;
  775.  
  776.    trace_dump_call_begin("pipe_context", "set_scissor_states");
  777.  
  778.    trace_dump_arg(ptr, pipe);
  779.    trace_dump_arg(uint, start_slot);
  780.    trace_dump_arg(uint, num_scissors);
  781.    trace_dump_arg(scissor_state, states);
  782.  
  783.    pipe->set_scissor_states(pipe, start_slot, num_scissors, states);
  784.  
  785.    trace_dump_call_end();
  786. }
  787.  
  788.  
  789. static INLINE void
  790. trace_context_set_viewport_states(struct pipe_context *_pipe,
  791.                                   unsigned start_slot,
  792.                                   unsigned num_viewports,
  793.                                   const struct pipe_viewport_state *states)
  794. {
  795.    struct trace_context *tr_ctx = trace_context(_pipe);
  796.    struct pipe_context *pipe = tr_ctx->pipe;
  797.  
  798.    trace_dump_call_begin("pipe_context", "set_viewport_states");
  799.  
  800.    trace_dump_arg(ptr, pipe);
  801.    trace_dump_arg(uint, start_slot);
  802.    trace_dump_arg(uint, num_viewports);
  803.    trace_dump_arg(viewport_state, states);
  804.  
  805.    pipe->set_viewport_states(pipe, start_slot, num_viewports, states);
  806.  
  807.    trace_dump_call_end();
  808. }
  809.  
  810.  
  811. static struct pipe_sampler_view *
  812. trace_context_create_sampler_view(struct pipe_context *_pipe,
  813.                           struct pipe_resource *_resource,
  814.                           const struct pipe_sampler_view *templ)
  815. {
  816.    struct trace_context *tr_ctx = trace_context(_pipe);
  817.    struct trace_resource *tr_res = trace_resource(_resource);
  818.    struct pipe_context *pipe = tr_ctx->pipe;
  819.    struct pipe_resource *resource = tr_res->resource;
  820.    struct pipe_sampler_view *result;
  821.    struct trace_sampler_view *tr_view;
  822.  
  823.    trace_dump_call_begin("pipe_context", "create_sampler_view");
  824.  
  825.    trace_dump_arg(ptr, pipe);
  826.    trace_dump_arg(ptr, resource);
  827.  
  828.    trace_dump_arg_begin("templ");
  829.    trace_dump_sampler_view_template(templ, resource->target);
  830.    trace_dump_arg_end();
  831.  
  832.    result = pipe->create_sampler_view(pipe, resource, templ);
  833.  
  834.    trace_dump_ret(ptr, result);
  835.  
  836.    trace_dump_call_end();
  837.  
  838.    /*
  839.     * Wrap pipe_sampler_view
  840.     */
  841.    tr_view = CALLOC_STRUCT(trace_sampler_view);
  842.    tr_view->base = *templ;
  843.    tr_view->base.reference.count = 1;
  844.    tr_view->base.texture = NULL;
  845.    pipe_resource_reference(&tr_view->base.texture, _resource);
  846.    tr_view->base.context = _pipe;
  847.    tr_view->sampler_view = result;
  848.    result = &tr_view->base;
  849.  
  850.    return result;
  851. }
  852.  
  853.  
  854. static void
  855. trace_context_sampler_view_destroy(struct pipe_context *_pipe,
  856.                            struct pipe_sampler_view *_view)
  857. {
  858.    struct trace_context *tr_ctx = trace_context(_pipe);
  859.    struct trace_sampler_view *tr_view = trace_sampler_view(_view);
  860.    struct pipe_context *pipe = tr_ctx->pipe;
  861.    struct pipe_sampler_view *view = tr_view->sampler_view;
  862.  
  863.    assert(_view->context == _pipe);
  864.  
  865.    trace_dump_call_begin("pipe_context", "sampler_view_destroy");
  866.  
  867.    trace_dump_arg(ptr, pipe);
  868.    trace_dump_arg(ptr, view);
  869.  
  870.    pipe_sampler_view_reference(&tr_view->sampler_view, NULL);
  871.  
  872.    trace_dump_call_end();
  873.  
  874.    pipe_resource_reference(&_view->texture, NULL);
  875.    FREE(_view);
  876. }
  877.  
  878. /********************************************************************
  879.  * surface
  880.  */
  881.  
  882.  
  883. static struct pipe_surface *
  884. trace_context_create_surface(struct pipe_context *_pipe,
  885.                              struct pipe_resource *_resource,
  886.                              const struct pipe_surface *surf_tmpl)
  887. {
  888.    struct trace_context *tr_ctx = trace_context(_pipe);
  889.    struct trace_resource *tr_res = trace_resource(_resource);
  890.    struct pipe_context *pipe = tr_ctx->pipe;
  891.    struct pipe_resource *resource = tr_res->resource;
  892.    struct pipe_surface *result = NULL;
  893.  
  894.    trace_dump_call_begin("pipe_context", "create_surface");
  895.  
  896.    trace_dump_arg(ptr, pipe);
  897.    trace_dump_arg(ptr, resource);
  898.    
  899.    trace_dump_arg_begin("surf_tmpl");
  900.    trace_dump_surface_template(surf_tmpl, resource->target);
  901.    trace_dump_arg_end();
  902.  
  903.  
  904.    result = pipe->create_surface(pipe, resource, surf_tmpl);
  905.  
  906.    trace_dump_ret(ptr, result);
  907.  
  908.    trace_dump_call_end();
  909.  
  910.    result = trace_surf_create(tr_ctx, tr_res, result);
  911.  
  912.    return result;
  913. }
  914.  
  915.  
  916. static void
  917. trace_context_surface_destroy(struct pipe_context *_pipe,
  918.                               struct pipe_surface *_surface)
  919. {
  920.    struct trace_context *tr_ctx = trace_context(_pipe);
  921.    struct pipe_context *pipe = tr_ctx->pipe;
  922.    struct trace_surface *tr_surf = trace_surface(_surface);
  923.    struct pipe_surface *surface = tr_surf->surface;
  924.  
  925.    trace_dump_call_begin("pipe_context", "surface_destroy");
  926.  
  927.    trace_dump_arg(ptr, pipe);
  928.    trace_dump_arg(ptr, surface);
  929.  
  930.    trace_dump_call_end();
  931.  
  932.    trace_surf_destroy(tr_surf);
  933. }
  934.  
  935.  
  936. static INLINE void
  937. trace_context_set_sampler_views(struct pipe_context *_pipe,
  938.                                 unsigned shader,
  939.                                 unsigned start,
  940.                                 unsigned num,
  941.                                 struct pipe_sampler_view **views)
  942. {
  943.    struct trace_context *tr_ctx = trace_context(_pipe);
  944.    struct trace_sampler_view *tr_view;
  945.    struct pipe_context *pipe = tr_ctx->pipe;
  946.    struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS];
  947.    unsigned i;
  948.  
  949.    /* remove this when we have pipe->set_sampler_views(..., start, ...) */
  950.    assert(start == 0);
  951.  
  952.    for(i = 0; i < num; ++i) {
  953.       tr_view = trace_sampler_view(views[i]);
  954.       unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
  955.    }
  956.    views = unwrapped_views;
  957.  
  958.    switch (shader) {
  959.    case PIPE_SHADER_VERTEX:
  960.       trace_dump_call_begin("pipe_context", "set_vertex_sampler_views");
  961.       break;
  962.    case PIPE_SHADER_GEOMETRY:
  963.       trace_dump_call_begin("pipe_context", "set_geometry_sampler_views");
  964.       break;
  965.    case PIPE_SHADER_FRAGMENT:
  966.       trace_dump_call_begin("pipe_context", "set_fragment_sampler_views");
  967.       break;
  968.    default:
  969.       debug_error("Unexpected shader in trace_context_set_sampler_views()");
  970.    }
  971.  
  972.    trace_dump_arg(ptr, pipe);
  973.    /*trace_dump_arg(uint, shader);*/
  974.    trace_dump_arg(uint, num);
  975.    trace_dump_arg_array(ptr, views, num);
  976.  
  977.    switch (shader) {
  978.    case PIPE_SHADER_VERTEX:
  979.       pipe->set_vertex_sampler_views(pipe, num, views);
  980.       break;
  981.    case PIPE_SHADER_GEOMETRY:
  982.       pipe->set_geometry_sampler_views(pipe, num, views);
  983.       break;
  984.    case PIPE_SHADER_FRAGMENT:
  985.       pipe->set_fragment_sampler_views(pipe, num, views);
  986.       break;
  987.    default:
  988.       debug_error("Unexpected shader in trace_context_set_sampler_views()");
  989.    }
  990.  
  991.    trace_dump_call_end();
  992. }
  993.  
  994.  
  995. static INLINE void
  996. trace_context_set_fragment_sampler_views(struct pipe_context *_pipe,
  997.                                          unsigned num,
  998.                                          struct pipe_sampler_view **views)
  999. {
  1000.    trace_context_set_sampler_views(_pipe, PIPE_SHADER_FRAGMENT, 0, num, views);
  1001. }
  1002.  
  1003.  
  1004. static INLINE void
  1005. trace_context_set_vertex_sampler_views(struct pipe_context *_pipe,
  1006.                                        unsigned num,
  1007.                                        struct pipe_sampler_view **views)
  1008. {
  1009.    trace_context_set_sampler_views(_pipe, PIPE_SHADER_VERTEX, 0, num, views);
  1010. }
  1011.  
  1012.  
  1013. static INLINE void
  1014. trace_context_set_geometry_sampler_views(struct pipe_context *_pipe,
  1015.                                        unsigned num,
  1016.                                        struct pipe_sampler_view **views)
  1017. {
  1018.    trace_context_set_sampler_views(_pipe, PIPE_SHADER_GEOMETRY, 0, num, views);
  1019. }
  1020.  
  1021.  
  1022. static INLINE void
  1023. trace_context_set_vertex_buffers(struct pipe_context *_pipe,
  1024.                                  unsigned start_slot, unsigned num_buffers,
  1025.                                  const struct pipe_vertex_buffer *buffers)
  1026. {
  1027.    struct trace_context *tr_ctx = trace_context(_pipe);
  1028.    struct pipe_context *pipe = tr_ctx->pipe;
  1029.    unsigned i;
  1030.  
  1031.    trace_dump_call_begin("pipe_context", "set_vertex_buffers");
  1032.  
  1033.    trace_dump_arg(ptr, pipe);
  1034.    trace_dump_arg(uint, start_slot);
  1035.    trace_dump_arg(uint, num_buffers);
  1036.  
  1037.    trace_dump_arg_begin("buffers");
  1038.    trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
  1039.    trace_dump_arg_end();
  1040.  
  1041.    if (buffers) {
  1042.       struct pipe_vertex_buffer *_buffers = MALLOC(num_buffers * sizeof(*_buffers));
  1043.       memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers));
  1044.       for (i = 0; i < num_buffers; i++)
  1045.          _buffers[i].buffer = trace_resource_unwrap(tr_ctx, buffers[i].buffer);
  1046.       pipe->set_vertex_buffers(pipe, start_slot, num_buffers, _buffers);
  1047.       FREE(_buffers);
  1048.    } else {
  1049.       pipe->set_vertex_buffers(pipe, start_slot, num_buffers, NULL);
  1050.    }
  1051.  
  1052.    trace_dump_call_end();
  1053. }
  1054.  
  1055.  
  1056. static INLINE void
  1057. trace_context_set_index_buffer(struct pipe_context *_pipe,
  1058.                                const struct pipe_index_buffer *ib)
  1059. {
  1060.    struct trace_context *tr_ctx = trace_context(_pipe);
  1061.    struct pipe_context *pipe = tr_ctx->pipe;
  1062.  
  1063.    trace_dump_call_begin("pipe_context", "set_index_buffer");
  1064.  
  1065.    trace_dump_arg(ptr, pipe);
  1066.    trace_dump_arg(index_buffer, ib);
  1067.  
  1068.    if (ib) {
  1069.       struct pipe_index_buffer _ib;
  1070.       _ib = *ib;
  1071.       _ib.buffer = trace_resource_unwrap(tr_ctx, ib->buffer);
  1072.       pipe->set_index_buffer(pipe, &_ib);
  1073.    } else {
  1074.       pipe->set_index_buffer(pipe, NULL);
  1075.    }
  1076.  
  1077.    trace_dump_call_end();
  1078. }
  1079.  
  1080.  
  1081. static INLINE struct pipe_stream_output_target *
  1082. trace_context_create_stream_output_target(struct pipe_context *_pipe,
  1083.                                           struct pipe_resource *res,
  1084.                                           unsigned buffer_offset,
  1085.                                           unsigned buffer_size)
  1086. {
  1087.    struct trace_context *tr_ctx = trace_context(_pipe);
  1088.    struct pipe_context *pipe = tr_ctx->pipe;
  1089.    struct pipe_stream_output_target *result;
  1090.  
  1091.    res = trace_resource_unwrap(tr_ctx, res);
  1092.  
  1093.    trace_dump_call_begin("pipe_context", "create_stream_output_target");
  1094.  
  1095.    trace_dump_arg(ptr, pipe);
  1096.    trace_dump_arg(ptr, res);
  1097.    trace_dump_arg(uint, buffer_offset);
  1098.    trace_dump_arg(uint, buffer_size);
  1099.  
  1100.    result = pipe->create_stream_output_target(pipe,
  1101.                                               res, buffer_offset, buffer_size);
  1102.  
  1103.    trace_dump_ret(ptr, result);
  1104.  
  1105.    trace_dump_call_end();
  1106.  
  1107.    return result;
  1108. }
  1109.  
  1110.  
  1111. static INLINE void
  1112. trace_context_stream_output_target_destroy(
  1113.    struct pipe_context *_pipe,
  1114.    struct pipe_stream_output_target *target)
  1115. {
  1116.    struct trace_context *tr_ctx = trace_context(_pipe);
  1117.    struct pipe_context *pipe = tr_ctx->pipe;
  1118.  
  1119.    trace_dump_call_begin("pipe_context", "stream_output_target_destroy");
  1120.  
  1121.    trace_dump_arg(ptr, pipe);
  1122.    trace_dump_arg(ptr, target);
  1123.  
  1124.    pipe->stream_output_target_destroy(pipe, target);
  1125.  
  1126.    trace_dump_call_end();
  1127. }
  1128.  
  1129.  
  1130. static INLINE void
  1131. trace_context_set_stream_output_targets(struct pipe_context *_pipe,
  1132.                                         unsigned num_targets,
  1133.                                         struct pipe_stream_output_target **tgs,
  1134.                                         unsigned append_bitmask)
  1135. {
  1136.    struct trace_context *tr_ctx = trace_context(_pipe);
  1137.    struct pipe_context *pipe = tr_ctx->pipe;
  1138.  
  1139.    trace_dump_call_begin("pipe_context", "set_stream_output_targets");
  1140.  
  1141.    trace_dump_arg(ptr, pipe);
  1142.    trace_dump_arg(uint, num_targets);
  1143.    trace_dump_arg_array(ptr, tgs, num_targets);
  1144.    trace_dump_arg(uint, append_bitmask);
  1145.  
  1146.    pipe->set_stream_output_targets(pipe, num_targets, tgs, append_bitmask);
  1147.  
  1148.    trace_dump_call_end();
  1149. }
  1150.  
  1151.  
  1152. static INLINE void
  1153. trace_context_resource_copy_region(struct pipe_context *_pipe,
  1154.                                    struct pipe_resource *dst,
  1155.                                    unsigned dst_level,
  1156.                                    unsigned dstx, unsigned dsty, unsigned dstz,
  1157.                                    struct pipe_resource *src,
  1158.                                    unsigned src_level,
  1159.                                    const struct pipe_box *src_box)
  1160. {
  1161.    struct trace_context *tr_ctx = trace_context(_pipe);
  1162.    struct pipe_context *pipe = tr_ctx->pipe;
  1163.  
  1164.    dst = trace_resource_unwrap(tr_ctx, dst);
  1165.    src = trace_resource_unwrap(tr_ctx, src);
  1166.  
  1167.    trace_dump_call_begin("pipe_context", "resource_copy_region");
  1168.  
  1169.    trace_dump_arg(ptr, pipe);
  1170.    trace_dump_arg(ptr, dst);
  1171.    trace_dump_arg(uint, dst_level);
  1172.    trace_dump_arg(uint, dstx);
  1173.    trace_dump_arg(uint, dsty);
  1174.    trace_dump_arg(uint, dstz);
  1175.    trace_dump_arg(ptr, src);
  1176.    trace_dump_arg(uint, src_level);
  1177.    trace_dump_arg(box, src_box);
  1178.  
  1179.    pipe->resource_copy_region(pipe,
  1180.                               dst, dst_level, dstx, dsty, dstz,
  1181.                               src, src_level, src_box);
  1182.  
  1183.    trace_dump_call_end();
  1184. }
  1185.  
  1186.  
  1187. static INLINE void
  1188. trace_context_blit(struct pipe_context *_pipe,
  1189.                    const struct pipe_blit_info *_info)
  1190. {
  1191.    struct trace_context *tr_ctx = trace_context(_pipe);
  1192.    struct pipe_context *pipe = tr_ctx->pipe;
  1193.    struct pipe_blit_info info = *_info;
  1194.  
  1195.    info.dst.resource = trace_resource_unwrap(tr_ctx, info.dst.resource);
  1196.    info.src.resource = trace_resource_unwrap(tr_ctx, info.src.resource);
  1197.  
  1198.    trace_dump_call_begin("pipe_context", "blit");
  1199.  
  1200.    trace_dump_arg(ptr, pipe);
  1201.    trace_dump_arg(blit_info, _info);
  1202.  
  1203.    pipe->blit(pipe, &info);
  1204.  
  1205.    trace_dump_call_end();
  1206. }
  1207.  
  1208.  
  1209. static INLINE void
  1210. trace_context_clear(struct pipe_context *_pipe,
  1211.                     unsigned buffers,
  1212.                     const union pipe_color_union *color,
  1213.                     double depth,
  1214.                     unsigned stencil)
  1215. {
  1216.    struct trace_context *tr_ctx = trace_context(_pipe);
  1217.    struct pipe_context *pipe = tr_ctx->pipe;
  1218.  
  1219.    trace_dump_call_begin("pipe_context", "clear");
  1220.  
  1221.    trace_dump_arg(ptr, pipe);
  1222.    trace_dump_arg(uint, buffers);
  1223.    trace_dump_arg_begin("color");
  1224.    if (color)
  1225.       trace_dump_array(float, color->f, 4);
  1226.    else
  1227.       trace_dump_null();
  1228.    trace_dump_arg_end();
  1229.    trace_dump_arg(float, depth);
  1230.    trace_dump_arg(uint, stencil);
  1231.  
  1232.    pipe->clear(pipe, buffers, color, depth, stencil);
  1233.  
  1234.    trace_dump_call_end();
  1235. }
  1236.  
  1237.  
  1238. static INLINE void
  1239. trace_context_clear_render_target(struct pipe_context *_pipe,
  1240.                                   struct pipe_surface *dst,
  1241.                                   const union pipe_color_union *color,
  1242.                                   unsigned dstx, unsigned dsty,
  1243.                                   unsigned width, unsigned height)
  1244. {
  1245.    struct trace_context *tr_ctx = trace_context(_pipe);
  1246.    struct pipe_context *pipe = tr_ctx->pipe;
  1247.  
  1248.    dst = trace_surface_unwrap(tr_ctx, dst);
  1249.  
  1250.    trace_dump_call_begin("pipe_context", "clear_render_target");
  1251.  
  1252.    trace_dump_arg(ptr, pipe);
  1253.    trace_dump_arg(ptr, dst);
  1254.    trace_dump_arg_array(float, color->f, 4);
  1255.    trace_dump_arg(uint, dstx);
  1256.    trace_dump_arg(uint, dsty);
  1257.    trace_dump_arg(uint, width);
  1258.    trace_dump_arg(uint, height);
  1259.  
  1260.    pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height);
  1261.  
  1262.    trace_dump_call_end();
  1263. }
  1264.  
  1265. static INLINE void
  1266. trace_context_clear_depth_stencil(struct pipe_context *_pipe,
  1267.                                   struct pipe_surface *dst,
  1268.                                   unsigned clear_flags,
  1269.                                   double depth,
  1270.                                   unsigned stencil,
  1271.                                   unsigned dstx, unsigned dsty,
  1272.                                   unsigned width, unsigned height)
  1273. {
  1274.    struct trace_context *tr_ctx = trace_context(_pipe);
  1275.    struct pipe_context *pipe = tr_ctx->pipe;
  1276.  
  1277.    dst = trace_surface_unwrap(tr_ctx, dst);
  1278.  
  1279.    trace_dump_call_begin("pipe_context", "clear_depth_stencil");
  1280.  
  1281.    trace_dump_arg(ptr, pipe);
  1282.    trace_dump_arg(ptr, dst);
  1283.    trace_dump_arg(uint, clear_flags);
  1284.    trace_dump_arg(float, depth);
  1285.    trace_dump_arg(uint, stencil);
  1286.    trace_dump_arg(uint, dstx);
  1287.    trace_dump_arg(uint, dsty);
  1288.    trace_dump_arg(uint, width);
  1289.    trace_dump_arg(uint, height);
  1290.  
  1291.    pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil,
  1292.                              dstx, dsty, width, height);
  1293.  
  1294.    trace_dump_call_end();
  1295. }
  1296.  
  1297. static INLINE void
  1298. trace_context_flush(struct pipe_context *_pipe,
  1299.                     struct pipe_fence_handle **fence,
  1300.                     unsigned flags)
  1301. {
  1302.    struct trace_context *tr_ctx = trace_context(_pipe);
  1303.    struct pipe_context *pipe = tr_ctx->pipe;
  1304.  
  1305.    trace_dump_call_begin("pipe_context", "flush");
  1306.  
  1307.    trace_dump_arg(ptr, pipe);
  1308.    trace_dump_arg(uint, flags);
  1309.  
  1310.    pipe->flush(pipe, fence, flags);
  1311.  
  1312.    if(fence)
  1313.       trace_dump_ret(ptr, *fence);
  1314.  
  1315.    trace_dump_call_end();
  1316. }
  1317.  
  1318.  
  1319. static INLINE void
  1320. trace_context_destroy(struct pipe_context *_pipe)
  1321. {
  1322.    struct trace_context *tr_ctx = trace_context(_pipe);
  1323.    struct pipe_context *pipe = tr_ctx->pipe;
  1324.  
  1325.    trace_dump_call_begin("pipe_context", "destroy");
  1326.    trace_dump_arg(ptr, pipe);
  1327.    trace_dump_call_end();
  1328.  
  1329.    pipe->destroy(pipe);
  1330.  
  1331.    FREE(tr_ctx);
  1332. }
  1333.  
  1334.  
  1335. /********************************************************************
  1336.  * transfer
  1337.  */
  1338.  
  1339.  
  1340. static void *
  1341. trace_context_transfer_map(struct pipe_context *_context,
  1342.                            struct pipe_resource *_resource,
  1343.                            unsigned level,
  1344.                            unsigned usage,
  1345.                            const struct pipe_box *box,
  1346.                            struct pipe_transfer **transfer)
  1347. {
  1348.    struct trace_context *tr_context = trace_context(_context);
  1349.    struct trace_resource *tr_res = trace_resource(_resource);
  1350.    struct pipe_context *context = tr_context->pipe;
  1351.    struct pipe_resource *texture = tr_res->resource;
  1352.    struct pipe_transfer *result = NULL;
  1353.    void *map;
  1354.  
  1355.    assert(texture->screen == context->screen);
  1356.  
  1357.    /*
  1358.     * Map and transfers can't be serialized so we convert all write transfers
  1359.     * to transfer_inline_write and ignore read transfers.
  1360.     */
  1361.  
  1362.    map = context->transfer_map(context, texture, level, usage, box, &result);
  1363.    if (!map)
  1364.       return NULL;
  1365.  
  1366.    *transfer = trace_transfer_create(tr_context, tr_res, result);
  1367.  
  1368.    if (map) {
  1369.       if(usage & PIPE_TRANSFER_WRITE) {
  1370.          trace_transfer(*transfer)->map = map;
  1371.       }
  1372.    }
  1373.  
  1374.    return *transfer ? map : NULL;
  1375. }
  1376.  
  1377. static void
  1378. trace_context_transfer_flush_region( struct pipe_context *_context,
  1379.                                      struct pipe_transfer *_transfer,
  1380.                                      const struct pipe_box *box)
  1381. {
  1382.    struct trace_context *tr_context = trace_context(_context);
  1383.    struct trace_transfer *tr_transfer = trace_transfer(_transfer);
  1384.    struct pipe_context *context = tr_context->pipe;
  1385.    struct pipe_transfer *transfer = tr_transfer->transfer;
  1386.  
  1387.    context->transfer_flush_region(context,
  1388.                                   transfer,
  1389.                                   box);
  1390. }
  1391.  
  1392. static void
  1393. trace_context_transfer_unmap(struct pipe_context *_context,
  1394.                              struct pipe_transfer *_transfer)
  1395. {
  1396.    struct trace_context *tr_ctx = trace_context(_context);
  1397.    struct trace_transfer *tr_trans = trace_transfer(_transfer);
  1398.    struct pipe_context *context = tr_ctx->pipe;
  1399.    struct pipe_transfer *transfer = tr_trans->transfer;
  1400.  
  1401.    if(tr_trans->map) {
  1402.       /*
  1403.        * Fake a transfer_inline_write
  1404.        */
  1405.  
  1406.       struct pipe_resource *resource = transfer->resource;
  1407.       unsigned level = transfer->level;
  1408.       unsigned usage = transfer->usage;
  1409.       const struct pipe_box *box = &transfer->box;
  1410.       unsigned stride = transfer->stride;
  1411.       unsigned layer_stride = transfer->layer_stride;
  1412.  
  1413.       trace_dump_call_begin("pipe_context", "transfer_inline_write");
  1414.  
  1415.       trace_dump_arg(ptr, context);
  1416.       trace_dump_arg(ptr, resource);
  1417.       trace_dump_arg(uint, level);
  1418.       trace_dump_arg(uint, usage);
  1419.       trace_dump_arg(box, box);
  1420.  
  1421.       trace_dump_arg_begin("data");
  1422.       trace_dump_box_bytes(tr_trans->map,
  1423.                            resource,
  1424.                            box,
  1425.                            stride,
  1426.                            layer_stride);
  1427.       trace_dump_arg_end();
  1428.  
  1429.       trace_dump_arg(uint, stride);
  1430.       trace_dump_arg(uint, layer_stride);
  1431.  
  1432.       trace_dump_call_end();
  1433.  
  1434.       tr_trans->map = NULL;
  1435.    }
  1436.  
  1437.    context->transfer_unmap(context, transfer);
  1438.    trace_transfer_destroy(tr_ctx, tr_trans);
  1439. }
  1440.  
  1441.  
  1442. static void
  1443. trace_context_transfer_inline_write(struct pipe_context *_context,
  1444.                                     struct pipe_resource *_resource,
  1445.                                     unsigned level,
  1446.                                     unsigned usage,
  1447.                                     const struct pipe_box *box,
  1448.                                     const void *data,
  1449.                                     unsigned stride,
  1450.                                     unsigned layer_stride)
  1451. {
  1452.    struct trace_context *tr_context = trace_context(_context);
  1453.    struct trace_resource *tr_res = trace_resource(_resource);
  1454.    struct pipe_context *context = tr_context->pipe;
  1455.    struct pipe_resource *resource = tr_res->resource;
  1456.  
  1457.    assert(resource->screen == context->screen);
  1458.  
  1459.    trace_dump_call_begin("pipe_context", "transfer_inline_write");
  1460.  
  1461.    trace_dump_arg(ptr, context);
  1462.    trace_dump_arg(ptr, resource);
  1463.    trace_dump_arg(uint, level);
  1464.    trace_dump_arg(uint, usage);
  1465.    trace_dump_arg(box, box);
  1466.  
  1467.    trace_dump_arg_begin("data");
  1468.    trace_dump_box_bytes(data,
  1469.                         resource,
  1470.                         box,
  1471.                         stride,
  1472.                         layer_stride);
  1473.    trace_dump_arg_end();
  1474.  
  1475.    trace_dump_arg(uint, stride);
  1476.    trace_dump_arg(uint, layer_stride);
  1477.  
  1478.    trace_dump_call_end();
  1479.  
  1480.    context->transfer_inline_write(context, resource,
  1481.                                   level, usage, box, data, stride, layer_stride);
  1482. }
  1483.  
  1484.  
  1485. static void trace_context_render_condition(struct pipe_context *_context,
  1486.                                            struct pipe_query *query,
  1487.                                            boolean condition,
  1488.                                            uint mode)
  1489. {
  1490.    struct trace_context *tr_context = trace_context(_context);
  1491.    struct pipe_context *context = tr_context->pipe;
  1492.  
  1493.    trace_dump_call_begin("pipe_context", "render_condition");
  1494.  
  1495.    trace_dump_arg(ptr, context);
  1496.    trace_dump_arg(ptr, query);
  1497.    trace_dump_arg(bool, condition);
  1498.    trace_dump_arg(uint, mode);
  1499.  
  1500.    trace_dump_call_end();
  1501.  
  1502.    context->render_condition(context, query, condition, mode);
  1503. }
  1504.  
  1505.  
  1506. static void trace_context_texture_barrier(struct pipe_context *_context)
  1507. {
  1508.    struct trace_context *tr_context = trace_context(_context);
  1509.    struct pipe_context *context = tr_context->pipe;
  1510.  
  1511.    trace_dump_call_begin("pipe_context", "texture_barrier");
  1512.  
  1513.    trace_dump_arg(ptr, context);
  1514.  
  1515.    trace_dump_call_end();
  1516.  
  1517.    context->texture_barrier(context);
  1518. }
  1519.  
  1520.  
  1521. static const struct debug_named_value rbug_blocker_flags[] = {
  1522.    {"before", 1, NULL},
  1523.    {"after", 2, NULL},
  1524.    DEBUG_NAMED_VALUE_END
  1525. };
  1526.  
  1527. struct pipe_context *
  1528. trace_context_create(struct trace_screen *tr_scr,
  1529.                      struct pipe_context *pipe)
  1530. {
  1531.    struct trace_context *tr_ctx;
  1532.  
  1533.    if(!pipe)
  1534.       goto error1;
  1535.  
  1536.    if(!trace_enabled())
  1537.       goto error1;
  1538.  
  1539.    tr_ctx = CALLOC_STRUCT(trace_context);
  1540.    if(!tr_ctx)
  1541.       goto error1;
  1542.  
  1543.    tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */
  1544.    tr_ctx->base.screen = &tr_scr->base;
  1545.  
  1546.    tr_ctx->base.destroy = trace_context_destroy;
  1547.  
  1548. #define TR_CTX_INIT(_member) \
  1549.    tr_ctx->base . _member = pipe -> _member ? trace_context_ ## _member : NULL
  1550.  
  1551.    TR_CTX_INIT(draw_vbo);
  1552.    TR_CTX_INIT(render_condition);
  1553.    TR_CTX_INIT(create_query);
  1554.    TR_CTX_INIT(destroy_query);
  1555.    TR_CTX_INIT(begin_query);
  1556.    TR_CTX_INIT(end_query);
  1557.    TR_CTX_INIT(get_query_result);
  1558.    TR_CTX_INIT(create_blend_state);
  1559.    TR_CTX_INIT(bind_blend_state);
  1560.    TR_CTX_INIT(delete_blend_state);
  1561.    TR_CTX_INIT(create_sampler_state);
  1562.    TR_CTX_INIT(bind_fragment_sampler_states);
  1563.    TR_CTX_INIT(bind_vertex_sampler_states);
  1564.    TR_CTX_INIT(bind_geometry_sampler_states);
  1565.    TR_CTX_INIT(delete_sampler_state);
  1566.    TR_CTX_INIT(create_rasterizer_state);
  1567.    TR_CTX_INIT(bind_rasterizer_state);
  1568.    TR_CTX_INIT(delete_rasterizer_state);
  1569.    TR_CTX_INIT(create_depth_stencil_alpha_state);
  1570.    TR_CTX_INIT(bind_depth_stencil_alpha_state);
  1571.    TR_CTX_INIT(delete_depth_stencil_alpha_state);
  1572.    TR_CTX_INIT(create_fs_state);
  1573.    TR_CTX_INIT(bind_fs_state);
  1574.    TR_CTX_INIT(delete_fs_state);
  1575.    TR_CTX_INIT(create_vs_state);
  1576.    TR_CTX_INIT(bind_vs_state);
  1577.    TR_CTX_INIT(delete_vs_state);
  1578.    TR_CTX_INIT(create_gs_state);
  1579.    TR_CTX_INIT(bind_gs_state);
  1580.    TR_CTX_INIT(delete_gs_state);
  1581.    TR_CTX_INIT(create_vertex_elements_state);
  1582.    TR_CTX_INIT(bind_vertex_elements_state);
  1583.    TR_CTX_INIT(delete_vertex_elements_state);
  1584.    TR_CTX_INIT(set_blend_color);
  1585.    TR_CTX_INIT(set_stencil_ref);
  1586.    TR_CTX_INIT(set_clip_state);
  1587.    TR_CTX_INIT(set_sample_mask);
  1588.    TR_CTX_INIT(set_constant_buffer);
  1589.    TR_CTX_INIT(set_framebuffer_state);
  1590.    TR_CTX_INIT(set_polygon_stipple);
  1591.    TR_CTX_INIT(set_scissor_states);
  1592.    TR_CTX_INIT(set_viewport_states);
  1593.    TR_CTX_INIT(set_fragment_sampler_views);
  1594.    TR_CTX_INIT(set_vertex_sampler_views);
  1595.    TR_CTX_INIT(set_geometry_sampler_views);
  1596.    TR_CTX_INIT(create_sampler_view);
  1597.    TR_CTX_INIT(sampler_view_destroy);
  1598.    TR_CTX_INIT(create_surface);
  1599.    TR_CTX_INIT(surface_destroy);
  1600.    TR_CTX_INIT(set_vertex_buffers);
  1601.    TR_CTX_INIT(set_index_buffer);
  1602.    TR_CTX_INIT(create_stream_output_target);
  1603.    TR_CTX_INIT(stream_output_target_destroy);
  1604.    TR_CTX_INIT(set_stream_output_targets);
  1605.    TR_CTX_INIT(resource_copy_region);
  1606.    TR_CTX_INIT(blit);
  1607.    TR_CTX_INIT(clear);
  1608.    TR_CTX_INIT(clear_render_target);
  1609.    TR_CTX_INIT(clear_depth_stencil);
  1610.    TR_CTX_INIT(flush);
  1611.    TR_CTX_INIT(texture_barrier);
  1612.  
  1613.    TR_CTX_INIT(transfer_map);
  1614.    TR_CTX_INIT(transfer_unmap);
  1615.    TR_CTX_INIT(transfer_flush_region);
  1616.    TR_CTX_INIT(transfer_inline_write);
  1617.  
  1618. #undef TR_CTX_INIT
  1619.  
  1620.    tr_ctx->pipe = pipe;
  1621.  
  1622.    return &tr_ctx->base;
  1623.  
  1624. error1:
  1625.    return pipe;
  1626. }
  1627.  
  1628.  
  1629. /**
  1630.  * Sanity checker: check that the given context really is a
  1631.  * trace context (and not the wrapped driver's context).
  1632.  */
  1633. void
  1634. trace_context_check(const struct pipe_context *pipe)
  1635. {
  1636.    struct trace_context *tr_ctx = (struct trace_context *) pipe;
  1637.    assert(tr_ctx->base.destroy == trace_context_destroy);
  1638. }
  1639.  
  1640.