Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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