Subversion Repositories Kolibri OS

Rev

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

  1. /**************************************************************************
  2.  *
  3.  * Copyright 2010 Thomas Balling Sørensen.
  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 <vdpau/vdpau.h>
  29.  
  30. #include "util/u_memory.h"
  31. #include "util/u_sampler.h"
  32.  
  33. #include "vdpau_private.h"
  34.  
  35. /**
  36.  * Create a VdpBitmapSurface.
  37.  */
  38. VdpStatus
  39. vlVdpBitmapSurfaceCreate(VdpDevice device,
  40.                          VdpRGBAFormat rgba_format,
  41.                          uint32_t width, uint32_t height,
  42.                          VdpBool frequently_accessed,
  43.                          VdpBitmapSurface *surface)
  44. {
  45.    struct pipe_context *pipe;
  46.    struct pipe_resource res_tmpl, *res;
  47.    struct pipe_sampler_view sv_templ;
  48.  
  49.    vlVdpBitmapSurface *vlsurface = NULL;
  50.  
  51.    if (!(width && height))
  52.       return VDP_STATUS_INVALID_SIZE;
  53.  
  54.    vlVdpDevice *dev = vlGetDataHTAB(device);
  55.    if (!dev)
  56.       return VDP_STATUS_INVALID_HANDLE;
  57.  
  58.    pipe = dev->context;
  59.    if (!pipe)
  60.       return VDP_STATUS_INVALID_HANDLE;
  61.  
  62.    if (!surface)
  63.       return VDP_STATUS_INVALID_POINTER;
  64.  
  65.    vlsurface = CALLOC(1, sizeof(vlVdpBitmapSurface));
  66.    if (!vlsurface)
  67.       return VDP_STATUS_RESOURCES;
  68.  
  69.    vlsurface->device = dev;
  70.  
  71.    memset(&res_tmpl, 0, sizeof(res_tmpl));
  72.    res_tmpl.target = PIPE_TEXTURE_2D;
  73.    res_tmpl.format = FormatRGBAToPipe(rgba_format);
  74.    res_tmpl.width0 = width;
  75.    res_tmpl.height0 = height;
  76.    res_tmpl.depth0 = 1;
  77.    res_tmpl.array_size = 1;
  78.    res_tmpl.bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
  79.    res_tmpl.usage = frequently_accessed ? PIPE_USAGE_DYNAMIC : PIPE_USAGE_STATIC;
  80.  
  81.    pipe_mutex_lock(dev->mutex);
  82.    res = pipe->screen->resource_create(pipe->screen, &res_tmpl);
  83.    if (!res) {
  84.       pipe_mutex_unlock(dev->mutex);
  85.       FREE(dev);
  86.       FREE(vlsurface);
  87.       return VDP_STATUS_RESOURCES;
  88.    }
  89.  
  90.    vlVdpDefaultSamplerViewTemplate(&sv_templ, res);
  91.    vlsurface->sampler_view = pipe->create_sampler_view(pipe, res, &sv_templ);
  92.  
  93.    pipe_resource_reference(&res, NULL);
  94.    pipe_mutex_unlock(dev->mutex);
  95.  
  96.    if (!vlsurface->sampler_view) {
  97.       FREE(dev);
  98.       return VDP_STATUS_RESOURCES;
  99.    }
  100.  
  101.    *surface = vlAddDataHTAB(vlsurface);
  102.    if (*surface == 0) {
  103.       FREE(dev);
  104.       return VDP_STATUS_ERROR;
  105.    }
  106.  
  107.    return VDP_STATUS_OK;
  108. }
  109.  
  110. /**
  111.  * Destroy a VdpBitmapSurface.
  112.  */
  113. VdpStatus
  114. vlVdpBitmapSurfaceDestroy(VdpBitmapSurface surface)
  115. {
  116.    vlVdpBitmapSurface *vlsurface;
  117.  
  118.    vlsurface = vlGetDataHTAB(surface);
  119.    if (!vlsurface)
  120.       return VDP_STATUS_INVALID_HANDLE;
  121.  
  122.    pipe_mutex_lock(vlsurface->device->mutex);
  123.    pipe_sampler_view_reference(&vlsurface->sampler_view, NULL);
  124.    pipe_mutex_unlock(vlsurface->device->mutex);
  125.  
  126.    vlRemoveDataHTAB(surface);
  127.    FREE(vlsurface);
  128.  
  129.    return VDP_STATUS_OK;
  130. }
  131.  
  132. /**
  133.  * Retrieve the parameters used to create a VdpBitmapSurface.
  134.  */
  135. VdpStatus
  136. vlVdpBitmapSurfaceGetParameters(VdpBitmapSurface surface,
  137.                                 VdpRGBAFormat *rgba_format,
  138.                                 uint32_t *width, uint32_t *height,
  139.                                 VdpBool *frequently_accessed)
  140. {
  141.    vlVdpBitmapSurface *vlsurface;
  142.    struct pipe_resource *res;
  143.  
  144.    vlsurface = vlGetDataHTAB(surface);
  145.    if (!vlsurface)
  146.       return VDP_STATUS_INVALID_HANDLE;
  147.  
  148.    if (!(rgba_format && width && height && frequently_accessed))
  149.       return VDP_STATUS_INVALID_POINTER;
  150.  
  151.    res = vlsurface->sampler_view->texture;
  152.    *rgba_format = PipeToFormatRGBA(res->format);
  153.    *width = res->width0;
  154.    *height = res->height0;
  155.    *frequently_accessed = res->usage == PIPE_USAGE_DYNAMIC;
  156.  
  157.    return VDP_STATUS_OK;
  158. }
  159.  
  160. /**
  161.  * Copy image data from application memory in the surface's native format to
  162.  * a VdpBitmapSurface.
  163.  */
  164. VdpStatus
  165. vlVdpBitmapSurfacePutBitsNative(VdpBitmapSurface surface,
  166.                                 void const *const *source_data,
  167.                                 uint32_t const *source_pitches,
  168.                                 VdpRect const *destination_rect)
  169. {
  170.    vlVdpBitmapSurface *vlsurface;
  171.    struct pipe_box dst_box;
  172.    struct pipe_context *pipe;
  173.  
  174.    vlsurface = vlGetDataHTAB(surface);
  175.    if (!vlsurface)
  176.       return VDP_STATUS_INVALID_HANDLE;
  177.  
  178.    if (!(source_data && source_pitches))
  179.       return VDP_STATUS_INVALID_POINTER;
  180.  
  181.    pipe = vlsurface->device->context;
  182.  
  183.    pipe_mutex_lock(vlsurface->device->mutex);
  184.  
  185.    vlVdpResolveDelayedRendering(vlsurface->device, NULL, NULL);
  186.  
  187.    dst_box = RectToPipeBox(destination_rect, vlsurface->sampler_view->texture);
  188.    pipe->transfer_inline_write(pipe, vlsurface->sampler_view->texture, 0,
  189.                                PIPE_TRANSFER_WRITE, &dst_box, *source_data,
  190.                                *source_pitches, 0);
  191.  
  192.    pipe_mutex_unlock(vlsurface->device->mutex);
  193.  
  194.    return VDP_STATUS_OK;
  195. }
  196.