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_format.h"
  29. #include "util/u_memory.h"
  30. #include "util/simple_list.h"
  31.  
  32. #include "tr_dump.h"
  33. #include "tr_dump_defines.h"
  34. #include "tr_dump_state.h"
  35. #include "tr_texture.h"
  36. #include "tr_context.h"
  37. #include "tr_screen.h"
  38. #include "tr_public.h"
  39.  
  40.  
  41. static boolean trace = FALSE;
  42.  
  43. static const char *
  44. trace_screen_get_name(struct pipe_screen *_screen)
  45. {
  46.    struct trace_screen *tr_scr = trace_screen(_screen);
  47.    struct pipe_screen *screen = tr_scr->screen;
  48.    const char *result;
  49.  
  50.    trace_dump_call_begin("pipe_screen", "get_name");
  51.  
  52.    trace_dump_arg(ptr, screen);
  53.  
  54.    result = screen->get_name(screen);
  55.  
  56.    trace_dump_ret(string, result);
  57.  
  58.    trace_dump_call_end();
  59.  
  60.    return result;
  61. }
  62.  
  63.  
  64. static const char *
  65. trace_screen_get_vendor(struct pipe_screen *_screen)
  66. {
  67.    struct trace_screen *tr_scr = trace_screen(_screen);
  68.    struct pipe_screen *screen = tr_scr->screen;
  69.    const char *result;
  70.  
  71.    trace_dump_call_begin("pipe_screen", "get_vendor");
  72.  
  73.    trace_dump_arg(ptr, screen);
  74.  
  75.    result = screen->get_vendor(screen);
  76.  
  77.    trace_dump_ret(string, result);
  78.  
  79.    trace_dump_call_end();
  80.  
  81.    return result;
  82. }
  83.  
  84.  
  85. static const char *
  86. trace_screen_get_device_vendor(struct pipe_screen *_screen)
  87. {
  88.    struct trace_screen *tr_scr = trace_screen(_screen);
  89.    struct pipe_screen *screen = tr_scr->screen;
  90.    const char *result;
  91.  
  92.    trace_dump_call_begin("pipe_screen", "get_device_vendor");
  93.  
  94.    trace_dump_arg(ptr, screen);
  95.  
  96.    result = screen->get_device_vendor(screen);
  97.  
  98.    trace_dump_ret(string, result);
  99.  
  100.    trace_dump_call_end();
  101.  
  102.    return result;
  103. }
  104.  
  105.  
  106. static int
  107. trace_screen_get_param(struct pipe_screen *_screen,
  108.                        enum pipe_cap param)
  109. {
  110.    struct trace_screen *tr_scr = trace_screen(_screen);
  111.    struct pipe_screen *screen = tr_scr->screen;
  112.    int result;
  113.  
  114.    trace_dump_call_begin("pipe_screen", "get_param");
  115.  
  116.    trace_dump_arg(ptr, screen);
  117.    trace_dump_arg(int, param);
  118.  
  119.    result = screen->get_param(screen, param);
  120.  
  121.    trace_dump_ret(int, result);
  122.  
  123.    trace_dump_call_end();
  124.  
  125.    return result;
  126. }
  127.  
  128.  
  129. static int
  130. trace_screen_get_shader_param(struct pipe_screen *_screen, unsigned shader,
  131.                        enum pipe_shader_cap param)
  132. {
  133.    struct trace_screen *tr_scr = trace_screen(_screen);
  134.    struct pipe_screen *screen = tr_scr->screen;
  135.    int result;
  136.  
  137.    trace_dump_call_begin("pipe_screen", "get_shader_param");
  138.  
  139.    trace_dump_arg(ptr, screen);
  140.    trace_dump_arg(uint, shader);
  141.    trace_dump_arg(int, param);
  142.  
  143.    result = screen->get_shader_param(screen, shader, param);
  144.  
  145.    trace_dump_ret(int, result);
  146.  
  147.    trace_dump_call_end();
  148.  
  149.    return result;
  150. }
  151.  
  152.  
  153. static float
  154. trace_screen_get_paramf(struct pipe_screen *_screen,
  155.                         enum pipe_capf param)
  156. {
  157.    struct trace_screen *tr_scr = trace_screen(_screen);
  158.    struct pipe_screen *screen = tr_scr->screen;
  159.    float result;
  160.  
  161.    trace_dump_call_begin("pipe_screen", "get_paramf");
  162.  
  163.    trace_dump_arg(ptr, screen);
  164.    trace_dump_arg(int, param);
  165.  
  166.    result = screen->get_paramf(screen, param);
  167.  
  168.    trace_dump_ret(float, result);
  169.  
  170.    trace_dump_call_end();
  171.  
  172.    return result;
  173. }
  174.  
  175.  
  176. static boolean
  177. trace_screen_is_format_supported(struct pipe_screen *_screen,
  178.                                  enum pipe_format format,
  179.                                  enum pipe_texture_target target,
  180.                                  unsigned sample_count,
  181.                                  unsigned tex_usage)
  182. {
  183.    struct trace_screen *tr_scr = trace_screen(_screen);
  184.    struct pipe_screen *screen = tr_scr->screen;
  185.    boolean result;
  186.  
  187.    trace_dump_call_begin("pipe_screen", "is_format_supported");
  188.  
  189.    trace_dump_arg(ptr, screen);
  190.    trace_dump_arg(format, format);
  191.    trace_dump_arg(int, target);
  192.    trace_dump_arg(uint, sample_count);
  193.    trace_dump_arg(uint, tex_usage);
  194.  
  195.    result = screen->is_format_supported(screen, format, target, sample_count,
  196.                                         tex_usage);
  197.  
  198.    trace_dump_ret(bool, result);
  199.  
  200.    trace_dump_call_end();
  201.  
  202.    return result;
  203. }
  204.  
  205.  
  206. static struct pipe_context *
  207. trace_screen_context_create(struct pipe_screen *_screen, void *priv)
  208. {
  209.    struct trace_screen *tr_scr = trace_screen(_screen);
  210.    struct pipe_screen *screen = tr_scr->screen;
  211.    struct pipe_context *result;
  212.  
  213.    trace_dump_call_begin("pipe_screen", "context_create");
  214.  
  215.    trace_dump_arg(ptr, screen);
  216.  
  217.    result = screen->context_create(screen, priv);
  218.  
  219.    trace_dump_ret(ptr, result);
  220.  
  221.    trace_dump_call_end();
  222.  
  223.    result = trace_context_create(tr_scr, result);
  224.  
  225.    return result;
  226. }
  227.  
  228.  
  229. static void
  230. trace_screen_flush_frontbuffer(struct pipe_screen *_screen,
  231.                                struct pipe_resource *_resource,
  232.                                unsigned level, unsigned layer,
  233.                                void *context_private,
  234.                                struct pipe_box *sub_box)
  235. {
  236.    struct trace_screen *tr_scr = trace_screen(_screen);
  237.    struct trace_resource *tr_res = trace_resource(_resource);
  238.    struct pipe_screen *screen = tr_scr->screen;
  239.    struct pipe_resource *resource = tr_res->resource;
  240.  
  241.    trace_dump_call_begin("pipe_screen", "flush_frontbuffer");
  242.  
  243.    trace_dump_arg(ptr, screen);
  244.    trace_dump_arg(ptr, resource);
  245.    trace_dump_arg(uint, level);
  246.    trace_dump_arg(uint, layer);
  247.    /* XXX: hide, as there is nothing we can do with this
  248.    trace_dump_arg(ptr, context_private);
  249.    */
  250.  
  251.    screen->flush_frontbuffer(screen, resource, level, layer, context_private, sub_box);
  252.  
  253.    trace_dump_call_end();
  254. }
  255.  
  256.  
  257. /********************************************************************
  258.  * texture
  259.  */
  260.  
  261.  
  262. static struct pipe_resource *
  263. trace_screen_resource_create(struct pipe_screen *_screen,
  264.                             const struct pipe_resource *templat)
  265. {
  266.    struct trace_screen *tr_scr = trace_screen(_screen);
  267.    struct pipe_screen *screen = tr_scr->screen;
  268.    struct pipe_resource *result;
  269.  
  270.    trace_dump_call_begin("pipe_screen", "resource_create");
  271.  
  272.    trace_dump_arg(ptr, screen);
  273.    trace_dump_arg(resource_template, templat);
  274.  
  275.    result = screen->resource_create(screen, templat);
  276.  
  277.    trace_dump_ret(ptr, result);
  278.  
  279.    trace_dump_call_end();
  280.  
  281.    result = trace_resource_create(tr_scr, result);
  282.  
  283.    return result;
  284. }
  285.  
  286. static struct pipe_resource *
  287. trace_screen_resource_from_handle(struct pipe_screen *_screen,
  288.                                  const struct pipe_resource *templ,
  289.                                  struct winsys_handle *handle)
  290. {
  291.    struct trace_screen *tr_screen = trace_screen(_screen);
  292.    struct pipe_screen *screen = tr_screen->screen;
  293.    struct pipe_resource *result;
  294.  
  295.    /* TODO trace call */
  296.  
  297.    result = screen->resource_from_handle(screen, templ, handle);
  298.  
  299.    result = trace_resource_create(trace_screen(_screen), result);
  300.  
  301.    return result;
  302. }
  303.  
  304. static boolean
  305. trace_screen_resource_get_handle(struct pipe_screen *_screen,
  306.                                 struct pipe_resource *_resource,
  307.                                 struct winsys_handle *handle)
  308. {
  309.    struct trace_screen *tr_screen = trace_screen(_screen);
  310.    struct trace_resource *tr_resource = trace_resource(_resource);
  311.    struct pipe_screen *screen = tr_screen->screen;
  312.    struct pipe_resource *resource = tr_resource->resource;
  313.  
  314.    /* TODO trace call */
  315.  
  316.    return screen->resource_get_handle(screen, resource, handle);
  317. }
  318.  
  319.  
  320.  
  321. static void
  322. trace_screen_resource_destroy(struct pipe_screen *_screen,
  323.                               struct pipe_resource *_resource)
  324. {
  325.    struct trace_screen *tr_scr = trace_screen(_screen);
  326.    struct trace_resource *tr_res = trace_resource(_resource);
  327.    struct pipe_screen *screen = tr_scr->screen;
  328.    struct pipe_resource *resource = tr_res->resource;
  329.  
  330.    assert(resource->screen == screen);
  331.  
  332.    trace_dump_call_begin("pipe_screen", "resource_destroy");
  333.  
  334.    trace_dump_arg(ptr, screen);
  335.    trace_dump_arg(ptr, resource);
  336.  
  337.    trace_dump_call_end();
  338.  
  339.    trace_resource_destroy(tr_scr, tr_res);
  340. }
  341.  
  342.  
  343. /********************************************************************
  344.  * fence
  345.  */
  346.  
  347.  
  348. static void
  349. trace_screen_fence_reference(struct pipe_screen *_screen,
  350.                              struct pipe_fence_handle **pdst,
  351.                              struct pipe_fence_handle *src)
  352. {
  353.    struct trace_screen *tr_scr = trace_screen(_screen);
  354.    struct pipe_screen *screen = tr_scr->screen;
  355.    struct pipe_fence_handle *dst;
  356.  
  357.    assert(pdst);
  358.    dst = *pdst;
  359.    
  360.    trace_dump_call_begin("pipe_screen", "fence_reference");
  361.  
  362.    trace_dump_arg(ptr, screen);
  363.    trace_dump_arg(ptr, dst);
  364.    trace_dump_arg(ptr, src);
  365.  
  366.    screen->fence_reference(screen, pdst, src);
  367.  
  368.    trace_dump_call_end();
  369. }
  370.  
  371.  
  372. static boolean
  373. trace_screen_fence_signalled(struct pipe_screen *_screen,
  374.                              struct pipe_fence_handle *fence)
  375. {
  376.    struct trace_screen *tr_scr = trace_screen(_screen);
  377.    struct pipe_screen *screen = tr_scr->screen;
  378.    int result;
  379.  
  380.    trace_dump_call_begin("pipe_screen", "fence_signalled");
  381.  
  382.    trace_dump_arg(ptr, screen);
  383.    trace_dump_arg(ptr, fence);
  384.  
  385.    result = screen->fence_signalled(screen, fence);
  386.  
  387.    trace_dump_ret(bool, result);
  388.  
  389.    trace_dump_call_end();
  390.  
  391.    return result;
  392. }
  393.  
  394.  
  395. static boolean
  396. trace_screen_fence_finish(struct pipe_screen *_screen,
  397.                           struct pipe_fence_handle *fence,
  398.                           uint64_t timeout)
  399. {
  400.    struct trace_screen *tr_scr = trace_screen(_screen);
  401.    struct pipe_screen *screen = tr_scr->screen;
  402.    int result;
  403.  
  404.    trace_dump_call_begin("pipe_screen", "fence_finish");
  405.  
  406.    trace_dump_arg(ptr, screen);
  407.    trace_dump_arg(ptr, fence);
  408.    trace_dump_arg(uint, timeout);
  409.  
  410.    result = screen->fence_finish(screen, fence, timeout);
  411.  
  412.    trace_dump_ret(bool, result);
  413.  
  414.    trace_dump_call_end();
  415.  
  416.    return result;
  417. }
  418.  
  419.  
  420. /********************************************************************
  421.  * screen
  422.  */
  423.  
  424. static uint64_t
  425. trace_screen_get_timestamp(struct pipe_screen *_screen)
  426. {
  427.    struct trace_screen *tr_scr = trace_screen(_screen);
  428.    struct pipe_screen *screen = tr_scr->screen;
  429.    uint64_t result;
  430.  
  431.    trace_dump_call_begin("pipe_screen", "get_timestamp");
  432.    trace_dump_arg(ptr, screen);
  433.  
  434.    result = screen->get_timestamp(screen);
  435.  
  436.    trace_dump_ret(uint, result);
  437.    trace_dump_call_end();
  438.  
  439.    return result;
  440. }
  441.  
  442. static void
  443. trace_screen_destroy(struct pipe_screen *_screen)
  444. {
  445.    struct trace_screen *tr_scr = trace_screen(_screen);
  446.    struct pipe_screen *screen = tr_scr->screen;
  447.  
  448.    trace_dump_call_begin("pipe_screen", "destroy");
  449.    trace_dump_arg(ptr, screen);
  450.    trace_dump_call_end();
  451.  
  452.    screen->destroy(screen);
  453.  
  454.    FREE(tr_scr);
  455. }
  456.  
  457. boolean
  458. trace_enabled(void)
  459. {
  460.    static boolean firstrun = TRUE;
  461.  
  462.    if (!firstrun)
  463.       return trace;
  464.    firstrun = FALSE;
  465.  
  466.    if(trace_dump_trace_begin()) {
  467.       trace_dumping_start();
  468.       trace = TRUE;
  469.    }
  470.  
  471.    return trace;
  472. }
  473.  
  474. struct pipe_screen *
  475. trace_screen_create(struct pipe_screen *screen)
  476. {
  477.    struct trace_screen *tr_scr;
  478.  
  479.    if(!screen)
  480.       goto error1;
  481.  
  482.    if (!trace_enabled())
  483.       goto error1;
  484.  
  485.    trace_dump_call_begin("", "pipe_screen_create");
  486.  
  487.    tr_scr = CALLOC_STRUCT(trace_screen);
  488.    if(!tr_scr)
  489.       goto error2;
  490.  
  491.    tr_scr->base.destroy = trace_screen_destroy;
  492.    tr_scr->base.get_name = trace_screen_get_name;
  493.    tr_scr->base.get_vendor = trace_screen_get_vendor;
  494.    tr_scr->base.get_device_vendor = trace_screen_get_device_vendor;
  495.    tr_scr->base.get_param = trace_screen_get_param;
  496.    tr_scr->base.get_shader_param = trace_screen_get_shader_param;
  497.    tr_scr->base.get_paramf = trace_screen_get_paramf;
  498.    tr_scr->base.is_format_supported = trace_screen_is_format_supported;
  499.    assert(screen->context_create);
  500.    tr_scr->base.context_create = trace_screen_context_create;
  501.    tr_scr->base.resource_create = trace_screen_resource_create;
  502.    tr_scr->base.resource_from_handle = trace_screen_resource_from_handle;
  503.    tr_scr->base.resource_get_handle = trace_screen_resource_get_handle;
  504.    tr_scr->base.resource_destroy = trace_screen_resource_destroy;
  505.    tr_scr->base.fence_reference = trace_screen_fence_reference;
  506.    tr_scr->base.fence_signalled = trace_screen_fence_signalled;
  507.    tr_scr->base.fence_finish = trace_screen_fence_finish;
  508.    tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer;
  509.    tr_scr->base.get_timestamp = trace_screen_get_timestamp;
  510.  
  511.    tr_scr->screen = screen;
  512.  
  513.    trace_dump_ret(ptr, screen);
  514.    trace_dump_call_end();
  515.  
  516.    return &tr_scr->base;
  517.  
  518. error2:
  519.    trace_dump_ret(ptr, screen);
  520.    trace_dump_call_end();
  521. error1:
  522.    return screen;
  523. }
  524.  
  525.  
  526. struct trace_screen *
  527. trace_screen(struct pipe_screen *screen)
  528. {
  529.    assert(screen);
  530.    assert(screen->destroy == trace_screen_destroy);
  531.    return (struct trace_screen *)screen;
  532. }
  533.