src/gallium/state_trackers/python/p_texture.i

   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 /**
  29  * @file
  30  * SWIG interface definion for Gallium types.
  31  *
  32  * @author Jose Fonseca <jrfonseca@tungstengraphics.com>
  33  */
  34
  35
  36 %nodefaultctor pipe_texture;
  37 %nodefaultctor pipe_surface;
  38 %nodefaultctor pipe_buffer;
  39
  40 %nodefaultdtor pipe_texture;
  41 %nodefaultdtor pipe_surface;
  42 %nodefaultdtor pipe_buffer;
  43
  44 %ignore pipe_texture::screen;
  45
  46 %ignore pipe_surface::winsys;
  47 %immutable pipe_surface::texture;
  48 %immutable pipe_surface::buffer;
  49
  50 %newobject pipe_texture::get_surface;
  51
  52
  53 %extend pipe_texture {
  54
  55    ~pipe_texture() {
  56       struct pipe_texture *ptr = $self;
  57       pipe_texture_reference(&ptr, NULL);
  58    }
  59
  60    unsigned get_width(unsigned level=0) {
  61       return $self->width[level];
  62    }
  63
  64    unsigned get_height(unsigned level=0) {
  65       return $self->height[level];
  66    }
  67
  68    unsigned get_depth(unsigned level=0) {
  69       return $self->depth[level];
  70    }
  71
  72    unsigned get_nblocksx(unsigned level=0) {
  73       return $self->nblocksx[level];
  74    }
  75
  76    unsigned get_nblocksy(unsigned level=0) {
  77       return $self->nblocksy[level];
  78    }
  79
  80    /** Get a surface which is a "view" into a texture */
  81    struct pipe_surface *
  82    get_surface(unsigned face=0, unsigned level=0, unsigned zslice=0, unsigned usage=0 )
  83    {
  84       struct pipe_screen *screen = $self->screen;
  85       return screen->get_tex_surface(screen, $self, face, level, zslice, usage);
  86    }
  87
  88 };
  89
  90
  91 %extend pipe_surface {
  92
  93    ~pipe_surface() {
  94       struct pipe_surface *ptr = $self;
  95       pipe_surface_reference(&ptr, NULL);
  96    }
  97
  98    void
  99    get_tile_raw(unsigned x, unsigned y, unsigned w, unsigned h, char *raw, unsigned stride)
 100    {
 101       struct pipe_screen *screen = $self->texture->screen;
 102       struct pipe_transfer *transfer;
 103       transfer = screen->get_tex_transfer(screen,
 104                                           $self->texture,
 105                                           $self->face,
 106                                           $self->level,
 107                                           $self->zslice,
 108                                           PIPE_TRANSFER_READ,
 109                                           x, y, w, h);
 110       if(transfer) {
 111          pipe_get_tile_raw(transfer, 0, 0, w, h, raw, stride);
 112          screen->tex_transfer_destroy(transfer);
 113       }
 114    }
 115
 116    void
 117    put_tile_raw(unsigned x, unsigned y, unsigned w, unsigned h, const char *raw, unsigned stride)
 118    {
 119       struct pipe_screen *screen = $self->texture->screen;
 120       struct pipe_transfer *transfer;
 121       transfer = screen->get_tex_transfer(screen,
 122                                           $self->texture,
 123                                           $self->face,
 124                                           $self->level,
 125                                           $self->zslice,
 126                                           PIPE_TRANSFER_WRITE,
 127                                           x, y, w, h);
 128       if(transfer) {
 129          pipe_put_tile_raw(transfer, 0, 0, w, h, raw, stride);
 130          screen->tex_transfer_destroy(transfer);
 131       }
 132    }
 133
 134    void
 135    get_tile_rgba(unsigned x, unsigned y, unsigned w, unsigned h, float *rgba)
 136    {
 137       struct pipe_screen *screen = $self->texture->screen;
 138       struct pipe_transfer *transfer;
 139       transfer = screen->get_tex_transfer(screen,
 140                                           $self->texture,
 141                                           $self->face,
 142                                           $self->level,
 143                                           $self->zslice,
 144                                           PIPE_TRANSFER_READ,
 145                                           x, y, w, h);
 146       if(transfer) {
 147          pipe_get_tile_rgba(transfer, 0, 0, w, h, rgba);
 148          screen->tex_transfer_destroy(transfer);
 149       }
 150    }
 151
 152    void
 153    put_tile_rgba(unsigned x, unsigned y, unsigned w, unsigned h, const float *rgba)
 154    {
 155       struct pipe_screen *screen = $self->texture->screen;
 156       struct pipe_transfer *transfer;
 157       transfer = screen->get_tex_transfer(screen,
 158                                           $self->texture,
 159                                           $self->face,
 160                                           $self->level,
 161                                           $self->zslice,
 162                                           PIPE_TRANSFER_WRITE,
 163                                           x, y, w, h);
 164       if(transfer) {
 165          pipe_put_tile_rgba(transfer, 0, 0, w, h, rgba);
 166          screen->tex_transfer_destroy(transfer);
 167       }
 168    }
 169
 170    %cstring_output_allocate_size(char **STRING, int *LENGTH, free(*$1));
 171    void
 172    get_tile_rgba8(unsigned x, unsigned y, unsigned w, unsigned h, char **STRING, int *LENGTH)
 173    {
 174       struct pipe_screen *screen = $self->texture->screen;
 175       struct pipe_transfer *transfer;
 176       float *rgba;
 177       unsigned char *rgba8;
 178       unsigned i, j, k;
 179
 180       *LENGTH = 0;
 181       *STRING = NULL;
 182
 183       if (!$self)
 184          return;
 185
 186       *LENGTH = h*w*4;
 187       *STRING = (char *) malloc(*LENGTH);
 188       if(!*STRING)
 189          return;
 190
 191       rgba = malloc(w*4*sizeof(float));
 192       if(!rgba)
 193          return;
 194
 195       rgba8 = (unsigned char *) *STRING;
 196
 197       for(j = 0; j < h; ++j) {
 198          transfer = screen->get_tex_transfer(screen,
 199                                              $self->texture,
 200                                              $self->face,
 201                                              $self->level,
 202                                              $self->zslice,
 203                                              PIPE_TRANSFER_READ,
 204                                              x, y + j,
 205                                              w,
 206                                              1);
 207          if(transfer) {
 208             pipe_get_tile_rgba(transfer,
 209                                0, 0, w, 1,
 210                                rgba);
 211             for(i = 0; i < w; ++i)
 212                for(k = 0; k <4; ++k)
 213                   rgba8[j*w*4 + i*4 + k] = float_to_ubyte(rgba[i*4 + k]);
 214             screen->tex_transfer_destroy(transfer);
 215          }
 216       }
 217
 218       free(rgba);
 219    }
 220
 221    void
 222    get_tile_z(unsigned x, unsigned y, unsigned w, unsigned h, unsigned *z)
 223    {
 224       struct pipe_screen *screen = $self->texture->screen;
 225       struct pipe_transfer *transfer;
 226       transfer = screen->get_tex_transfer(screen,
 227                                           $self->texture,
 228                                           $self->face,
 229                                           $self->level,
 230                                           $self->zslice,
 231                                           PIPE_TRANSFER_READ,
 232                                           x, y, w, h);
 233       if(transfer) {
 234          pipe_get_tile_z(transfer, 0, 0, w, h, z);
 235          screen->tex_transfer_destroy(transfer);
 236       }
 237    }
 238
 239    void
 240    put_tile_z(unsigned x, unsigned y, unsigned w, unsigned h, const unsigned *z)
 241    {
 242       struct pipe_screen *screen = $self->texture->screen;
 243       struct pipe_transfer *transfer;
 244       transfer = screen->get_tex_transfer(screen,
 245                                           $self->texture,
 246                                           $self->face,
 247                                           $self->level,
 248                                           $self->zslice,
 249                                           PIPE_TRANSFER_WRITE,
 250                                           x, y, w, h);
 251       if(transfer) {
 252          pipe_put_tile_z(transfer, 0, 0, w, h, z);
 253          screen->tex_transfer_destroy(transfer);
 254       }
 255    }
 256
 257    void
 258    sample_rgba(float *rgba) {
 259       st_sample_surface($self, rgba);
 260    }
 261
 262    unsigned
 263    compare_tile_rgba(unsigned x, unsigned y, unsigned w, unsigned h, const float *rgba, float tol = 0.0)
 264    {
 265       struct pipe_screen *screen = $self->texture->screen;
 266       struct pipe_transfer *transfer;
 267       float *rgba2;
 268       const float *p1;
 269       const float *p2;
 270       unsigned i, j, n;
 271
 272       rgba2 = MALLOC(h*w*4*sizeof(float));
 273       if(!rgba2)
 274          return ~0;
 275
 276       transfer = screen->get_tex_transfer(screen,
 277                                           $self->texture,
 278                                           $self->face,
 279                                           $self->level,
 280                                           $self->zslice,
 281                                           PIPE_TRANSFER_WRITE,
 282                                           x, y, w, h);
 283       if(!transfer) {
 284          FREE(rgba2);
 285          return ~0;
 286       }
 287
 288       pipe_get_tile_rgba(transfer, 0, 0, w, h, rgba2);
 289       screen->tex_transfer_destroy(transfer);
 290
 291       p1 = rgba;
 292       p2 = rgba2;
 293       n = 0;
 294       for(i = h*w; i; --i) {
 295          unsigned differs = 0;
 296          for(j = 4; j; --j) {
 297             float delta = *p2++ - *p1++;
 298             if (delta < -tol || delta > tol)
 299                 differs = 1;
 300          }
 301          n += differs;
 302       }
 303
 304       FREE(rgba2);
 305
 306       return n;
 307    }
 308
 309 };
 310
 311 /* Avoid naming conflict with p_inlines.h's pipe_buffer_read/write */
 312 %rename(read) pipe_buffer_read_;
 313 %rename(write) pipe_buffer_write_;
 314
 315 %extend pipe_buffer {
 316
 317    ~pipe_buffer() {
 318       struct pipe_buffer *ptr = $self;
 319       pipe_buffer_reference(&ptr, NULL);
 320    }
 321
 322    unsigned __len__(void)
 323    {
 324       assert(p_atomic_read(&$self->reference.count) > 0);
 325       return $self->size;
 326    }
 327
 328    %cstring_output_allocate_size(char **STRING, int *LENGTH, free(*$1));
 329    void read_(char **STRING, int *LENGTH)
 330    {
 331       struct pipe_screen *screen = $self->screen;
 332
 333       assert(p_atomic_read(&$self->reference.count) > 0);
 334
 335       *LENGTH = $self->size;
 336       *STRING = (char *) malloc($self->size);
 337       if(!*STRING)
 338          return;
 339
 340       pipe_buffer_read(screen, $self, 0, $self->size, STRING);
 341    }
 342
 343    %cstring_input_binary(const char *STRING, unsigned LENGTH);
 344    void write_(const char *STRING, unsigned LENGTH, unsigned offset = 0)
 345    {
 346       struct pipe_screen *screen = $self->screen;
 347
 348       assert(p_atomic_read(&$self->reference.count) > 0);
 349
 350       if(offset > $self->size) {
 351          PyErr_SetString(PyExc_ValueError, "offset must be smaller than buffer size");
 352          return;
 353       }
 354
 355       if(offset + LENGTH > $self->size) {
 356          PyErr_SetString(PyExc_ValueError, "data length must fit inside the buffer");
 357          return;
 358       }
 359
 360       pipe_buffer_write(screen, $self, offset, LENGTH, STRING);
 361    }
 362 };