gallium: Don't depend directly on staging dir in Xorg template makefile
[mesa.git] / src / gallium / state_trackers / python / p_context.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 %nodefaultctor st_context;
36 %nodefaultdtor st_context;
37
38 struct st_context {
39 };
40
41 %extend st_context {
42
43 ~st_context() {
44 st_context_destroy($self);
45 }
46
47 /*
48 * State functions (create/bind/destroy state objects)
49 */
50
51 void set_blend( const struct pipe_blend_state *state ) {
52 cso_set_blend($self->cso, state);
53 }
54
55 void set_fragment_sampler( unsigned index, const struct pipe_sampler_state *state ) {
56 cso_single_sampler($self->cso, index, state);
57 cso_single_sampler_done($self->cso);
58 }
59
60 void set_vertex_sampler( unsigned index, const struct pipe_sampler_state *state ) {
61 cso_single_vertex_sampler($self->cso, index, state);
62 cso_single_vertex_sampler_done($self->cso);
63 }
64
65 void set_rasterizer( const struct pipe_rasterizer_state *state ) {
66 cso_set_rasterizer($self->cso, state);
67 }
68
69 void set_depth_stencil_alpha(const struct pipe_depth_stencil_alpha_state *state) {
70 cso_set_depth_stencil_alpha($self->cso, state);
71 }
72
73 void set_fragment_shader( const struct pipe_shader_state *state ) {
74 void *fs;
75
76 if(!state) {
77 cso_set_fragment_shader_handle($self->cso, NULL);
78 return;
79 }
80
81 fs = $self->pipe->create_fs_state($self->pipe, state);
82 if(!fs)
83 return;
84
85 if(cso_set_fragment_shader_handle($self->cso, fs) != PIPE_OK)
86 return;
87
88 cso_delete_fragment_shader($self->cso, $self->fs);
89 $self->fs = fs;
90 }
91
92 void set_vertex_shader( const struct pipe_shader_state *state ) {
93 void *vs;
94
95 if(!state) {
96 cso_set_vertex_shader_handle($self->cso, NULL);
97 return;
98 }
99
100 vs = $self->pipe->create_vs_state($self->pipe, state);
101 if(!vs)
102 return;
103
104 if(cso_set_vertex_shader_handle($self->cso, vs) != PIPE_OK)
105 return;
106
107 cso_delete_vertex_shader($self->cso, $self->vs);
108 $self->vs = vs;
109 }
110
111 void set_geometry_shader( const struct pipe_shader_state *state ) {
112 void *gs;
113
114 if(!state) {
115 cso_set_geometry_shader_handle($self->cso, NULL);
116 return;
117 }
118
119 gs = $self->pipe->create_gs_state($self->pipe, state);
120 if(!gs)
121 return;
122
123 if(cso_set_geometry_shader_handle($self->cso, gs) != PIPE_OK)
124 return;
125
126 cso_delete_geometry_shader($self->cso, $self->gs);
127 $self->gs = gs;
128 }
129
130 struct pipe_sampler_view *
131 create_sampler_view(struct pipe_resource *texture,
132 enum pipe_format format = PIPE_FORMAT_NONE,
133 unsigned first_level = 0,
134 unsigned last_level = ~0,
135 unsigned swizzle_r = 0,
136 unsigned swizzle_g = 1,
137 unsigned swizzle_b = 2,
138 unsigned swizzle_a = 3)
139 {
140 struct pipe_context *pipe = $self->pipe;
141 struct pipe_sampler_view templat;
142
143 memset(&templat, 0, sizeof templat);
144 if (format == PIPE_FORMAT_NONE) {
145 templat.format = texture->format;
146 } else {
147 templat.format = format;
148 }
149 templat.last_level = MIN2(last_level, texture->last_level);
150 templat.first_level = first_level;
151 templat.last_level = last_level;
152 templat.swizzle_r = swizzle_r;
153 templat.swizzle_g = swizzle_g;
154 templat.swizzle_b = swizzle_b;
155 templat.swizzle_a = swizzle_a;
156
157 return pipe->create_sampler_view(pipe, texture, &templat);
158 }
159
160 void
161 sampler_view_destroy(struct pipe_context *ctx,
162 struct pipe_sampler_view *view)
163 {
164 struct pipe_context *pipe = $self->pipe;
165
166 pipe->sampler_view_destroy(pipe, view);
167 }
168
169 /*
170 * Parameter-like state (or properties)
171 */
172
173 void set_blend_color(const struct pipe_blend_color *state ) {
174 cso_set_blend_color($self->cso, state);
175 }
176
177 void set_stencil_ref(const struct pipe_stencil_ref *state ) {
178 cso_set_stencil_ref($self->cso, state);
179 }
180
181 void set_clip(const struct pipe_clip_state *state ) {
182 $self->pipe->set_clip_state($self->pipe, state);
183 }
184
185 void set_constant_buffer(unsigned shader, unsigned index,
186 struct pipe_resource *buffer )
187 {
188 $self->pipe->set_constant_buffer($self->pipe, shader, index, buffer);
189 }
190
191 void set_framebuffer(const struct pipe_framebuffer_state *state )
192 {
193 memcpy(&$self->framebuffer, state, sizeof *state);
194 cso_set_framebuffer($self->cso, state);
195 }
196
197 void set_polygon_stipple(const struct pipe_poly_stipple *state ) {
198 $self->pipe->set_polygon_stipple($self->pipe, state);
199 }
200
201 void set_scissor(const struct pipe_scissor_state *state ) {
202 $self->pipe->set_scissor_state($self->pipe, state);
203 }
204
205 void set_viewport(const struct pipe_viewport_state *state) {
206 cso_set_viewport($self->cso, state);
207 }
208
209 void set_fragment_sampler_view(unsigned index,
210 struct pipe_sampler_view *view)
211 {
212 pipe_sampler_view_reference(&$self->fragment_sampler_views[index], view);
213
214 $self->pipe->set_fragment_sampler_views($self->pipe,
215 PIPE_MAX_SAMPLERS,
216 $self->fragment_sampler_views);
217 }
218
219 void set_vertex_sampler_view(unsigned index,
220 struct pipe_sampler_view *view)
221 {
222 pipe_sampler_view_reference(&$self->vertex_sampler_views[index], view);
223
224 $self->pipe->set_vertex_sampler_views($self->pipe,
225 PIPE_MAX_VERTEX_SAMPLERS,
226 $self->vertex_sampler_views);
227 }
228
229 void set_fragment_sampler_texture(unsigned index,
230 struct pipe_resource *texture) {
231 struct pipe_sampler_view templ;
232
233 if(!texture)
234 texture = $self->default_texture;
235 pipe_sampler_view_reference(&$self->fragment_sampler_views[index], NULL);
236 u_sampler_view_default_template(&templ,
237 texture,
238 texture->format);
239 $self->fragment_sampler_views[index] = $self->pipe->create_sampler_view($self->pipe,
240 texture,
241 &templ);
242 $self->pipe->set_fragment_sampler_views($self->pipe,
243 PIPE_MAX_SAMPLERS,
244 $self->fragment_sampler_views);
245 }
246
247 void set_vertex_sampler_texture(unsigned index,
248 struct pipe_resource *texture) {
249 struct pipe_sampler_view templ;
250
251 if(!texture)
252 texture = $self->default_texture;
253 pipe_sampler_view_reference(&$self->vertex_sampler_views[index], NULL);
254 u_sampler_view_default_template(&templ,
255 texture,
256 texture->format);
257 $self->vertex_sampler_views[index] = $self->pipe->create_sampler_view($self->pipe,
258 texture,
259 &templ);
260
261 $self->pipe->set_vertex_sampler_views($self->pipe,
262 PIPE_MAX_VERTEX_SAMPLERS,
263 $self->vertex_sampler_views);
264 }
265
266 void set_vertex_buffer(unsigned index,
267 unsigned stride,
268 unsigned max_index,
269 unsigned buffer_offset,
270 struct pipe_resource *buffer)
271 {
272 unsigned i;
273 struct pipe_vertex_buffer state;
274
275 memset(&state, 0, sizeof(state));
276 state.stride = stride;
277 state.max_index = max_index;
278 state.buffer_offset = buffer_offset;
279 state.buffer = buffer;
280
281 memcpy(&$self->vertex_buffers[index], &state, sizeof(state));
282
283 for(i = 0; i < PIPE_MAX_ATTRIBS; ++i)
284 if(self->vertex_buffers[i].buffer)
285 $self->num_vertex_buffers = i + 1;
286
287 $self->pipe->set_vertex_buffers($self->pipe,
288 $self->num_vertex_buffers,
289 $self->vertex_buffers);
290 }
291
292 void set_vertex_element(unsigned index,
293 const struct pipe_vertex_element *element)
294 {
295 memcpy(&$self->vertex_elements[index], element, sizeof(*element));
296 }
297
298 void set_vertex_elements(unsigned num)
299 {
300 $self->num_vertex_elements = num;
301 cso_set_vertex_elements($self->cso,
302 $self->num_vertex_elements,
303 $self->vertex_elements);
304 }
305
306 /*
307 * Draw functions
308 */
309
310 void draw_arrays(unsigned mode, unsigned start, unsigned count) {
311 $self->pipe->draw_arrays($self->pipe, mode, start, count);
312 }
313
314 void draw_elements( struct pipe_resource *indexBuffer,
315 unsigned indexSize, int indexBias,
316 unsigned mode, unsigned start, unsigned count)
317 {
318 $self->pipe->draw_elements($self->pipe,
319 indexBuffer,
320 indexSize,
321 indexBias,
322 mode, start, count);
323 }
324
325 void draw_range_elements( struct pipe_resource *indexBuffer,
326 unsigned indexSize, int indexBias,
327 unsigned minIndex, unsigned maxIndex,
328 unsigned mode, unsigned start, unsigned count)
329 {
330 $self->pipe->draw_range_elements($self->pipe,
331 indexBuffer, indexSize, indexBias,
332 minIndex, maxIndex,
333 mode, start, count);
334 }
335
336 void draw_vertices(unsigned prim,
337 unsigned num_verts,
338 unsigned num_attribs,
339 const float *vertices)
340 {
341 struct pipe_context *pipe = $self->pipe;
342 struct pipe_screen *screen = pipe->screen;
343 struct pipe_resource *vbuf;
344 struct pipe_transfer *transfer;
345 struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
346 struct pipe_vertex_buffer vbuffer;
347 float *map;
348 unsigned size;
349 unsigned i;
350
351 size = num_verts * num_attribs * 4 * sizeof(float);
352
353 vbuf = pipe_buffer_create(screen,
354 PIPE_BIND_VERTEX_BUFFER,
355 size);
356 if(!vbuf)
357 goto error1;
358
359 map = pipe_buffer_map(pipe, vbuf, PIPE_TRANSFER_WRITE, &transfer);
360 if (!map)
361 goto error2;
362 memcpy(map, vertices, size);
363 pipe_buffer_unmap(pipe, vbuf, transfer);
364
365 cso_save_vertex_elements($self->cso);
366
367 /* tell pipe about the vertex attributes */
368 for (i = 0; i < num_attribs; i++) {
369 velements[i].src_offset = i * 4 * sizeof(float);
370 velements[i].instance_divisor = 0;
371 velements[i].vertex_buffer_index = 0;
372 velements[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
373 }
374 cso_set_vertex_elements($self->cso, num_attribs, velements);
375
376 /* tell pipe about the vertex buffer */
377 memset(&vbuffer, 0, sizeof(vbuffer));
378 vbuffer.buffer = vbuf;
379 vbuffer.stride = num_attribs * 4 * sizeof(float); /* vertex size */
380 vbuffer.buffer_offset = 0;
381 vbuffer.max_index = num_verts - 1;
382 pipe->set_vertex_buffers(pipe, 1, &vbuffer);
383
384 /* draw */
385 pipe->draw_arrays(pipe, prim, 0, num_verts);
386
387 cso_restore_vertex_elements($self->cso);
388
389 error2:
390 pipe_resource_reference(&vbuf, NULL);
391 error1:
392 ;
393 }
394
395 void
396 clear(unsigned buffers, const float *rgba, double depth = 0.0f,
397 unsigned stencil = 0)
398 {
399 $self->pipe->clear($self->pipe, buffers, rgba, depth, stencil);
400 }
401
402 void
403 flush(unsigned flags = 0) {
404 struct pipe_fence_handle *fence = NULL;
405 $self->pipe->flush($self->pipe, flags | PIPE_FLUSH_RENDER_CACHE, &fence);
406 if(fence) {
407 /* TODO: allow asynchronous operation */
408 $self->pipe->screen->fence_finish( $self->pipe->screen, fence, 0 );
409 $self->pipe->screen->fence_reference( $self->pipe->screen, &fence, NULL );
410 }
411 }
412
413 /*
414 * Surface functions
415 */
416
417 void resource_copy_region(struct pipe_resource *dst,
418 struct pipe_subresource subdst,
419 unsigned dstx, unsigned dsty, unsigned dstz,
420 struct pipe_resource *src,
421 struct pipe_subresource subsrc,
422 unsigned srcx, unsigned srcy, unsigned srcz,
423 unsigned width, unsigned height)
424 {
425 $self->pipe->resource_copy_region($self->pipe,
426 dst, subdst, dstx, dsty, dstz,
427 src, subsrc, srcx, srcy, srcz,
428 width, height);
429 }
430
431 void resource_fill_region(struct pipe_resource *dst,
432 struct pipe_subresource subdst,
433 unsigned dstx, unsigned dsty, unsigned dstz,
434 unsigned width, unsigned height,
435 unsigned value)
436 {
437 $self->pipe->resource_fill_region($self->pipe,
438 dst, subdst, dstx, dsty, dstz,
439 width, height, value);
440 }
441
442 %cstring_output_allocate_size(char **STRING, int *LENGTH, free(*$1));
443 void
444 surface_read_raw(struct st_surface *surface,
445 unsigned x, unsigned y, unsigned w, unsigned h,
446 char **STRING, int *LENGTH)
447 {
448 struct pipe_resource *texture = surface->texture;
449 struct pipe_context *pipe = $self->pipe;
450 struct pipe_transfer *transfer;
451 unsigned stride;
452
453 stride = util_format_get_stride(texture->format, w);
454 *LENGTH = util_format_get_nblocksy(texture->format, h) * stride;
455 *STRING = (char *) malloc(*LENGTH);
456 if(!*STRING)
457 return;
458
459 transfer = pipe_get_transfer(pipe,
460 surface->texture,
461 surface->face,
462 surface->level,
463 surface->zslice,
464 PIPE_TRANSFER_READ,
465 x, y, w, h);
466 if(transfer) {
467 pipe_get_tile_raw(pipe, transfer, 0, 0, w, h, *STRING, stride);
468 pipe->transfer_destroy(pipe, transfer);
469 }
470 }
471
472 %cstring_input_binary(const char *STRING, unsigned LENGTH);
473 void
474 surface_write_raw(struct st_surface *surface,
475 unsigned x, unsigned y, unsigned w, unsigned h,
476 const char *STRING, unsigned LENGTH, unsigned stride = 0)
477 {
478 struct pipe_resource *texture = surface->texture;
479 struct pipe_context *pipe = $self->pipe;
480 struct pipe_transfer *transfer;
481
482 if(stride == 0)
483 stride = util_format_get_stride(texture->format, w);
484
485 if(LENGTH < util_format_get_nblocksy(texture->format, h) * stride)
486 SWIG_exception(SWIG_ValueError, "offset must be smaller than buffer size");
487
488 transfer = pipe_get_transfer(pipe,
489 surface->texture,
490 surface->face,
491 surface->level,
492 surface->zslice,
493 PIPE_TRANSFER_WRITE,
494 x, y, w, h);
495 if(!transfer)
496 SWIG_exception(SWIG_MemoryError, "couldn't initiate transfer");
497
498 pipe_put_tile_raw(pipe, transfer, 0, 0, w, h, STRING, stride);
499 pipe->transfer_destroy(pipe, transfer);
500
501 fail:
502 return;
503 }
504
505 void
506 surface_read_rgba(struct st_surface *surface,
507 unsigned x, unsigned y, unsigned w, unsigned h,
508 float *rgba)
509 {
510 struct pipe_context *pipe = $self->pipe;
511 struct pipe_transfer *transfer;
512 transfer = pipe_get_transfer(pipe,
513 surface->texture,
514 surface->face,
515 surface->level,
516 surface->zslice,
517 PIPE_TRANSFER_READ,
518 x, y, w, h);
519 if(transfer) {
520 pipe_get_tile_rgba(pipe, transfer, 0, 0, w, h, rgba);
521 pipe->transfer_destroy(pipe, transfer);
522 }
523 }
524
525 void
526 surface_write_rgba(struct st_surface *surface,
527 unsigned x, unsigned y, unsigned w, unsigned h,
528 const float *rgba)
529 {
530 struct pipe_context *pipe = $self->pipe;
531 struct pipe_transfer *transfer;
532 transfer = pipe_get_transfer(pipe,
533 surface->texture,
534 surface->face,
535 surface->level,
536 surface->zslice,
537 PIPE_TRANSFER_WRITE,
538 x, y, w, h);
539 if(transfer) {
540 pipe_put_tile_rgba(pipe, transfer, 0, 0, w, h, rgba);
541 pipe->transfer_destroy(pipe, transfer);
542 }
543 }
544
545 %cstring_output_allocate_size(char **STRING, int *LENGTH, free(*$1));
546 void
547 surface_read_rgba8(struct st_surface *surface,
548 unsigned x, unsigned y, unsigned w, unsigned h,
549 char **STRING, int *LENGTH)
550 {
551 struct pipe_context *pipe = $self->pipe;
552 struct pipe_transfer *transfer;
553 float *rgba;
554 unsigned char *rgba8;
555 unsigned i, j, k;
556
557 *LENGTH = 0;
558 *STRING = NULL;
559
560 if (!surface)
561 return;
562
563 *LENGTH = h*w*4;
564 *STRING = (char *) malloc(*LENGTH);
565 if(!*STRING)
566 return;
567
568 rgba = malloc(h*w*4*sizeof(float));
569 if(!rgba)
570 return;
571
572 rgba8 = (unsigned char *) *STRING;
573
574 transfer = pipe_get_transfer(pipe,
575 surface->texture,
576 surface->face,
577 surface->level,
578 surface->zslice,
579 PIPE_TRANSFER_READ,
580 x, y, w, h);
581 if(transfer) {
582 pipe_get_tile_rgba(pipe, transfer, 0, 0, w, h, rgba);
583 for(j = 0; j < h; ++j) {
584 for(i = 0; i < w; ++i)
585 for(k = 0; k <4; ++k)
586 rgba8[j*w*4 + i*4 + k] = float_to_ubyte(rgba[j*w*4 + i*4 + k]);
587 }
588 pipe->transfer_destroy(pipe, transfer);
589 }
590
591 free(rgba);
592 }
593
594 void
595 surface_read_z(struct st_surface *surface,
596 unsigned x, unsigned y, unsigned w, unsigned h,
597 unsigned *z)
598 {
599 struct pipe_context *pipe = $self->pipe;
600 struct pipe_transfer *transfer;
601 transfer = pipe_get_transfer(pipe,
602 surface->texture,
603 surface->face,
604 surface->level,
605 surface->zslice,
606 PIPE_TRANSFER_READ,
607 x, y, w, h);
608 if(transfer) {
609 pipe_get_tile_z(pipe, transfer, 0, 0, w, h, z);
610 pipe->transfer_destroy(pipe, transfer);
611 }
612 }
613
614 void
615 surface_write_z(struct st_surface *surface,
616 unsigned x, unsigned y, unsigned w, unsigned h,
617 const unsigned *z)
618 {
619 struct pipe_context *pipe = $self->pipe;
620 struct pipe_transfer *transfer;
621 transfer = pipe_get_transfer(pipe,
622 surface->texture,
623 surface->face,
624 surface->level,
625 surface->zslice,
626 PIPE_TRANSFER_WRITE,
627 x, y, w, h);
628 if(transfer) {
629 pipe_put_tile_z(pipe, transfer, 0, 0, w, h, z);
630 pipe->transfer_destroy(pipe, transfer);
631 }
632 }
633
634 void
635 surface_sample_rgba(struct st_surface *surface,
636 float *rgba,
637 int norm = 0)
638 {
639 st_sample_surface($self->pipe, surface, rgba, norm != 0);
640 }
641
642 unsigned
643 surface_compare_rgba(struct st_surface *surface,
644 unsigned x, unsigned y, unsigned w, unsigned h,
645 const float *rgba, float tol = 0.0)
646 {
647 struct pipe_context *pipe = $self->pipe;
648 struct pipe_transfer *transfer;
649 float *rgba2;
650 const float *p1;
651 const float *p2;
652 unsigned i, j, n;
653
654 rgba2 = MALLOC(h*w*4*sizeof(float));
655 if(!rgba2)
656 return ~0;
657
658 transfer = pipe_get_transfer(pipe,
659 surface->texture,
660 surface->face,
661 surface->level,
662 surface->zslice,
663 PIPE_TRANSFER_READ,
664 x, y, w, h);
665 if(!transfer) {
666 FREE(rgba2);
667 return ~0;
668 }
669
670 pipe_get_tile_rgba(pipe, transfer, 0, 0, w, h, rgba2);
671 pipe->transfer_destroy(pipe, transfer);
672
673 p1 = rgba;
674 p2 = rgba2;
675 n = 0;
676 for(i = h*w; i; --i) {
677 unsigned differs = 0;
678 for(j = 4; j; --j) {
679 float delta = *p2++ - *p1++;
680 if (delta < -tol || delta > tol)
681 differs = 1;
682 }
683 n += differs;
684 }
685
686 FREE(rgba2);
687
688 return n;
689 }
690
691 %cstring_input_binary(const char *STRING, unsigned LENGTH);
692 void
693 transfer_inline_write(struct pipe_resource *resource,
694 struct pipe_subresource *sr,
695 unsigned usage,
696 const struct pipe_box *box,
697 const char *STRING, unsigned LENGTH,
698 unsigned stride,
699 unsigned slice_stride)
700 {
701 struct pipe_context *pipe = $self->pipe;
702
703 pipe->transfer_inline_write(pipe, resource, *sr, usage, box, STRING, stride, slice_stride);
704 }
705
706 %cstring_output_allocate_size(char **STRING, int *LENGTH, free(*$1));
707 void buffer_read(struct pipe_resource *buffer,
708 char **STRING, int *LENGTH)
709 {
710 struct pipe_context *pipe = $self->pipe;
711
712 assert(buffer->target == PIPE_BUFFER);
713
714 *LENGTH = buffer->width0;
715 *STRING = (char *) malloc(buffer->width0);
716 if(!*STRING)
717 return;
718
719 pipe_buffer_read(pipe, buffer, 0, buffer->width0, *STRING);
720 }
721
722 void buffer_write(struct pipe_resource *buffer,
723 const char *STRING, unsigned LENGTH, unsigned offset = 0)
724 {
725 struct pipe_context *pipe = $self->pipe;
726
727 assert(buffer->target == PIPE_BUFFER);
728
729 if(offset > buffer->width0)
730 SWIG_exception(SWIG_ValueError, "offset must be smaller than buffer size");
731
732 if(offset + LENGTH > buffer->width0)
733 SWIG_exception(SWIG_ValueError, "data length must fit inside the buffer");
734
735 pipe_buffer_write(pipe, buffer, offset, LENGTH, STRING);
736
737 fail:
738 return;
739 }
740
741 };