1 /**************************************************************************
3 * Copyright 2009 VMware, Inc. All Rights Reserved.
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sub license, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial portions
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
20 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
21 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
22 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
23 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 **************************************************************************/
27 #include "VG/openvg.h"
29 #include "vg_context.h"
34 #include "api_consts.h"
36 #include "pipe/p_compiler.h"
37 #include "util/u_pointer.h"
38 #include "util/u_math.h"
42 static INLINE
struct vg_state
*current_state()
44 struct vg_context
*ctx
= vg_current_context();
48 return &ctx
->state
.vg
;
51 static INLINE VGboolean
count_in_bounds(VGParamType type
, VGint count
)
56 if (type
== VG_SCISSOR_RECTS
)
57 return (!(count
% 4) && (count
>= 0 || count
<= VEGA_MAX_SCISSOR_RECTS
* 4));
58 else if (type
== VG_STROKE_DASH_PATTERN
) {
59 return count
<= VEGA_MAX_DASH_COUNT
;
61 VGint real_count
= vgGetVectorSize(type
);
62 return count
== real_count
;
66 void vgSetf (VGParamType type
, VGfloat value
)
68 struct vg_context
*ctx
= vg_current_context();
69 struct vg_state
*state
= current_state();
70 VGErrorCode error
= VG_NO_ERROR
;
75 case VG_IMAGE_QUALITY
:
76 case VG_RENDERING_QUALITY
:
79 #ifdef OPENVG_VERSION_1_1
80 case VG_COLOR_TRANSFORM
:
82 case VG_STROKE_CAP_STYLE
:
83 case VG_STROKE_JOIN_STYLE
:
84 case VG_STROKE_DASH_PHASE_RESET
:
88 case VG_SCREEN_LAYOUT
:
89 case VG_FILTER_FORMAT_LINEAR
:
90 case VG_FILTER_FORMAT_PREMULTIPLIED
:
91 case VG_FILTER_CHANNEL_MASK
:
93 case VG_MAX_SCISSOR_RECTS
:
94 case VG_MAX_DASH_COUNT
:
95 case VG_MAX_KERNEL_SIZE
:
96 case VG_MAX_SEPARABLE_KERNEL_SIZE
:
97 case VG_MAX_COLOR_RAMP_STOPS
:
98 case VG_MAX_IMAGE_WIDTH
:
99 case VG_MAX_IMAGE_HEIGHT
:
100 case VG_MAX_IMAGE_PIXELS
:
101 case VG_MAX_IMAGE_BYTES
:
102 case VG_MAX_GAUSSIAN_STD_DEVIATION
:
104 vgSeti(type
, floor(value
));
107 case VG_STROKE_LINE_WIDTH
:
108 state
->stroke
.line_width
.f
= value
;
109 state
->stroke
.line_width
.i
= float_to_int_floor(*((VGuint
*)(&value
)));
111 case VG_STROKE_MITER_LIMIT
:
112 state
->stroke
.miter_limit
.f
= value
;
113 state
->stroke
.miter_limit
.i
= float_to_int_floor(*((VGuint
*)(&value
)));
115 case VG_STROKE_DASH_PHASE
:
116 state
->stroke
.dash_phase
.f
= value
;
117 state
->stroke
.dash_phase
.i
= float_to_int_floor(*((VGuint
*)(&value
)));
120 error
= VG_ILLEGAL_ARGUMENT_ERROR
;
123 vg_set_error(ctx
, error
);
126 void vgSeti (VGParamType type
, VGint value
)
128 struct vg_context
*ctx
= vg_current_context();
129 struct vg_state
*state
= current_state();
130 VGErrorCode error
= VG_NO_ERROR
;
134 if (value
< VG_MATRIX_PATH_USER_TO_SURFACE
||
135 #ifdef OPENVG_VERSION_1_1
136 value
> VG_MATRIX_GLYPH_USER_TO_SURFACE
)
138 value
> VG_MATRIX_STROKE_PAINT_TO_USER
)
140 error
= VG_ILLEGAL_ARGUMENT_ERROR
;
142 state
->matrix_mode
= value
;
145 if (value
< VG_EVEN_ODD
||
147 error
= VG_ILLEGAL_ARGUMENT_ERROR
;
149 state
->fill_rule
= value
;
151 case VG_IMAGE_QUALITY
:
152 state
->image_quality
= value
;
154 case VG_RENDERING_QUALITY
:
155 if (value
< VG_RENDERING_QUALITY_NONANTIALIASED
||
156 value
> VG_RENDERING_QUALITY_BETTER
)
157 error
= VG_ILLEGAL_ARGUMENT_ERROR
;
159 state
->rendering_quality
= value
;
162 if (value
< VG_BLEND_SRC
||
163 value
> VG_BLEND_ADDITIVE
)
164 error
= VG_ILLEGAL_ARGUMENT_ERROR
;
166 ctx
->state
.dirty
|= BLEND_DIRTY
;
167 state
->blend_mode
= value
;
171 if (value
< VG_DRAW_IMAGE_NORMAL
||
172 value
> VG_DRAW_IMAGE_STENCIL
)
173 error
= VG_ILLEGAL_ARGUMENT_ERROR
;
175 state
->image_mode
= value
;
176 #ifdef OPENVG_VERSION_1_1
177 case VG_COLOR_TRANSFORM
:
178 state
->color_transform
= value
;
181 case VG_STROKE_LINE_WIDTH
:
182 state
->stroke
.line_width
.f
= value
;
183 state
->stroke
.line_width
.i
= value
;
185 case VG_STROKE_CAP_STYLE
:
186 if (value
< VG_CAP_BUTT
||
187 value
> VG_CAP_SQUARE
)
188 error
= VG_ILLEGAL_ARGUMENT_ERROR
;
190 state
->stroke
.cap_style
= value
;
192 case VG_STROKE_JOIN_STYLE
:
193 if (value
< VG_JOIN_MITER
||
194 value
> VG_JOIN_BEVEL
)
195 error
= VG_ILLEGAL_ARGUMENT_ERROR
;
197 state
->stroke
.join_style
= value
;
199 case VG_STROKE_MITER_LIMIT
:
200 state
->stroke
.miter_limit
.f
= value
;
201 state
->stroke
.miter_limit
.i
= value
;
203 case VG_STROKE_DASH_PHASE
:
204 state
->stroke
.dash_phase
.f
= value
;
205 state
->stroke
.dash_phase
.i
= value
;
207 case VG_STROKE_DASH_PHASE_RESET
:
208 state
->stroke
.dash_phase_reset
= value
;
211 state
->masking
= value
;
214 state
->scissoring
= value
;
215 ctx
->state
.dirty
|= DEPTH_STENCIL_DIRTY
;
217 case VG_PIXEL_LAYOUT
:
218 if (value
< VG_PIXEL_LAYOUT_UNKNOWN
||
219 value
> VG_PIXEL_LAYOUT_BGR_HORIZONTAL
)
220 error
= VG_ILLEGAL_ARGUMENT_ERROR
;
222 state
->pixel_layout
= value
;
224 case VG_SCREEN_LAYOUT
:
225 /* read only ignore */
227 case VG_FILTER_FORMAT_LINEAR
:
228 state
->filter_format_linear
= value
;
230 case VG_FILTER_FORMAT_PREMULTIPLIED
:
231 state
->filter_format_premultiplied
= value
;
233 case VG_FILTER_CHANNEL_MASK
:
234 state
->filter_channel_mask
= value
;
237 case VG_MAX_SCISSOR_RECTS
:
238 case VG_MAX_DASH_COUNT
:
239 case VG_MAX_KERNEL_SIZE
:
240 case VG_MAX_SEPARABLE_KERNEL_SIZE
:
241 case VG_MAX_COLOR_RAMP_STOPS
:
242 case VG_MAX_IMAGE_WIDTH
:
243 case VG_MAX_IMAGE_HEIGHT
:
244 case VG_MAX_IMAGE_PIXELS
:
245 case VG_MAX_IMAGE_BYTES
:
246 case VG_MAX_GAUSSIAN_STD_DEVIATION
:
248 /* read only ignore */
251 error
= VG_ILLEGAL_ARGUMENT_ERROR
;
254 vg_set_error(ctx
, error
);
257 void vgSetfv(VGParamType type
, VGint count
,
258 const VGfloat
* values
)
260 struct vg_context
*ctx
= vg_current_context();
261 struct vg_state
*state
= current_state();
262 VGErrorCode error
= VG_NO_ERROR
;
264 if ((count
&& !values
) || !count_in_bounds(type
, count
) || !is_aligned(values
)) {
265 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
272 case VG_IMAGE_QUALITY
:
273 case VG_RENDERING_QUALITY
:
276 #ifdef OPENVG_VERSION_1_1
277 case VG_COLOR_TRANSFORM
:
279 case VG_STROKE_CAP_STYLE
:
280 case VG_STROKE_JOIN_STYLE
:
281 case VG_STROKE_DASH_PHASE_RESET
:
284 case VG_PIXEL_LAYOUT
:
285 case VG_SCREEN_LAYOUT
:
286 case VG_FILTER_FORMAT_LINEAR
:
287 case VG_FILTER_FORMAT_PREMULTIPLIED
:
288 case VG_FILTER_CHANNEL_MASK
:
289 vgSeti(type
, floor(values
[0]));
292 case VG_SCISSOR_RECTS
: {
294 VGuint
*x
= (VGuint
*)values
;
295 for (i
= 0; i
< count
; ++i
) {
296 state
->scissor_rects
[i
].f
= values
[i
];
297 state
->scissor_rects
[i
].i
= float_to_int_floor(x
[i
]);
299 state
->scissor_rects_num
= count
/ 4;
300 ctx
->state
.dirty
|= DEPTH_STENCIL_DIRTY
;
303 #ifdef OPENVG_VERSION_1_1
304 case VG_COLOR_TRANSFORM_VALUES
: {
306 for (i
= 0; i
< count
; ++i
) {
307 state
->color_transform_values
[i
] = values
[i
];
312 case VG_STROKE_LINE_WIDTH
:
313 state
->stroke
.line_width
.f
= values
[0];
314 state
->stroke
.line_width
.i
= float_to_int_floor(*((VGuint
*)(values
)));
316 case VG_STROKE_MITER_LIMIT
:
317 state
->stroke
.miter_limit
.f
= values
[0];
318 state
->stroke
.miter_limit
.i
= float_to_int_floor(*((VGuint
*)(values
)));
320 case VG_STROKE_DASH_PATTERN
: {
322 for (i
= 0; i
< count
; ++i
) {
323 state
->stroke
.dash_pattern
[i
].f
= values
[i
];
324 state
->stroke
.dash_pattern
[i
].i
=
325 float_to_int_floor(*((VGuint
*)(values
+ i
)));
327 state
->stroke
.dash_pattern_num
= count
;
330 case VG_STROKE_DASH_PHASE
:
331 state
->stroke
.dash_phase
.f
= values
[0];
332 state
->stroke
.dash_phase
.i
= float_to_int_floor(*((VGuint
*)(values
)));
334 case VG_TILE_FILL_COLOR
:
335 state
->tile_fill_color
[0] = values
[0];
336 state
->tile_fill_color
[1] = values
[1];
337 state
->tile_fill_color
[2] = values
[2];
338 state
->tile_fill_color
[3] = values
[3];
340 state
->tile_fill_colori
[0] = float_to_int_floor(*((VGuint
*)(values
+ 0)));
341 state
->tile_fill_colori
[1] = float_to_int_floor(*((VGuint
*)(values
+ 1)));
342 state
->tile_fill_colori
[2] = float_to_int_floor(*((VGuint
*)(values
+ 2)));
343 state
->tile_fill_colori
[3] = float_to_int_floor(*((VGuint
*)(values
+ 3)));
346 state
->clear_color
[0] = values
[0];
347 state
->clear_color
[1] = values
[1];
348 state
->clear_color
[2] = values
[2];
349 state
->clear_color
[3] = values
[3];
351 state
->clear_colori
[0] = float_to_int_floor(*((VGuint
*)(values
+ 0)));
352 state
->clear_colori
[1] = float_to_int_floor(*((VGuint
*)(values
+ 1)));
353 state
->clear_colori
[2] = float_to_int_floor(*((VGuint
*)(values
+ 2)));
354 state
->clear_colori
[3] = float_to_int_floor(*((VGuint
*)(values
+ 3)));
356 #ifdef OPENVG_VERSION_1_1
357 case VG_GLYPH_ORIGIN
:
358 state
->glyph_origin
[0].f
= values
[0];
359 state
->glyph_origin
[1].f
= values
[1];
361 state
->glyph_origin
[0].i
= float_to_int_floor(*((VGuint
*)(values
+ 0)));
362 state
->glyph_origin
[1].i
= float_to_int_floor(*((VGuint
*)(values
+ 1)));
366 case VG_MAX_SCISSOR_RECTS
:
367 case VG_MAX_DASH_COUNT
:
368 case VG_MAX_KERNEL_SIZE
:
369 case VG_MAX_SEPARABLE_KERNEL_SIZE
:
370 case VG_MAX_COLOR_RAMP_STOPS
:
371 case VG_MAX_IMAGE_WIDTH
:
372 case VG_MAX_IMAGE_HEIGHT
:
373 case VG_MAX_IMAGE_PIXELS
:
374 case VG_MAX_IMAGE_BYTES
:
375 case VG_MAX_GAUSSIAN_STD_DEVIATION
:
379 error
= VG_ILLEGAL_ARGUMENT_ERROR
;
382 vg_set_error(ctx
, error
);
385 void vgSetiv(VGParamType type
, VGint count
,
386 const VGint
* values
)
388 struct vg_context
*ctx
= vg_current_context();
389 struct vg_state
*state
= current_state();
391 if ((count
&& !values
) || !count_in_bounds(type
, count
) || !is_aligned(values
)) {
392 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
399 case VG_IMAGE_QUALITY
:
400 case VG_RENDERING_QUALITY
:
403 #ifdef OPENVG_VERSION_1_1
404 case VG_COLOR_TRANSFORM
:
406 case VG_STROKE_CAP_STYLE
:
407 case VG_STROKE_JOIN_STYLE
:
408 case VG_STROKE_DASH_PHASE_RESET
:
411 case VG_PIXEL_LAYOUT
:
412 case VG_SCREEN_LAYOUT
:
413 case VG_FILTER_FORMAT_LINEAR
:
414 case VG_FILTER_FORMAT_PREMULTIPLIED
:
415 case VG_FILTER_CHANNEL_MASK
:
416 vgSeti(type
, values
[0]);
419 case VG_SCISSOR_RECTS
: {
421 for (i
= 0; i
< count
; ++i
) {
422 state
->scissor_rects
[i
].i
= values
[i
];
423 state
->scissor_rects
[i
].f
= values
[i
];
425 state
->scissor_rects_num
= count
/ 4;
426 ctx
->state
.dirty
|= DEPTH_STENCIL_DIRTY
;
429 #ifdef OPENVG_VERSION_1_1
430 case VG_COLOR_TRANSFORM_VALUES
: {
432 for (i
= 0; i
< count
; ++i
) {
433 state
->color_transform_values
[i
] = values
[i
];
438 case VG_STROKE_LINE_WIDTH
:
439 state
->stroke
.line_width
.f
= values
[0];
440 state
->stroke
.line_width
.i
= values
[0];
442 case VG_STROKE_MITER_LIMIT
:
443 state
->stroke
.miter_limit
.f
= values
[0];
444 state
->stroke
.miter_limit
.i
= values
[0];
446 case VG_STROKE_DASH_PATTERN
: {
448 for (i
= 0; i
< count
; ++i
) {
449 state
->stroke
.dash_pattern
[i
].f
= values
[i
];
450 state
->stroke
.dash_pattern
[i
].i
= values
[i
];
452 state
->stroke
.dash_pattern_num
= count
;
455 case VG_STROKE_DASH_PHASE
:
456 state
->stroke
.dash_phase
.f
= values
[0];
457 state
->stroke
.dash_phase
.i
= values
[0];
459 case VG_TILE_FILL_COLOR
:
460 state
->tile_fill_color
[0] = values
[0];
461 state
->tile_fill_color
[1] = values
[1];
462 state
->tile_fill_color
[2] = values
[2];
463 state
->tile_fill_color
[3] = values
[3];
465 state
->tile_fill_colori
[0] = values
[0];
466 state
->tile_fill_colori
[1] = values
[1];
467 state
->tile_fill_colori
[2] = values
[2];
468 state
->tile_fill_colori
[3] = values
[3];
471 state
->clear_color
[0] = values
[0];
472 state
->clear_color
[1] = values
[1];
473 state
->clear_color
[2] = values
[2];
474 state
->clear_color
[3] = values
[3];
476 state
->clear_colori
[0] = values
[0];
477 state
->clear_colori
[1] = values
[1];
478 state
->clear_colori
[2] = values
[2];
479 state
->clear_colori
[3] = values
[3];
481 #ifdef OPENVG_VERSION_1_1
482 case VG_GLYPH_ORIGIN
:
483 state
->glyph_origin
[0].f
= values
[0];
484 state
->glyph_origin
[1].f
= values
[1];
485 state
->glyph_origin
[0].i
= values
[0];
486 state
->glyph_origin
[1].i
= values
[1];
490 case VG_MAX_SCISSOR_RECTS
:
491 case VG_MAX_DASH_COUNT
:
492 case VG_MAX_KERNEL_SIZE
:
493 case VG_MAX_SEPARABLE_KERNEL_SIZE
:
494 case VG_MAX_COLOR_RAMP_STOPS
:
495 case VG_MAX_IMAGE_WIDTH
:
496 case VG_MAX_IMAGE_HEIGHT
:
497 case VG_MAX_IMAGE_PIXELS
:
498 case VG_MAX_IMAGE_BYTES
:
499 case VG_MAX_GAUSSIAN_STD_DEVIATION
:
504 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
509 VGfloat
vgGetf(VGParamType type
)
511 struct vg_context
*ctx
= vg_current_context();
512 const struct vg_state
*state
= current_state();
513 VGErrorCode error
= VG_NO_ERROR
;
514 VGfloat value
= 0.0f
;
519 case VG_IMAGE_QUALITY
:
520 case VG_RENDERING_QUALITY
:
523 #ifdef OPENVG_VERSION_1_1
524 case VG_COLOR_TRANSFORM
:
526 case VG_STROKE_CAP_STYLE
:
527 case VG_STROKE_JOIN_STYLE
:
528 case VG_STROKE_DASH_PHASE_RESET
:
531 case VG_PIXEL_LAYOUT
:
532 case VG_SCREEN_LAYOUT
:
533 case VG_FILTER_FORMAT_LINEAR
:
534 case VG_FILTER_FORMAT_PREMULTIPLIED
:
535 case VG_FILTER_CHANNEL_MASK
:
538 case VG_STROKE_LINE_WIDTH
:
539 value
= state
->stroke
.line_width
.f
;
541 case VG_STROKE_MITER_LIMIT
:
542 value
= state
->stroke
.miter_limit
.f
;
544 case VG_STROKE_DASH_PHASE
:
545 value
= state
->stroke
.dash_phase
.f
;
548 case VG_MAX_SCISSOR_RECTS
:
549 case VG_MAX_DASH_COUNT
:
550 case VG_MAX_KERNEL_SIZE
:
551 case VG_MAX_SEPARABLE_KERNEL_SIZE
:
552 case VG_MAX_COLOR_RAMP_STOPS
:
553 case VG_MAX_IMAGE_WIDTH
:
554 case VG_MAX_IMAGE_HEIGHT
:
555 case VG_MAX_IMAGE_PIXELS
:
556 case VG_MAX_IMAGE_BYTES
:
557 case VG_MAX_GAUSSIAN_STD_DEVIATION
:
561 value
= 1e+10;/*must be at least 1e+10*/
564 error
= VG_ILLEGAL_ARGUMENT_ERROR
;
567 vg_set_error(ctx
, error
);
571 VGint
vgGeti(VGParamType type
)
573 const struct vg_state
*state
= current_state();
574 struct vg_context
*ctx
= vg_current_context();
575 VGErrorCode error
= VG_NO_ERROR
;
580 value
= state
->matrix_mode
;
583 value
= state
->fill_rule
;
585 case VG_IMAGE_QUALITY
:
586 value
= state
->image_quality
;
588 case VG_RENDERING_QUALITY
:
589 value
= state
->rendering_quality
;
592 value
= state
->blend_mode
;
595 value
= state
->image_mode
;
597 #ifdef OPENVG_VERSION_1_1
598 case VG_COLOR_TRANSFORM
:
599 value
= state
->color_transform
;
602 case VG_STROKE_LINE_WIDTH
:
603 value
= state
->stroke
.line_width
.i
;
605 case VG_STROKE_CAP_STYLE
:
606 value
= state
->stroke
.cap_style
;
608 case VG_STROKE_JOIN_STYLE
:
609 value
= state
->stroke
.join_style
;
611 case VG_STROKE_MITER_LIMIT
:
612 value
= state
->stroke
.miter_limit
.i
;
614 case VG_STROKE_DASH_PHASE
:
615 value
= state
->stroke
.dash_phase
.i
;
617 case VG_STROKE_DASH_PHASE_RESET
:
618 value
= state
->stroke
.dash_phase_reset
;
621 value
= state
->masking
;
624 value
= state
->scissoring
;
626 case VG_PIXEL_LAYOUT
:
627 value
= state
->pixel_layout
;
629 case VG_SCREEN_LAYOUT
:
630 value
= state
->screen_layout
;
632 case VG_FILTER_FORMAT_LINEAR
:
633 value
= state
->filter_format_linear
;
635 case VG_FILTER_FORMAT_PREMULTIPLIED
:
636 value
= state
->filter_format_premultiplied
;
638 case VG_FILTER_CHANNEL_MASK
:
639 value
= state
->filter_channel_mask
;
642 case VG_MAX_SCISSOR_RECTS
:
643 value
= 32; /*must be at least 32*/
645 case VG_MAX_DASH_COUNT
:
646 value
= 16; /*must be at least 16*/
648 case VG_MAX_KERNEL_SIZE
:
649 value
= 7; /*must be at least 7*/
651 case VG_MAX_SEPARABLE_KERNEL_SIZE
:
652 value
= 15; /*must be at least 15*/
654 case VG_MAX_COLOR_RAMP_STOPS
:
655 value
= 256; /*must be at least 32*/
657 case VG_MAX_IMAGE_WIDTH
:
660 case VG_MAX_IMAGE_HEIGHT
:
663 case VG_MAX_IMAGE_PIXELS
:
666 case VG_MAX_IMAGE_BYTES
:
667 value
= 2048*2048 * 4;
669 case VG_MAX_GAUSSIAN_STD_DEVIATION
:
670 value
= 128; /*must be at least 128*/
674 VGfloat val
= vgGetf(type
);
675 value
= float_to_int_floor(*((VGuint
*)&val
));
679 error
= VG_ILLEGAL_ARGUMENT_ERROR
;
682 vg_set_error(ctx
, error
);
686 VGint
vgGetVectorSize(VGParamType type
)
688 struct vg_context
*ctx
= vg_current_context();
689 const struct vg_state
*state
= current_state();
693 case VG_IMAGE_QUALITY
:
694 case VG_RENDERING_QUALITY
:
698 case VG_SCISSOR_RECTS
:
699 return state
->scissor_rects_num
* 4;
700 #ifdef OPENVG_VERSION_1_1
701 case VG_COLOR_TRANSFORM
:
703 case VG_COLOR_TRANSFORM_VALUES
:
706 case VG_STROKE_LINE_WIDTH
:
707 case VG_STROKE_CAP_STYLE
:
708 case VG_STROKE_JOIN_STYLE
:
709 case VG_STROKE_MITER_LIMIT
:
711 case VG_STROKE_DASH_PATTERN
:
712 return state
->stroke
.dash_pattern_num
;
713 case VG_STROKE_DASH_PHASE
:
715 case VG_STROKE_DASH_PHASE_RESET
:
717 case VG_TILE_FILL_COLOR
:
721 #ifdef OPENVG_VERSION_1_1
722 case VG_GLYPH_ORIGIN
:
729 case VG_PIXEL_LAYOUT
:
731 case VG_SCREEN_LAYOUT
:
733 case VG_FILTER_FORMAT_LINEAR
:
735 case VG_FILTER_FORMAT_PREMULTIPLIED
:
737 case VG_FILTER_CHANNEL_MASK
:
740 case VG_MAX_COLOR_RAMP_STOPS
:
742 case VG_MAX_SCISSOR_RECTS
:
743 case VG_MAX_DASH_COUNT
:
744 case VG_MAX_KERNEL_SIZE
:
745 case VG_MAX_SEPARABLE_KERNEL_SIZE
:
746 case VG_MAX_IMAGE_WIDTH
:
747 case VG_MAX_IMAGE_HEIGHT
:
748 case VG_MAX_IMAGE_PIXELS
:
749 case VG_MAX_IMAGE_BYTES
:
751 case VG_MAX_GAUSSIAN_STD_DEVIATION
:
755 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
760 void vgGetfv(VGParamType type
, VGint count
,
763 const struct vg_state
*state
= current_state();
764 struct vg_context
*ctx
= vg_current_context();
765 VGint real_count
= vgGetVectorSize(type
);
767 if (!values
|| count
<= 0 || count
> real_count
|| !is_aligned(values
)) {
768 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
775 case VG_IMAGE_QUALITY
:
776 case VG_RENDERING_QUALITY
:
779 #ifdef OPENVG_VERSION_1_1
780 case VG_COLOR_TRANSFORM
:
782 case VG_STROKE_CAP_STYLE
:
783 case VG_STROKE_JOIN_STYLE
:
784 case VG_STROKE_DASH_PHASE_RESET
:
787 case VG_PIXEL_LAYOUT
:
788 case VG_SCREEN_LAYOUT
:
789 case VG_FILTER_FORMAT_LINEAR
:
790 case VG_FILTER_FORMAT_PREMULTIPLIED
:
791 case VG_FILTER_CHANNEL_MASK
:
792 case VG_MAX_SCISSOR_RECTS
:
793 case VG_MAX_DASH_COUNT
:
794 case VG_MAX_KERNEL_SIZE
:
795 case VG_MAX_SEPARABLE_KERNEL_SIZE
:
796 case VG_MAX_COLOR_RAMP_STOPS
:
797 case VG_MAX_IMAGE_WIDTH
:
798 case VG_MAX_IMAGE_HEIGHT
:
799 case VG_MAX_IMAGE_PIXELS
:
800 case VG_MAX_IMAGE_BYTES
:
801 case VG_MAX_GAUSSIAN_STD_DEVIATION
:
802 values
[0] = vgGeti(type
);
805 values
[0] = vgGetf(type
);
807 case VG_SCISSOR_RECTS
: {
809 for (i
= 0; i
< count
; ++i
) {
810 values
[i
] = state
->scissor_rects
[i
].f
;
814 #ifdef OPENVG_VERSION_1_1
815 case VG_COLOR_TRANSFORM_VALUES
: {
816 memcpy(values
, state
->color_transform_values
,
817 sizeof(VGfloat
) * count
);
821 case VG_STROKE_LINE_WIDTH
:
822 values
[0] = state
->stroke
.line_width
.f
;
824 case VG_STROKE_MITER_LIMIT
:
825 values
[0] = state
->stroke
.miter_limit
.f
;
827 case VG_STROKE_DASH_PATTERN
: {
829 for (i
= 0; i
< count
; ++i
) {
830 values
[i
] = state
->stroke
.dash_pattern
[i
].f
;
834 case VG_STROKE_DASH_PHASE
:
835 values
[0] = state
->stroke
.dash_phase
.f
;
837 case VG_TILE_FILL_COLOR
:
838 values
[0] = state
->tile_fill_color
[0];
839 values
[1] = state
->tile_fill_color
[1];
840 values
[2] = state
->tile_fill_color
[2];
841 values
[3] = state
->tile_fill_color
[3];
844 values
[0] = state
->clear_color
[0];
845 values
[1] = state
->clear_color
[1];
846 values
[2] = state
->clear_color
[2];
847 values
[3] = state
->clear_color
[3];
849 #ifdef OPENVG_VERSION_1_1
850 case VG_GLYPH_ORIGIN
:
851 values
[0] = state
->glyph_origin
[0].f
;
852 values
[1] = state
->glyph_origin
[1].f
;
856 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
861 void vgGetiv(VGParamType type
, VGint count
,
864 const struct vg_state
*state
= current_state();
865 struct vg_context
*ctx
= vg_current_context();
866 VGint real_count
= vgGetVectorSize(type
);
868 if (!values
|| count
<= 0 || count
> real_count
|| !is_aligned(values
)) {
869 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
876 case VG_IMAGE_QUALITY
:
877 case VG_RENDERING_QUALITY
:
880 #ifdef OPENVG_VERSION_1_1
881 case VG_COLOR_TRANSFORM
:
883 case VG_STROKE_CAP_STYLE
:
884 case VG_STROKE_JOIN_STYLE
:
885 case VG_STROKE_DASH_PHASE_RESET
:
888 case VG_PIXEL_LAYOUT
:
889 case VG_SCREEN_LAYOUT
:
890 case VG_FILTER_FORMAT_LINEAR
:
891 case VG_FILTER_FORMAT_PREMULTIPLIED
:
892 case VG_FILTER_CHANNEL_MASK
:
893 case VG_MAX_SCISSOR_RECTS
:
894 case VG_MAX_DASH_COUNT
:
895 case VG_MAX_KERNEL_SIZE
:
896 case VG_MAX_SEPARABLE_KERNEL_SIZE
:
897 case VG_MAX_COLOR_RAMP_STOPS
:
898 case VG_MAX_IMAGE_WIDTH
:
899 case VG_MAX_IMAGE_HEIGHT
:
900 case VG_MAX_IMAGE_PIXELS
:
901 case VG_MAX_IMAGE_BYTES
:
902 case VG_MAX_GAUSSIAN_STD_DEVIATION
:
903 values
[0] = vgGeti(type
);
906 VGfloat val
= vgGetf(type
);
907 values
[0] = float_to_int_floor(*((VGuint
*)&val
));
910 case VG_SCISSOR_RECTS
: {
912 for (i
= 0; i
< count
; ++i
) {
913 values
[i
] = state
->scissor_rects
[i
].i
;
917 #ifdef OPENVG_VERSION_1_1
918 case VG_COLOR_TRANSFORM_VALUES
: {
920 VGuint
*x
= (VGuint
*)state
->color_transform_values
;
921 for (i
= 0; i
< count
; ++i
) {
922 values
[i
] = float_to_int_floor(x
[i
]);
927 case VG_STROKE_LINE_WIDTH
:
928 values
[0] = state
->stroke
.line_width
.i
;
930 case VG_STROKE_MITER_LIMIT
:
931 values
[0] = state
->stroke
.miter_limit
.i
;
933 case VG_STROKE_DASH_PATTERN
: {
935 for (i
= 0; i
< count
; ++i
) {
936 values
[i
] = state
->stroke
.dash_pattern
[i
].i
;
940 case VG_STROKE_DASH_PHASE
:
941 values
[0] = state
->stroke
.dash_phase
.i
;
943 case VG_TILE_FILL_COLOR
:
944 values
[0] = state
->tile_fill_colori
[0];
945 values
[1] = state
->tile_fill_colori
[1];
946 values
[2] = state
->tile_fill_colori
[2];
947 values
[3] = state
->tile_fill_colori
[3];
950 values
[0] = state
->clear_colori
[0];
951 values
[1] = state
->clear_colori
[1];
952 values
[2] = state
->clear_colori
[2];
953 values
[3] = state
->clear_colori
[3];
955 #ifdef OPENVG_VERSION_1_1
956 case VG_GLYPH_ORIGIN
:
957 values
[0] = state
->glyph_origin
[0].i
;
958 values
[1] = state
->glyph_origin
[1].i
;
962 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
967 void vgSetParameterf(VGHandle object
,
971 struct vg_context
*ctx
= vg_current_context();
972 void *ptr
= (void*)object
;
974 if (!object
|| object
== VG_INVALID_HANDLE
|| !is_aligned(ptr
)) {
975 vg_set_error(ctx
, VG_BAD_HANDLE_ERROR
);
981 case VG_PAINT_COLOR_RAMP_SPREAD_MODE
:
982 case VG_PAINT_PATTERN_TILING_MODE
:
983 vgSetParameteri(object
, paramType
, floor(value
));
987 case VG_PAINT_COLOR_RAMP_STOPS
:
988 case VG_PAINT_LINEAR_GRADIENT
:
989 case VG_PAINT_RADIAL_GRADIENT
:
990 /* it's an error if paramType refers to a vector parameter */
991 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
993 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED
: {
994 struct vg_paint
*p
= (struct vg_paint
*)object
;
995 paint_set_color_ramp_premultiplied(p
, value
);
999 case VG_PATH_DATATYPE
:
1000 case VG_PATH_FORMAT
:
1003 case VG_PATH_NUM_SEGMENTS
:
1004 case VG_PATH_NUM_COORDS
:
1006 case VG_IMAGE_FORMAT
:
1007 case VG_IMAGE_WIDTH
:
1008 case VG_IMAGE_HEIGHT
:
1010 #ifdef OPENVG_VERSION_1_1
1011 case VG_FONT_NUM_GLYPHS
:
1012 /* read only don't produce an error */
1016 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1021 void vgSetParameteri(VGHandle object
,
1025 struct vg_context
*ctx
= vg_current_context();
1026 void *ptr
= (void*)object
;
1028 if (!object
|| object
== VG_INVALID_HANDLE
|| !is_aligned(ptr
)) {
1029 vg_set_error(ctx
, VG_BAD_HANDLE_ERROR
);
1035 if (value
< VG_PAINT_TYPE_COLOR
||
1036 value
> VG_PAINT_TYPE_PATTERN
)
1037 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1039 struct vg_paint
*paint
= (struct vg_paint
*)ptr
;
1040 paint_set_type(paint
, value
);
1043 case VG_PAINT_COLOR
:
1044 case VG_PAINT_COLOR_RAMP_STOPS
:
1045 case VG_PAINT_LINEAR_GRADIENT
:
1046 case VG_PAINT_RADIAL_GRADIENT
:
1047 /* it's an error if paramType refers to a vector parameter */
1048 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1050 case VG_PAINT_COLOR_RAMP_SPREAD_MODE
:
1051 if (value
< VG_COLOR_RAMP_SPREAD_PAD
||
1052 value
> VG_COLOR_RAMP_SPREAD_REFLECT
)
1053 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1055 struct vg_paint
*paint
= (struct vg_paint
*)ptr
;
1056 paint_set_spread_mode(paint
, value
);
1059 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED
: {
1060 struct vg_paint
*p
= (struct vg_paint
*)object
;
1061 paint_set_color_ramp_premultiplied(p
, value
);
1064 case VG_PAINT_PATTERN_TILING_MODE
:
1065 if (value
< VG_TILE_FILL
||
1066 value
> VG_TILE_REFLECT
)
1067 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1069 struct vg_paint
*paint
= (struct vg_paint
*)ptr
;
1070 paint_set_pattern_tiling(paint
, value
);
1074 case VG_PATH_DATATYPE
:
1075 case VG_PATH_FORMAT
:
1078 case VG_PATH_NUM_SEGMENTS
:
1079 case VG_PATH_NUM_COORDS
:
1081 case VG_IMAGE_FORMAT
:
1082 case VG_IMAGE_WIDTH
:
1083 case VG_IMAGE_HEIGHT
:
1085 #ifdef OPENVG_VERSION_1_1
1086 case VG_FONT_NUM_GLYPHS
:
1087 /* read only don't produce an error */
1091 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1096 void vgSetParameterfv(VGHandle object
,
1099 const VGfloat
* values
)
1101 struct vg_context
*ctx
= vg_current_context();
1102 void *ptr
= (void*)object
;
1103 VGint real_count
= vgGetParameterVectorSize(object
, paramType
);
1105 if (!object
|| object
== VG_INVALID_HANDLE
|| !is_aligned(ptr
)) {
1106 vg_set_error(ctx
, VG_BAD_HANDLE_ERROR
);
1110 if (count
< 0 || count
< real_count
||
1111 (values
== NULL
&& count
!= 0) ||
1112 !is_aligned(values
)) {
1113 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1119 case VG_PAINT_COLOR_RAMP_SPREAD_MODE
:
1120 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED
:
1121 case VG_PAINT_PATTERN_TILING_MODE
:
1123 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1125 vgSetParameterf(object
, paramType
, values
[0]);
1128 case VG_PAINT_COLOR
: {
1130 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1132 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1133 paint_set_color(paint
, values
);
1137 case VG_PAINT_COLOR_RAMP_STOPS
: {
1138 if (count
&& count
< 4)
1139 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1141 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1142 count
= MIN2(count
, VEGA_MAX_COLOR_RAMP_STOPS
);
1143 paint_set_ramp_stops(paint
, values
, count
);
1145 VGint stopsi
[VEGA_MAX_COLOR_RAMP_STOPS
];
1147 for (i
= 0; i
< count
; ++i
) {
1148 stopsi
[i
] = float_to_int_floor(*((VGuint
*)(values
+ i
)));
1150 paint_set_ramp_stopsi(paint
, stopsi
, count
);
1155 case VG_PAINT_LINEAR_GRADIENT
: {
1157 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1159 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1160 paint_set_linear_gradient(paint
, values
);
1163 vals
[0] = FLT_TO_INT(values
[0]);
1164 vals
[1] = FLT_TO_INT(values
[1]);
1165 vals
[2] = FLT_TO_INT(values
[2]);
1166 vals
[3] = FLT_TO_INT(values
[3]);
1167 paint_set_linear_gradienti(paint
, vals
);
1172 case VG_PAINT_RADIAL_GRADIENT
: {
1174 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1176 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1177 paint_set_radial_gradient(paint
, values
);
1180 vals
[0] = FLT_TO_INT(values
[0]);
1181 vals
[1] = FLT_TO_INT(values
[1]);
1182 vals
[2] = FLT_TO_INT(values
[2]);
1183 vals
[3] = FLT_TO_INT(values
[3]);
1184 vals
[4] = FLT_TO_INT(values
[4]);
1185 paint_set_radial_gradienti(paint
, vals
);
1191 case VG_PATH_DATATYPE
:
1192 case VG_PATH_FORMAT
:
1195 case VG_PATH_NUM_SEGMENTS
:
1196 case VG_PATH_NUM_COORDS
:
1198 #ifdef OPENVG_VERSION_1_1
1199 case VG_FONT_NUM_GLYPHS
:
1200 /* read only don't produce an error */
1204 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1209 void vgSetParameteriv(VGHandle object
,
1212 const VGint
* values
)
1214 struct vg_context
*ctx
= vg_current_context();
1215 void *ptr
= (void*)object
;
1216 VGint real_count
= vgGetParameterVectorSize(object
, paramType
);
1218 if (!object
|| object
== VG_INVALID_HANDLE
|| !is_aligned(ptr
)) {
1219 vg_set_error(ctx
, VG_BAD_HANDLE_ERROR
);
1223 if (count
< 0 || count
< real_count
||
1224 (values
== NULL
&& count
!= 0) ||
1225 !is_aligned(values
)) {
1226 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1232 case VG_PAINT_COLOR_RAMP_SPREAD_MODE
:
1233 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED
:
1234 case VG_PAINT_PATTERN_TILING_MODE
:
1236 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1238 vgSetParameteri(object
, paramType
, values
[0]);
1241 case VG_PAINT_COLOR
: {
1243 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1245 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1246 paint_set_coloriv(paint
, values
);
1250 case VG_PAINT_COLOR_RAMP_STOPS
: {
1252 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1256 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1258 vals
= malloc(sizeof(VGfloat
)*count
);
1259 for (i
= 0; i
< count
; ++i
)
1260 vals
[i
] = values
[i
];
1263 paint_set_ramp_stopsi(paint
, values
, count
);
1264 paint_set_ramp_stops(paint
, vals
, count
);
1269 case VG_PAINT_LINEAR_GRADIENT
: {
1271 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1274 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1275 vals
[0] = values
[0];
1276 vals
[1] = values
[1];
1277 vals
[2] = values
[2];
1278 vals
[3] = values
[3];
1279 paint_set_linear_gradient(paint
, vals
);
1280 paint_set_linear_gradienti(paint
, values
);
1284 case VG_PAINT_RADIAL_GRADIENT
: {
1286 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1289 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1290 vals
[0] = values
[0];
1291 vals
[1] = values
[1];
1292 vals
[2] = values
[2];
1293 vals
[3] = values
[3];
1294 vals
[4] = values
[4];
1295 paint_set_radial_gradient(paint
, vals
);
1296 paint_set_radial_gradienti(paint
, values
);
1300 case VG_PATH_DATATYPE
:
1301 case VG_PATH_FORMAT
:
1304 case VG_PATH_NUM_SEGMENTS
:
1305 case VG_PATH_NUM_COORDS
:
1306 /* read only don't produce an error */
1309 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1314 VGint
vgGetParameterVectorSize(VGHandle object
,
1317 struct vg_context
*ctx
= vg_current_context();
1318 void *ptr
= (void*)object
;
1320 if (!ptr
|| object
== VG_INVALID_HANDLE
) {
1321 vg_set_error(ctx
, VG_BAD_HANDLE_ERROR
);
1327 case VG_PAINT_COLOR_RAMP_SPREAD_MODE
:
1328 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED
:
1329 case VG_PAINT_PATTERN_TILING_MODE
:
1331 case VG_PAINT_COLOR
:
1333 case VG_PAINT_COLOR_RAMP_STOPS
: {
1334 struct vg_paint
*p
= (struct vg_paint
*)object
;
1335 return paint_num_ramp_stops(p
);
1338 case VG_PAINT_LINEAR_GRADIENT
:
1340 case VG_PAINT_RADIAL_GRADIENT
:
1344 case VG_PATH_FORMAT
:
1345 case VG_PATH_DATATYPE
:
1348 case VG_PATH_NUM_SEGMENTS
:
1349 case VG_PATH_NUM_COORDS
:
1352 case VG_IMAGE_FORMAT
:
1353 case VG_IMAGE_WIDTH
:
1354 case VG_IMAGE_HEIGHT
:
1357 #ifdef OPENVG_VERSION_1_1
1358 case VG_FONT_NUM_GLYPHS
:
1363 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1370 VGfloat
vgGetParameterf(VGHandle object
,
1373 struct vg_context
*ctx
= vg_current_context();
1374 void *ptr
= (void*)object
;
1376 if (!ptr
|| object
== VG_INVALID_HANDLE
) {
1377 vg_set_error(ctx
, VG_BAD_HANDLE_ERROR
);
1383 case VG_PAINT_COLOR_RAMP_SPREAD_MODE
:
1384 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED
:
1385 case VG_PAINT_PATTERN_TILING_MODE
:
1386 return vgGetParameteri(object
, paramType
);
1388 case VG_PAINT_COLOR
:
1389 case VG_PAINT_COLOR_RAMP_STOPS
:
1390 case VG_PAINT_LINEAR_GRADIENT
:
1391 case VG_PAINT_RADIAL_GRADIENT
:
1392 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1395 case VG_PATH_FORMAT
:
1396 return VG_PATH_FORMAT_STANDARD
;
1397 case VG_PATH_SCALE
: {
1398 struct path
*p
= (struct path
*)object
;
1399 return path_scale(p
);
1401 case VG_PATH_BIAS
: {
1402 struct path
*p
= (struct path
*)object
;
1403 return path_bias(p
);
1405 case VG_PATH_DATATYPE
:
1406 case VG_PATH_NUM_SEGMENTS
:
1407 case VG_PATH_NUM_COORDS
:
1408 return vgGetParameteri(object
, paramType
);
1411 case VG_IMAGE_FORMAT
:
1412 case VG_IMAGE_WIDTH
:
1413 case VG_IMAGE_HEIGHT
:
1414 #ifdef OPENVG_VERSION_1_1
1415 case VG_FONT_NUM_GLYPHS
:
1416 return vgGetParameteri(object
, paramType
);
1421 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1427 VGint
vgGetParameteri(VGHandle object
,
1430 struct vg_context
*ctx
= vg_current_context();
1431 void *ptr
= (void*)object
;
1433 if (!ptr
|| object
== VG_INVALID_HANDLE
) {
1434 vg_set_error(ctx
, VG_BAD_HANDLE_ERROR
);
1439 case VG_PAINT_TYPE
: {
1440 struct vg_paint
*paint
= (struct vg_paint
*)ptr
;
1441 return paint_type(paint
);
1444 case VG_PAINT_COLOR_RAMP_SPREAD_MODE
: {
1445 struct vg_paint
*p
= (struct vg_paint
*)object
;
1446 return paint_spread_mode(p
);
1448 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED
: {
1449 struct vg_paint
*p
= (struct vg_paint
*)object
;
1450 return paint_color_ramp_premultiplied(p
);
1453 case VG_PAINT_PATTERN_TILING_MODE
: {
1454 struct vg_paint
*p
= (struct vg_paint
*)object
;
1455 return paint_pattern_tiling(p
);
1458 case VG_PAINT_COLOR
:
1459 case VG_PAINT_COLOR_RAMP_STOPS
:
1460 case VG_PAINT_LINEAR_GRADIENT
:
1461 case VG_PAINT_RADIAL_GRADIENT
:
1462 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1465 case VG_PATH_FORMAT
:
1466 return VG_PATH_FORMAT_STANDARD
;
1469 return vgGetParameterf(object
, paramType
);
1470 case VG_PATH_DATATYPE
: {
1471 struct path
*p
= (struct path
*)object
;
1472 return path_datatype(p
);
1474 case VG_PATH_NUM_SEGMENTS
: {
1475 struct path
*p
= (struct path
*)object
;
1476 return path_num_segments(p
);
1478 case VG_PATH_NUM_COORDS
: {
1479 struct path
*p
= (struct path
*)object
;
1480 return path_num_coords(p
);
1484 case VG_IMAGE_FORMAT
: {
1485 struct vg_image
*img
= (struct vg_image
*)object
;
1489 case VG_IMAGE_WIDTH
: {
1490 struct vg_image
*img
= (struct vg_image
*)object
;
1494 case VG_IMAGE_HEIGHT
: {
1495 struct vg_image
*img
= (struct vg_image
*)object
;
1500 #ifdef OPENVG_VERSION_1_1
1501 case VG_FONT_NUM_GLYPHS
: {
1508 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1514 void vgGetParameterfv(VGHandle object
,
1519 struct vg_context
*ctx
= vg_current_context();
1520 void *ptr
= (void*)object
;
1521 VGint real_count
= vgGetParameterVectorSize(object
, paramType
);
1523 if (!ptr
|| object
== VG_INVALID_HANDLE
) {
1524 vg_set_error(ctx
, VG_BAD_HANDLE_ERROR
);
1528 if (!values
|| count
<= 0 || count
> real_count
||
1529 !is_aligned(values
)) {
1530 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1535 case VG_PAINT_TYPE
: {
1536 struct vg_paint
*p
= (struct vg_paint
*)object
;
1537 values
[0] = paint_type(p
);
1540 case VG_PAINT_COLOR_RAMP_SPREAD_MODE
: {
1541 struct vg_paint
*p
= (struct vg_paint
*)object
;
1542 values
[0] = paint_spread_mode(p
);
1545 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED
: {
1546 struct vg_paint
*p
= (struct vg_paint
*)object
;
1547 values
[0] = paint_color_ramp_premultiplied(p
);
1550 case VG_PAINT_PATTERN_TILING_MODE
: {
1551 values
[0] = vgGetParameterf(object
, paramType
);
1554 case VG_PAINT_COLOR
: {
1555 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1556 paint_get_color(paint
, values
);
1559 case VG_PAINT_COLOR_RAMP_STOPS
: {
1560 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1561 paint_ramp_stops(paint
, values
, count
);
1564 case VG_PAINT_LINEAR_GRADIENT
: {
1565 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1566 paint_linear_gradient(paint
, values
);
1569 case VG_PAINT_RADIAL_GRADIENT
: {
1570 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1571 paint_radial_gradient(paint
, values
);
1575 case VG_PATH_FORMAT
:
1576 case VG_PATH_DATATYPE
:
1577 case VG_PATH_NUM_SEGMENTS
:
1578 case VG_PATH_NUM_COORDS
:
1579 values
[0] = vgGetParameteri(object
, paramType
);
1583 values
[0] = vgGetParameterf(object
, paramType
);
1586 case VG_IMAGE_FORMAT
:
1587 case VG_IMAGE_WIDTH
:
1588 case VG_IMAGE_HEIGHT
:
1589 #ifdef OPENVG_VERSION_1_1
1590 case VG_FONT_NUM_GLYPHS
:
1591 values
[0] = vgGetParameteri(object
, paramType
);
1596 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1601 void vgGetParameteriv(VGHandle object
,
1606 struct vg_context
*ctx
= vg_current_context();
1607 void *ptr
= (void*)object
;
1608 VGint real_count
= vgGetParameterVectorSize(object
, paramType
);
1610 if (!ptr
|| object
== VG_INVALID_HANDLE
) {
1611 vg_set_error(ctx
, VG_BAD_HANDLE_ERROR
);
1615 if (!values
|| count
<= 0 || count
> real_count
||
1616 !is_aligned(values
)) {
1617 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);
1623 case VG_PAINT_COLOR_RAMP_SPREAD_MODE
:
1624 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED
:
1625 case VG_PAINT_PATTERN_TILING_MODE
:
1626 #ifdef OPENVG_VERSION_1_1
1627 case VG_FONT_NUM_GLYPHS
:
1628 values
[0] = vgGetParameteri(object
, paramType
);
1631 case VG_PAINT_COLOR
: {
1632 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1633 paint_get_coloriv(paint
, values
);
1636 case VG_PAINT_COLOR_RAMP_STOPS
: {
1637 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1638 paint_ramp_stopsi(paint
, values
, count
);
1641 case VG_PAINT_LINEAR_GRADIENT
: {
1642 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1643 paint_linear_gradienti(paint
, values
);
1646 case VG_PAINT_RADIAL_GRADIENT
: {
1647 struct vg_paint
*paint
= (struct vg_paint
*)object
;
1648 paint_radial_gradienti(paint
, values
);
1654 values
[0] = vgGetParameterf(object
, paramType
);
1656 case VG_PATH_FORMAT
:
1657 case VG_PATH_DATATYPE
:
1658 case VG_PATH_NUM_SEGMENTS
:
1659 case VG_PATH_NUM_COORDS
:
1660 values
[0] = vgGetParameteri(object
, paramType
);
1663 case VG_IMAGE_FORMAT
:
1664 case VG_IMAGE_WIDTH
:
1665 case VG_IMAGE_HEIGHT
:
1666 values
[0] = vgGetParameteri(object
, paramType
);
1670 vg_set_error(ctx
, VG_ILLEGAL_ARGUMENT_ERROR
);