api_params.c revision 5be631ce83c3801421c79240be2f422958b206a5
1/************************************************************************** 2 * 3 * Copyright 2009 VMware, Inc. All Rights Reserved. 4 * 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: 12 * 13 * The above copyright notice and this permission notice (including the 14 * next paragraph) shall be included in all copies or substantial portions 15 * of the Software. 16 * 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. 24 * 25 **************************************************************************/ 26 27#include "VG/openvg.h" 28 29#include "vg_context.h" 30#include "paint.h" 31#include "path.h" 32#include "image.h" 33#include "text.h" 34#include "matrix.h" 35#include "api_consts.h" 36#include "api.h" 37 38#include "pipe/p_compiler.h" 39#include "util/u_pointer.h" 40#include "util/u_math.h" 41 42#include <math.h> 43 44static INLINE struct vg_state *current_state() 45{ 46 struct vg_context *ctx = vg_current_context(); 47 if (!ctx) 48 return 0; 49 else 50 return &ctx->state.vg; 51} 52 53static INLINE VGboolean count_in_bounds(VGParamType type, VGint count) 54{ 55 if (count < 0) 56 return VG_FALSE; 57 58 if (type == VG_SCISSOR_RECTS) 59 return (!(count % 4) && (count >= 0 || count <= VEGA_MAX_SCISSOR_RECTS * 4)); 60 else if (type == VG_STROKE_DASH_PATTERN) { 61 return count <= VEGA_MAX_DASH_COUNT; 62 } else { 63 VGint real_count = vgGetVectorSize(type); 64 return count == real_count; 65 } 66} 67 68void vegaSetf (VGParamType type, VGfloat value) 69{ 70 struct vg_context *ctx = vg_current_context(); 71 struct vg_state *state = current_state(); 72 VGErrorCode error = VG_NO_ERROR; 73 74 switch(type) { 75 case VG_MATRIX_MODE: 76 case VG_FILL_RULE: 77 case VG_IMAGE_QUALITY: 78 case VG_RENDERING_QUALITY: 79 case VG_BLEND_MODE: 80 case VG_IMAGE_MODE: 81#ifdef OPENVG_VERSION_1_1 82 case VG_COLOR_TRANSFORM: 83#endif 84 case VG_STROKE_CAP_STYLE: 85 case VG_STROKE_JOIN_STYLE: 86 case VG_STROKE_DASH_PHASE_RESET: 87 case VG_MASKING: 88 case VG_SCISSORING: 89 case VG_PIXEL_LAYOUT: 90 case VG_SCREEN_LAYOUT: 91 case VG_FILTER_FORMAT_LINEAR: 92 case VG_FILTER_FORMAT_PREMULTIPLIED: 93 case VG_FILTER_CHANNEL_MASK: 94 95 case VG_MAX_SCISSOR_RECTS: 96 case VG_MAX_DASH_COUNT: 97 case VG_MAX_KERNEL_SIZE: 98 case VG_MAX_SEPARABLE_KERNEL_SIZE: 99 case VG_MAX_COLOR_RAMP_STOPS: 100 case VG_MAX_IMAGE_WIDTH: 101 case VG_MAX_IMAGE_HEIGHT: 102 case VG_MAX_IMAGE_PIXELS: 103 case VG_MAX_IMAGE_BYTES: 104 case VG_MAX_GAUSSIAN_STD_DEVIATION: 105 case VG_MAX_FLOAT: 106 vgSeti(type, floor(value)); 107 return; 108 break; 109 case VG_STROKE_LINE_WIDTH: 110 state->stroke.line_width.f = value; 111 state->stroke.line_width.i = float_to_int_floor(*((VGuint*)(&value))); 112 break; 113 case VG_STROKE_MITER_LIMIT: 114 state->stroke.miter_limit.f = value; 115 state->stroke.miter_limit.i = float_to_int_floor(*((VGuint*)(&value))); 116 break; 117 case VG_STROKE_DASH_PHASE: 118 state->stroke.dash_phase.f = value; 119 state->stroke.dash_phase.i = float_to_int_floor(*((VGuint*)(&value))); 120 break; 121 default: 122 error = VG_ILLEGAL_ARGUMENT_ERROR; 123 break; 124 } 125 vg_set_error(ctx, error); 126} 127 128void vegaSeti (VGParamType type, VGint value) 129{ 130 struct vg_context *ctx = vg_current_context(); 131 struct vg_state *state = current_state(); 132 VGErrorCode error = VG_NO_ERROR; 133 134 switch(type) { 135 case VG_MATRIX_MODE: 136 if (value < VG_MATRIX_PATH_USER_TO_SURFACE || 137#ifdef OPENVG_VERSION_1_1 138 value > VG_MATRIX_GLYPH_USER_TO_SURFACE) 139#else 140 value > VG_MATRIX_STROKE_PAINT_TO_USER) 141#endif 142 error = VG_ILLEGAL_ARGUMENT_ERROR; 143 else 144 state->matrix_mode = value; 145 break; 146 case VG_FILL_RULE: 147 if (value < VG_EVEN_ODD || 148 value > VG_NON_ZERO) 149 error = VG_ILLEGAL_ARGUMENT_ERROR; 150 else 151 state->fill_rule = value; 152 break; 153 case VG_IMAGE_QUALITY: 154 state->image_quality = value; 155 break; 156 case VG_RENDERING_QUALITY: 157 if (value < VG_RENDERING_QUALITY_NONANTIALIASED || 158 value > VG_RENDERING_QUALITY_BETTER) 159 error = VG_ILLEGAL_ARGUMENT_ERROR; 160 else 161 state->rendering_quality = value; 162 break; 163 case VG_BLEND_MODE: 164 if (value < VG_BLEND_SRC || 165 value > VG_BLEND_ADDITIVE) 166 error = VG_ILLEGAL_ARGUMENT_ERROR; 167 else { 168 ctx->state.dirty |= BLEND_DIRTY; 169 state->blend_mode = value; 170 } 171 break; 172 case VG_IMAGE_MODE: 173 if (value < VG_DRAW_IMAGE_NORMAL || 174 value > VG_DRAW_IMAGE_STENCIL) 175 error = VG_ILLEGAL_ARGUMENT_ERROR; 176 else 177 state->image_mode = value; 178 break; 179#ifdef OPENVG_VERSION_1_1 180 case VG_COLOR_TRANSFORM: 181 state->color_transform = value; 182#endif 183 break; 184 case VG_STROKE_LINE_WIDTH: 185 state->stroke.line_width.f = value; 186 state->stroke.line_width.i = value; 187 break; 188 case VG_STROKE_CAP_STYLE: 189 if (value < VG_CAP_BUTT || 190 value > VG_CAP_SQUARE) 191 error = VG_ILLEGAL_ARGUMENT_ERROR; 192 else 193 state->stroke.cap_style = value; 194 break; 195 case VG_STROKE_JOIN_STYLE: 196 if (value < VG_JOIN_MITER || 197 value > VG_JOIN_BEVEL) 198 error = VG_ILLEGAL_ARGUMENT_ERROR; 199 else 200 state->stroke.join_style = value; 201 break; 202 case VG_STROKE_MITER_LIMIT: 203 state->stroke.miter_limit.f = value; 204 state->stroke.miter_limit.i = value; 205 break; 206 case VG_STROKE_DASH_PHASE: 207 state->stroke.dash_phase.f = value; 208 state->stroke.dash_phase.i = value; 209 break; 210 case VG_STROKE_DASH_PHASE_RESET: 211 state->stroke.dash_phase_reset = value; 212 break; 213 case VG_MASKING: 214 state->masking = value; 215 break; 216 case VG_SCISSORING: 217 state->scissoring = value; 218 ctx->state.dirty |= DEPTH_STENCIL_DIRTY; 219 break; 220 case VG_PIXEL_LAYOUT: 221 if (value < VG_PIXEL_LAYOUT_UNKNOWN || 222 value > VG_PIXEL_LAYOUT_BGR_HORIZONTAL) 223 error = VG_ILLEGAL_ARGUMENT_ERROR; 224 else 225 state->pixel_layout = value; 226 break; 227 case VG_SCREEN_LAYOUT: 228 /* read only ignore */ 229 break; 230 case VG_FILTER_FORMAT_LINEAR: 231 state->filter_format_linear = value; 232 break; 233 case VG_FILTER_FORMAT_PREMULTIPLIED: 234 state->filter_format_premultiplied = value; 235 break; 236 case VG_FILTER_CHANNEL_MASK: 237 state->filter_channel_mask = value; 238 break; 239 240 case VG_MAX_SCISSOR_RECTS: 241 case VG_MAX_DASH_COUNT: 242 case VG_MAX_KERNEL_SIZE: 243 case VG_MAX_SEPARABLE_KERNEL_SIZE: 244 case VG_MAX_COLOR_RAMP_STOPS: 245 case VG_MAX_IMAGE_WIDTH: 246 case VG_MAX_IMAGE_HEIGHT: 247 case VG_MAX_IMAGE_PIXELS: 248 case VG_MAX_IMAGE_BYTES: 249 case VG_MAX_GAUSSIAN_STD_DEVIATION: 250 case VG_MAX_FLOAT: 251 /* read only ignore */ 252 break; 253 default: 254 error = VG_ILLEGAL_ARGUMENT_ERROR; 255 break; 256 } 257 vg_set_error(ctx, error); 258} 259 260void vegaSetfv(VGParamType type, VGint count, 261 const VGfloat * values) 262{ 263 struct vg_context *ctx = vg_current_context(); 264 struct vg_state *state = current_state(); 265 VGErrorCode error = VG_NO_ERROR; 266 267 if ((count && !values) || !count_in_bounds(type, count) || !is_aligned(values)) { 268 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 269 return; 270 } 271 272 switch(type) { 273 case VG_MATRIX_MODE: 274 case VG_FILL_RULE: 275 case VG_IMAGE_QUALITY: 276 case VG_RENDERING_QUALITY: 277 case VG_BLEND_MODE: 278 case VG_IMAGE_MODE: 279#ifdef OPENVG_VERSION_1_1 280 case VG_COLOR_TRANSFORM: 281#endif 282 case VG_STROKE_CAP_STYLE: 283 case VG_STROKE_JOIN_STYLE: 284 case VG_STROKE_DASH_PHASE_RESET: 285 case VG_MASKING: 286 case VG_SCISSORING: 287 case VG_PIXEL_LAYOUT: 288 case VG_SCREEN_LAYOUT: 289 case VG_FILTER_FORMAT_LINEAR: 290 case VG_FILTER_FORMAT_PREMULTIPLIED: 291 case VG_FILTER_CHANNEL_MASK: 292 vgSeti(type, floor(values[0])); 293 return; 294 break; 295 case VG_SCISSOR_RECTS: { 296 VGint i; 297 VGuint *x = (VGuint*)values; 298 for (i = 0; i < count; ++i) { 299 state->scissor_rects[i].f = values[i]; 300 state->scissor_rects[i].i = float_to_int_floor(x[i]); 301 } 302 state->scissor_rects_num = count / 4; 303 ctx->state.dirty |= DEPTH_STENCIL_DIRTY; 304 } 305 break; 306#ifdef OPENVG_VERSION_1_1 307 case VG_COLOR_TRANSFORM_VALUES: { 308 VGint i; 309 for (i = 0; i < count; ++i) { 310 state->color_transform_values[i] = values[i]; 311 } 312 } 313 break; 314#endif 315 case VG_STROKE_LINE_WIDTH: 316 state->stroke.line_width.f = values[0]; 317 state->stroke.line_width.i = float_to_int_floor(*((VGuint*)(values))); 318 break; 319 case VG_STROKE_MITER_LIMIT: 320 state->stroke.miter_limit.f = values[0]; 321 state->stroke.miter_limit.i = float_to_int_floor(*((VGuint*)(values))); 322 break; 323 case VG_STROKE_DASH_PATTERN: { 324 int i; 325 for (i = 0; i < count; ++i) { 326 state->stroke.dash_pattern[i].f = values[i]; 327 state->stroke.dash_pattern[i].i = 328 float_to_int_floor(*((VGuint*)(values + i))); 329 } 330 state->stroke.dash_pattern_num = count; 331 } 332 break; 333 case VG_STROKE_DASH_PHASE: 334 state->stroke.dash_phase.f = values[0]; 335 state->stroke.dash_phase.i = float_to_int_floor(*((VGuint*)(values))); 336 break; 337 case VG_TILE_FILL_COLOR: 338 state->tile_fill_color[0] = values[0]; 339 state->tile_fill_color[1] = values[1]; 340 state->tile_fill_color[2] = values[2]; 341 state->tile_fill_color[3] = values[3]; 342 343 state->tile_fill_colori[0] = float_to_int_floor(*((VGuint*)(values + 0))); 344 state->tile_fill_colori[1] = float_to_int_floor(*((VGuint*)(values + 1))); 345 state->tile_fill_colori[2] = float_to_int_floor(*((VGuint*)(values + 2))); 346 state->tile_fill_colori[3] = float_to_int_floor(*((VGuint*)(values + 3))); 347 break; 348 case VG_CLEAR_COLOR: 349 state->clear_color[0] = values[0]; 350 state->clear_color[1] = values[1]; 351 state->clear_color[2] = values[2]; 352 state->clear_color[3] = values[3]; 353 354 state->clear_colori[0] = float_to_int_floor(*((VGuint*)(values + 0))); 355 state->clear_colori[1] = float_to_int_floor(*((VGuint*)(values + 1))); 356 state->clear_colori[2] = float_to_int_floor(*((VGuint*)(values + 2))); 357 state->clear_colori[3] = float_to_int_floor(*((VGuint*)(values + 3))); 358 break; 359#ifdef OPENVG_VERSION_1_1 360 case VG_GLYPH_ORIGIN: 361 state->glyph_origin[0].f = values[0]; 362 state->glyph_origin[1].f = values[1]; 363 364 state->glyph_origin[0].i = float_to_int_floor(*((VGuint*)(values + 0))); 365 state->glyph_origin[1].i = float_to_int_floor(*((VGuint*)(values + 1))); 366 break; 367#endif 368 369 case VG_MAX_SCISSOR_RECTS: 370 case VG_MAX_DASH_COUNT: 371 case VG_MAX_KERNEL_SIZE: 372 case VG_MAX_SEPARABLE_KERNEL_SIZE: 373 case VG_MAX_COLOR_RAMP_STOPS: 374 case VG_MAX_IMAGE_WIDTH: 375 case VG_MAX_IMAGE_HEIGHT: 376 case VG_MAX_IMAGE_PIXELS: 377 case VG_MAX_IMAGE_BYTES: 378 case VG_MAX_GAUSSIAN_STD_DEVIATION: 379 case VG_MAX_FLOAT: 380 break; 381 default: 382 error = VG_ILLEGAL_ARGUMENT_ERROR; 383 break; 384 } 385 vg_set_error(ctx, error); 386} 387 388void vegaSetiv(VGParamType type, VGint count, 389 const VGint * values) 390{ 391 struct vg_context *ctx = vg_current_context(); 392 struct vg_state *state = current_state(); 393 394 if ((count && !values) || !count_in_bounds(type, count) || !is_aligned(values)) { 395 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 396 return; 397 } 398 399 switch(type) { 400 case VG_MATRIX_MODE: 401 case VG_FILL_RULE: 402 case VG_IMAGE_QUALITY: 403 case VG_RENDERING_QUALITY: 404 case VG_BLEND_MODE: 405 case VG_IMAGE_MODE: 406#ifdef OPENVG_VERSION_1_1 407 case VG_COLOR_TRANSFORM: 408#endif 409 case VG_STROKE_CAP_STYLE: 410 case VG_STROKE_JOIN_STYLE: 411 case VG_STROKE_DASH_PHASE_RESET: 412 case VG_MASKING: 413 case VG_SCISSORING: 414 case VG_PIXEL_LAYOUT: 415 case VG_SCREEN_LAYOUT: 416 case VG_FILTER_FORMAT_LINEAR: 417 case VG_FILTER_FORMAT_PREMULTIPLIED: 418 case VG_FILTER_CHANNEL_MASK: 419 vgSeti(type, values[0]); 420 return; 421 break; 422 case VG_SCISSOR_RECTS: { 423 VGint i; 424 for (i = 0; i < count; ++i) { 425 state->scissor_rects[i].i = values[i]; 426 state->scissor_rects[i].f = values[i]; 427 } 428 state->scissor_rects_num = count / 4; 429 ctx->state.dirty |= DEPTH_STENCIL_DIRTY; 430 } 431 break; 432#ifdef OPENVG_VERSION_1_1 433 case VG_COLOR_TRANSFORM_VALUES: { 434 VGint i; 435 for (i = 0; i < count; ++i) { 436 state->color_transform_values[i] = values[i]; 437 } 438 } 439 break; 440#endif 441 case VG_STROKE_LINE_WIDTH: 442 state->stroke.line_width.f = values[0]; 443 state->stroke.line_width.i = values[0]; 444 break; 445 case VG_STROKE_MITER_LIMIT: 446 state->stroke.miter_limit.f = values[0]; 447 state->stroke.miter_limit.i = values[0]; 448 break; 449 case VG_STROKE_DASH_PATTERN: { 450 int i; 451 for (i = 0; i < count; ++i) { 452 state->stroke.dash_pattern[i].f = values[i]; 453 state->stroke.dash_pattern[i].i = values[i]; 454 } 455 state->stroke.dash_pattern_num = count; 456 } 457 break; 458 case VG_STROKE_DASH_PHASE: 459 state->stroke.dash_phase.f = values[0]; 460 state->stroke.dash_phase.i = values[0]; 461 break; 462 case VG_TILE_FILL_COLOR: 463 state->tile_fill_color[0] = values[0]; 464 state->tile_fill_color[1] = values[1]; 465 state->tile_fill_color[2] = values[2]; 466 state->tile_fill_color[3] = values[3]; 467 468 state->tile_fill_colori[0] = values[0]; 469 state->tile_fill_colori[1] = values[1]; 470 state->tile_fill_colori[2] = values[2]; 471 state->tile_fill_colori[3] = values[3]; 472 break; 473 case VG_CLEAR_COLOR: 474 state->clear_color[0] = values[0]; 475 state->clear_color[1] = values[1]; 476 state->clear_color[2] = values[2]; 477 state->clear_color[3] = values[3]; 478 479 state->clear_colori[0] = values[0]; 480 state->clear_colori[1] = values[1]; 481 state->clear_colori[2] = values[2]; 482 state->clear_colori[3] = values[3]; 483 break; 484#ifdef OPENVG_VERSION_1_1 485 case VG_GLYPH_ORIGIN: 486 state->glyph_origin[0].f = values[0]; 487 state->glyph_origin[1].f = values[1]; 488 state->glyph_origin[0].i = values[0]; 489 state->glyph_origin[1].i = values[1]; 490 break; 491#endif 492 493 case VG_MAX_SCISSOR_RECTS: 494 case VG_MAX_DASH_COUNT: 495 case VG_MAX_KERNEL_SIZE: 496 case VG_MAX_SEPARABLE_KERNEL_SIZE: 497 case VG_MAX_COLOR_RAMP_STOPS: 498 case VG_MAX_IMAGE_WIDTH: 499 case VG_MAX_IMAGE_HEIGHT: 500 case VG_MAX_IMAGE_PIXELS: 501 case VG_MAX_IMAGE_BYTES: 502 case VG_MAX_GAUSSIAN_STD_DEVIATION: 503 case VG_MAX_FLOAT: 504 break; 505 506 default: 507 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 508 break; 509 } 510} 511 512VGfloat vegaGetf(VGParamType type) 513{ 514 struct vg_context *ctx = vg_current_context(); 515 const struct vg_state *state = current_state(); 516 VGErrorCode error = VG_NO_ERROR; 517 VGfloat value = 0.0f; 518 519 switch(type) { 520 case VG_MATRIX_MODE: 521 case VG_FILL_RULE: 522 case VG_IMAGE_QUALITY: 523 case VG_RENDERING_QUALITY: 524 case VG_BLEND_MODE: 525 case VG_IMAGE_MODE: 526#ifdef OPENVG_VERSION_1_1 527 case VG_COLOR_TRANSFORM: 528#endif 529 case VG_STROKE_CAP_STYLE: 530 case VG_STROKE_JOIN_STYLE: 531 case VG_STROKE_DASH_PHASE_RESET: 532 case VG_MASKING: 533 case VG_SCISSORING: 534 case VG_PIXEL_LAYOUT: 535 case VG_SCREEN_LAYOUT: 536 case VG_FILTER_FORMAT_LINEAR: 537 case VG_FILTER_FORMAT_PREMULTIPLIED: 538 case VG_FILTER_CHANNEL_MASK: 539 return vgGeti(type); 540 break; 541 case VG_STROKE_LINE_WIDTH: 542 value = state->stroke.line_width.f; 543 break; 544 case VG_STROKE_MITER_LIMIT: 545 value = state->stroke.miter_limit.f; 546 break; 547 case VG_STROKE_DASH_PHASE: 548 value = state->stroke.dash_phase.f; 549 break; 550 551 case VG_MAX_SCISSOR_RECTS: 552 case VG_MAX_DASH_COUNT: 553 case VG_MAX_KERNEL_SIZE: 554 case VG_MAX_SEPARABLE_KERNEL_SIZE: 555 case VG_MAX_COLOR_RAMP_STOPS: 556 case VG_MAX_IMAGE_WIDTH: 557 case VG_MAX_IMAGE_HEIGHT: 558 case VG_MAX_IMAGE_PIXELS: 559 case VG_MAX_IMAGE_BYTES: 560 case VG_MAX_GAUSSIAN_STD_DEVIATION: 561 return vgGeti(type); 562 break; 563 case VG_MAX_FLOAT: 564 value = 1e+10;/*must be at least 1e+10*/ 565 break; 566 default: 567 error = VG_ILLEGAL_ARGUMENT_ERROR; 568 break; 569 } 570 vg_set_error(ctx, error); 571 return value; 572} 573 574VGint vegaGeti(VGParamType type) 575{ 576 const struct vg_state *state = current_state(); 577 struct vg_context *ctx = vg_current_context(); 578 VGErrorCode error = VG_NO_ERROR; 579 VGint value = 0; 580 581 switch(type) { 582 case VG_MATRIX_MODE: 583 value = state->matrix_mode; 584 break; 585 case VG_FILL_RULE: 586 value = state->fill_rule; 587 break; 588 case VG_IMAGE_QUALITY: 589 value = state->image_quality; 590 break; 591 case VG_RENDERING_QUALITY: 592 value = state->rendering_quality; 593 break; 594 case VG_BLEND_MODE: 595 value = state->blend_mode; 596 break; 597 case VG_IMAGE_MODE: 598 value = state->image_mode; 599 break; 600#ifdef OPENVG_VERSION_1_1 601 case VG_COLOR_TRANSFORM: 602 value = state->color_transform; 603 break; 604#endif 605 case VG_STROKE_LINE_WIDTH: 606 value = state->stroke.line_width.i; 607 break; 608 case VG_STROKE_CAP_STYLE: 609 value = state->stroke.cap_style; 610 break; 611 case VG_STROKE_JOIN_STYLE: 612 value = state->stroke.join_style; 613 break; 614 case VG_STROKE_MITER_LIMIT: 615 value = state->stroke.miter_limit.i; 616 break; 617 case VG_STROKE_DASH_PHASE: 618 value = state->stroke.dash_phase.i; 619 break; 620 case VG_STROKE_DASH_PHASE_RESET: 621 value = state->stroke.dash_phase_reset; 622 break; 623 case VG_MASKING: 624 value = state->masking; 625 break; 626 case VG_SCISSORING: 627 value = state->scissoring; 628 break; 629 case VG_PIXEL_LAYOUT: 630 value = state->pixel_layout; 631 break; 632 case VG_SCREEN_LAYOUT: 633 value = state->screen_layout; 634 break; 635 case VG_FILTER_FORMAT_LINEAR: 636 value = state->filter_format_linear; 637 break; 638 case VG_FILTER_FORMAT_PREMULTIPLIED: 639 value = state->filter_format_premultiplied; 640 break; 641 case VG_FILTER_CHANNEL_MASK: 642 value = state->filter_channel_mask; 643 break; 644 645 case VG_MAX_SCISSOR_RECTS: 646 value = 32; /*must be at least 32*/ 647 break; 648 case VG_MAX_DASH_COUNT: 649 value = 16; /*must be at least 16*/ 650 break; 651 case VG_MAX_KERNEL_SIZE: 652 value = 7; /*must be at least 7*/ 653 break; 654 case VG_MAX_SEPARABLE_KERNEL_SIZE: 655 value = 15; /*must be at least 15*/ 656 break; 657 case VG_MAX_COLOR_RAMP_STOPS: 658 value = 256; /*must be at least 32*/ 659 break; 660 case VG_MAX_IMAGE_WIDTH: 661 value = 2048; 662 break; 663 case VG_MAX_IMAGE_HEIGHT: 664 value = 2048; 665 break; 666 case VG_MAX_IMAGE_PIXELS: 667 value = 2048*2048; 668 break; 669 case VG_MAX_IMAGE_BYTES: 670 value = 2048*2048 * 4; 671 break; 672 case VG_MAX_GAUSSIAN_STD_DEVIATION: 673 value = 128; /*must be at least 128*/ 674 break; 675 676 case VG_MAX_FLOAT: { 677 VGfloat val = vgGetf(type); 678 value = float_to_int_floor(*((VGuint*)&val)); 679 } 680 break; 681 default: 682 error = VG_ILLEGAL_ARGUMENT_ERROR; 683 break; 684 } 685 vg_set_error(ctx, error); 686 return value; 687} 688 689VGint vegaGetVectorSize(VGParamType type) 690{ 691 struct vg_context *ctx = vg_current_context(); 692 const struct vg_state *state = current_state(); 693 switch(type) { 694 case VG_MATRIX_MODE: 695 case VG_FILL_RULE: 696 case VG_IMAGE_QUALITY: 697 case VG_RENDERING_QUALITY: 698 case VG_BLEND_MODE: 699 case VG_IMAGE_MODE: 700 return 1; 701 case VG_SCISSOR_RECTS: 702 return state->scissor_rects_num * 4; 703#ifdef OPENVG_VERSION_1_1 704 case VG_COLOR_TRANSFORM: 705 return 1; 706 case VG_COLOR_TRANSFORM_VALUES: 707 return 8; 708#endif 709 case VG_STROKE_LINE_WIDTH: 710 case VG_STROKE_CAP_STYLE: 711 case VG_STROKE_JOIN_STYLE: 712 case VG_STROKE_MITER_LIMIT: 713 return 1; 714 case VG_STROKE_DASH_PATTERN: 715 return state->stroke.dash_pattern_num; 716 case VG_STROKE_DASH_PHASE: 717 return 1; 718 case VG_STROKE_DASH_PHASE_RESET: 719 return 1; 720 case VG_TILE_FILL_COLOR: 721 return 4; 722 case VG_CLEAR_COLOR: 723 return 4; 724#ifdef OPENVG_VERSION_1_1 725 case VG_GLYPH_ORIGIN: 726 return 2; 727#endif 728 case VG_MASKING: 729 return 1; 730 case VG_SCISSORING: 731 return 1; 732 case VG_PIXEL_LAYOUT: 733 return 1; 734 case VG_SCREEN_LAYOUT: 735 return 1; 736 case VG_FILTER_FORMAT_LINEAR: 737 return 1; 738 case VG_FILTER_FORMAT_PREMULTIPLIED: 739 return 1; 740 case VG_FILTER_CHANNEL_MASK: 741 return 1; 742 743 case VG_MAX_COLOR_RAMP_STOPS: 744 return 1; 745 case VG_MAX_SCISSOR_RECTS: 746 case VG_MAX_DASH_COUNT: 747 case VG_MAX_KERNEL_SIZE: 748 case VG_MAX_SEPARABLE_KERNEL_SIZE: 749 case VG_MAX_IMAGE_WIDTH: 750 case VG_MAX_IMAGE_HEIGHT: 751 case VG_MAX_IMAGE_PIXELS: 752 case VG_MAX_IMAGE_BYTES: 753 case VG_MAX_FLOAT: 754 case VG_MAX_GAUSSIAN_STD_DEVIATION: 755 return 1; 756 default: 757 if (ctx) 758 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 759 return 0; 760 } 761} 762 763void vegaGetfv(VGParamType type, VGint count, 764 VGfloat * values) 765{ 766 const struct vg_state *state = current_state(); 767 struct vg_context *ctx = vg_current_context(); 768 VGint real_count = vgGetVectorSize(type); 769 770 if (!values || count <= 0 || count > real_count || !is_aligned(values)) { 771 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 772 return; 773 } 774 775 switch(type) { 776 case VG_MATRIX_MODE: 777 case VG_FILL_RULE: 778 case VG_IMAGE_QUALITY: 779 case VG_RENDERING_QUALITY: 780 case VG_BLEND_MODE: 781 case VG_IMAGE_MODE: 782#ifdef OPENVG_VERSION_1_1 783 case VG_COLOR_TRANSFORM: 784#endif 785 case VG_STROKE_CAP_STYLE: 786 case VG_STROKE_JOIN_STYLE: 787 case VG_STROKE_DASH_PHASE_RESET: 788 case VG_MASKING: 789 case VG_SCISSORING: 790 case VG_PIXEL_LAYOUT: 791 case VG_SCREEN_LAYOUT: 792 case VG_FILTER_FORMAT_LINEAR: 793 case VG_FILTER_FORMAT_PREMULTIPLIED: 794 case VG_FILTER_CHANNEL_MASK: 795 case VG_MAX_SCISSOR_RECTS: 796 case VG_MAX_DASH_COUNT: 797 case VG_MAX_KERNEL_SIZE: 798 case VG_MAX_SEPARABLE_KERNEL_SIZE: 799 case VG_MAX_COLOR_RAMP_STOPS: 800 case VG_MAX_IMAGE_WIDTH: 801 case VG_MAX_IMAGE_HEIGHT: 802 case VG_MAX_IMAGE_PIXELS: 803 case VG_MAX_IMAGE_BYTES: 804 case VG_MAX_GAUSSIAN_STD_DEVIATION: 805 values[0] = vgGeti(type); 806 break; 807 case VG_MAX_FLOAT: 808 values[0] = vgGetf(type); 809 break; 810 case VG_SCISSOR_RECTS: { 811 VGint i; 812 for (i = 0; i < count; ++i) { 813 values[i] = state->scissor_rects[i].f; 814 } 815 } 816 break; 817#ifdef OPENVG_VERSION_1_1 818 case VG_COLOR_TRANSFORM_VALUES: { 819 memcpy(values, state->color_transform_values, 820 sizeof(VGfloat) * count); 821 } 822 break; 823#endif 824 case VG_STROKE_LINE_WIDTH: 825 values[0] = state->stroke.line_width.f; 826 break; 827 case VG_STROKE_MITER_LIMIT: 828 values[0] = state->stroke.miter_limit.f; 829 break; 830 case VG_STROKE_DASH_PATTERN: { 831 VGint i; 832 for (i = 0; i < count; ++i) { 833 values[i] = state->stroke.dash_pattern[i].f; 834 } 835 } 836 break; 837 case VG_STROKE_DASH_PHASE: 838 values[0] = state->stroke.dash_phase.f; 839 break; 840 case VG_TILE_FILL_COLOR: 841 values[0] = state->tile_fill_color[0]; 842 values[1] = state->tile_fill_color[1]; 843 values[2] = state->tile_fill_color[2]; 844 values[3] = state->tile_fill_color[3]; 845 break; 846 case VG_CLEAR_COLOR: 847 values[0] = state->clear_color[0]; 848 values[1] = state->clear_color[1]; 849 values[2] = state->clear_color[2]; 850 values[3] = state->clear_color[3]; 851 break; 852#ifdef OPENVG_VERSION_1_1 853 case VG_GLYPH_ORIGIN: 854 values[0] = state->glyph_origin[0].f; 855 values[1] = state->glyph_origin[1].f; 856 break; 857#endif 858 default: 859 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 860 break; 861 } 862} 863 864void vegaGetiv(VGParamType type, VGint count, 865 VGint * values) 866{ 867 const struct vg_state *state = current_state(); 868 struct vg_context *ctx = vg_current_context(); 869 VGint real_count = vgGetVectorSize(type); 870 871 if (!values || count <= 0 || count > real_count || !is_aligned(values)) { 872 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 873 return; 874 } 875 876 switch(type) { 877 case VG_MATRIX_MODE: 878 case VG_FILL_RULE: 879 case VG_IMAGE_QUALITY: 880 case VG_RENDERING_QUALITY: 881 case VG_BLEND_MODE: 882 case VG_IMAGE_MODE: 883#ifdef OPENVG_VERSION_1_1 884 case VG_COLOR_TRANSFORM: 885#endif 886 case VG_STROKE_CAP_STYLE: 887 case VG_STROKE_JOIN_STYLE: 888 case VG_STROKE_DASH_PHASE_RESET: 889 case VG_MASKING: 890 case VG_SCISSORING: 891 case VG_PIXEL_LAYOUT: 892 case VG_SCREEN_LAYOUT: 893 case VG_FILTER_FORMAT_LINEAR: 894 case VG_FILTER_FORMAT_PREMULTIPLIED: 895 case VG_FILTER_CHANNEL_MASK: 896 case VG_MAX_SCISSOR_RECTS: 897 case VG_MAX_DASH_COUNT: 898 case VG_MAX_KERNEL_SIZE: 899 case VG_MAX_SEPARABLE_KERNEL_SIZE: 900 case VG_MAX_COLOR_RAMP_STOPS: 901 case VG_MAX_IMAGE_WIDTH: 902 case VG_MAX_IMAGE_HEIGHT: 903 case VG_MAX_IMAGE_PIXELS: 904 case VG_MAX_IMAGE_BYTES: 905 case VG_MAX_GAUSSIAN_STD_DEVIATION: 906 values[0] = vgGeti(type); 907 break; 908 case VG_MAX_FLOAT: { 909 VGfloat val = vgGetf(type); 910 values[0] = float_to_int_floor(*((VGuint*)&val)); 911 } 912 break; 913 case VG_SCISSOR_RECTS: { 914 VGint i; 915 for (i = 0; i < count; ++i) { 916 values[i] = state->scissor_rects[i].i; 917 } 918 } 919 break; 920#ifdef OPENVG_VERSION_1_1 921 case VG_COLOR_TRANSFORM_VALUES: { 922 VGint i; 923 VGuint *x = (VGuint*)state->color_transform_values; 924 for (i = 0; i < count; ++i) { 925 values[i] = float_to_int_floor(x[i]); 926 } 927 } 928 break; 929#endif 930 case VG_STROKE_LINE_WIDTH: 931 values[0] = state->stroke.line_width.i; 932 break; 933 case VG_STROKE_MITER_LIMIT: 934 values[0] = state->stroke.miter_limit.i; 935 break; 936 case VG_STROKE_DASH_PATTERN: { 937 VGint i; 938 for (i = 0; i < count; ++i) { 939 values[i] = state->stroke.dash_pattern[i].i; 940 } 941 } 942 break; 943 case VG_STROKE_DASH_PHASE: 944 values[0] = state->stroke.dash_phase.i; 945 break; 946 case VG_TILE_FILL_COLOR: 947 values[0] = state->tile_fill_colori[0]; 948 values[1] = state->tile_fill_colori[1]; 949 values[2] = state->tile_fill_colori[2]; 950 values[3] = state->tile_fill_colori[3]; 951 break; 952 case VG_CLEAR_COLOR: 953 values[0] = state->clear_colori[0]; 954 values[1] = state->clear_colori[1]; 955 values[2] = state->clear_colori[2]; 956 values[3] = state->clear_colori[3]; 957 break; 958#ifdef OPENVG_VERSION_1_1 959 case VG_GLYPH_ORIGIN: 960 values[0] = state->glyph_origin[0].i; 961 values[1] = state->glyph_origin[1].i; 962 break; 963#endif 964 default: 965 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 966 break; 967 } 968} 969 970void vegaSetParameterf(VGHandle object, 971 VGint paramType, 972 VGfloat value) 973{ 974 struct vg_context *ctx = vg_current_context(); 975 void *ptr = (void*)object; 976 977 if (!object || object == VG_INVALID_HANDLE || !is_aligned(ptr)) { 978 vg_set_error(ctx, VG_BAD_HANDLE_ERROR); 979 return; 980 } 981 982 switch(paramType) { 983 case VG_PAINT_TYPE: 984 case VG_PAINT_COLOR_RAMP_SPREAD_MODE: 985 case VG_PAINT_PATTERN_TILING_MODE: 986 vgSetParameteri(object, paramType, floor(value)); 987 return; 988 break; 989 case VG_PAINT_COLOR: 990 case VG_PAINT_COLOR_RAMP_STOPS: 991 case VG_PAINT_LINEAR_GRADIENT: 992 case VG_PAINT_RADIAL_GRADIENT: 993 /* it's an error if paramType refers to a vector parameter */ 994 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 995 break; 996 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: { 997 struct vg_paint *p = (struct vg_paint *)object; 998 paint_set_color_ramp_premultiplied(p, value); 999 } 1000 break; 1001 1002 case VG_PATH_DATATYPE: 1003 case VG_PATH_FORMAT: 1004 case VG_PATH_SCALE: 1005 case VG_PATH_BIAS: 1006 case VG_PATH_NUM_SEGMENTS: 1007 case VG_PATH_NUM_COORDS: 1008 1009 case VG_IMAGE_FORMAT: 1010 case VG_IMAGE_WIDTH: 1011 case VG_IMAGE_HEIGHT: 1012 1013#ifdef OPENVG_VERSION_1_1 1014 case VG_FONT_NUM_GLYPHS: 1015 /* read only don't produce an error */ 1016 break; 1017#endif 1018 default: 1019 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1020 break; 1021 } 1022} 1023 1024void vegaSetParameteri(VGHandle object, 1025 VGint paramType, 1026 VGint value) 1027{ 1028 struct vg_context *ctx = vg_current_context(); 1029 void *ptr = (void*)object; 1030 1031 if (!object || object == VG_INVALID_HANDLE || !is_aligned(ptr)) { 1032 vg_set_error(ctx, VG_BAD_HANDLE_ERROR); 1033 return; 1034 } 1035 1036 switch(paramType) { 1037 case VG_PAINT_TYPE: 1038 if (value < VG_PAINT_TYPE_COLOR || 1039 value > VG_PAINT_TYPE_PATTERN) 1040 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1041 else { 1042 struct vg_paint *paint = (struct vg_paint *)ptr; 1043 paint_set_type(paint, value); 1044 } 1045 break; 1046 case VG_PAINT_COLOR: 1047 case VG_PAINT_COLOR_RAMP_STOPS: 1048 case VG_PAINT_LINEAR_GRADIENT: 1049 case VG_PAINT_RADIAL_GRADIENT: 1050 /* it's an error if paramType refers to a vector parameter */ 1051 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1052 break; 1053 case VG_PAINT_COLOR_RAMP_SPREAD_MODE: 1054 if (value < VG_COLOR_RAMP_SPREAD_PAD || 1055 value > VG_COLOR_RAMP_SPREAD_REFLECT) 1056 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1057 else { 1058 struct vg_paint *paint = (struct vg_paint *)ptr; 1059 paint_set_spread_mode(paint, value); 1060 } 1061 break; 1062 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: { 1063 struct vg_paint *p = (struct vg_paint *)object; 1064 paint_set_color_ramp_premultiplied(p, value); 1065 } 1066 break; 1067 case VG_PAINT_PATTERN_TILING_MODE: 1068 if (value < VG_TILE_FILL || 1069 value > VG_TILE_REFLECT) 1070 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1071 else { 1072 struct vg_paint *paint = (struct vg_paint *)ptr; 1073 paint_set_pattern_tiling(paint, value); 1074 } 1075 break; 1076 1077 case VG_PATH_DATATYPE: 1078 case VG_PATH_FORMAT: 1079 case VG_PATH_SCALE: 1080 case VG_PATH_BIAS: 1081 case VG_PATH_NUM_SEGMENTS: 1082 case VG_PATH_NUM_COORDS: 1083 1084 case VG_IMAGE_FORMAT: 1085 case VG_IMAGE_WIDTH: 1086 case VG_IMAGE_HEIGHT: 1087 1088#ifdef OPENVG_VERSION_1_1 1089 case VG_FONT_NUM_GLYPHS: 1090 /* read only don't produce an error */ 1091 break; 1092#endif 1093 default: 1094 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1095 return; 1096 } 1097} 1098 1099void vegaSetParameterfv(VGHandle object, 1100 VGint paramType, 1101 VGint count, 1102 const VGfloat * values) 1103{ 1104 struct vg_context *ctx = vg_current_context(); 1105 void *ptr = (void*)object; 1106 VGint real_count = vgGetParameterVectorSize(object, paramType); 1107 1108 if (!object || object == VG_INVALID_HANDLE || !is_aligned(ptr)) { 1109 vg_set_error(ctx, VG_BAD_HANDLE_ERROR); 1110 return; 1111 } 1112 1113 if (count < 0 || count < real_count || 1114 (values == NULL && count != 0) || 1115 !is_aligned(values)) { 1116 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1117 return; 1118 } 1119 1120 switch(paramType) { 1121 case VG_PAINT_TYPE: 1122 case VG_PAINT_COLOR_RAMP_SPREAD_MODE: 1123 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: 1124 case VG_PAINT_PATTERN_TILING_MODE: 1125 if (count != 1) 1126 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1127 else 1128 vgSetParameterf(object, paramType, values[0]); 1129 return; 1130 break; 1131 case VG_PAINT_COLOR: { 1132 if (count != 4) 1133 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1134 else { 1135 struct vg_paint *paint = (struct vg_paint *)object; 1136 paint_set_color(paint, values); 1137 } 1138 } 1139 break; 1140 case VG_PAINT_COLOR_RAMP_STOPS: { 1141 if (count && count < 4) 1142 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1143 else { 1144 struct vg_paint *paint = (struct vg_paint *)object; 1145 count = MIN2(count, VEGA_MAX_COLOR_RAMP_STOPS); 1146 paint_set_ramp_stops(paint, values, count); 1147 { 1148 VGint stopsi[VEGA_MAX_COLOR_RAMP_STOPS]; 1149 int i = 0; 1150 for (i = 0; i < count; ++i) { 1151 stopsi[i] = float_to_int_floor(*((VGuint*)(values + i))); 1152 } 1153 paint_set_ramp_stopsi(paint, stopsi, count); 1154 } 1155 } 1156 } 1157 break; 1158 case VG_PAINT_LINEAR_GRADIENT: { 1159 if (count != 4) 1160 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1161 else { 1162 struct vg_paint *paint = (struct vg_paint *)object; 1163 paint_set_linear_gradient(paint, values); 1164 { 1165 VGint vals[4]; 1166 vals[0] = FLT_TO_INT(values[0]); 1167 vals[1] = FLT_TO_INT(values[1]); 1168 vals[2] = FLT_TO_INT(values[2]); 1169 vals[3] = FLT_TO_INT(values[3]); 1170 paint_set_linear_gradienti(paint, vals); 1171 } 1172 } 1173 } 1174 break; 1175 case VG_PAINT_RADIAL_GRADIENT: { 1176 if (count != 5) 1177 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1178 else { 1179 struct vg_paint *paint = (struct vg_paint *)object; 1180 paint_set_radial_gradient(paint, values); 1181 { 1182 VGint vals[5]; 1183 vals[0] = FLT_TO_INT(values[0]); 1184 vals[1] = FLT_TO_INT(values[1]); 1185 vals[2] = FLT_TO_INT(values[2]); 1186 vals[3] = FLT_TO_INT(values[3]); 1187 vals[4] = FLT_TO_INT(values[4]); 1188 paint_set_radial_gradienti(paint, vals); 1189 } 1190 } 1191 } 1192 break; 1193 1194 case VG_PATH_DATATYPE: 1195 case VG_PATH_FORMAT: 1196 case VG_PATH_SCALE: 1197 case VG_PATH_BIAS: 1198 case VG_PATH_NUM_SEGMENTS: 1199 case VG_PATH_NUM_COORDS: 1200 1201#ifdef OPENVG_VERSION_1_1 1202 case VG_FONT_NUM_GLYPHS: 1203 /* read only don't produce an error */ 1204 break; 1205#endif 1206 default: 1207 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1208 return; 1209 } 1210} 1211 1212void vegaSetParameteriv(VGHandle object, 1213 VGint paramType, 1214 VGint count, 1215 const VGint * values) 1216{ 1217 struct vg_context *ctx = vg_current_context(); 1218 void *ptr = (void*)object; 1219 VGint real_count = vgGetParameterVectorSize(object, paramType); 1220 1221 if (!object || object == VG_INVALID_HANDLE || !is_aligned(ptr)) { 1222 vg_set_error(ctx, VG_BAD_HANDLE_ERROR); 1223 return; 1224 } 1225 1226 if (count < 0 || count < real_count || 1227 (values == NULL && count != 0) || 1228 !is_aligned(values)) { 1229 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1230 return; 1231 } 1232 1233 switch(paramType) { 1234 case VG_PAINT_TYPE: 1235 case VG_PAINT_COLOR_RAMP_SPREAD_MODE: 1236 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: 1237 case VG_PAINT_PATTERN_TILING_MODE: 1238 if (count != 1) 1239 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1240 else 1241 vgSetParameteri(object, paramType, values[0]); 1242 return; 1243 break; 1244 case VG_PAINT_COLOR: { 1245 if (count != 4) 1246 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1247 else { 1248 struct vg_paint *paint = (struct vg_paint *)object; 1249 paint_set_coloriv(paint, values); 1250 } 1251 } 1252 break; 1253 case VG_PAINT_COLOR_RAMP_STOPS: { 1254 if ((count % 5)) 1255 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1256 else { 1257 VGfloat *vals = 0; 1258 int i; 1259 struct vg_paint *paint = (struct vg_paint *)object; 1260 if (count) { 1261 vals = malloc(sizeof(VGfloat)*count); 1262 for (i = 0; i < count; ++i) 1263 vals[i] = values[i]; 1264 } 1265 1266 paint_set_ramp_stopsi(paint, values, count); 1267 paint_set_ramp_stops(paint, vals, count); 1268 free(vals); 1269 } 1270 } 1271 break; 1272 case VG_PAINT_LINEAR_GRADIENT: { 1273 if (count != 4) 1274 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1275 else { 1276 VGfloat vals[4]; 1277 struct vg_paint *paint = (struct vg_paint *)object; 1278 vals[0] = values[0]; 1279 vals[1] = values[1]; 1280 vals[2] = values[2]; 1281 vals[3] = values[3]; 1282 paint_set_linear_gradient(paint, vals); 1283 paint_set_linear_gradienti(paint, values); 1284 } 1285 } 1286 break; 1287 case VG_PAINT_RADIAL_GRADIENT: { 1288 if (count != 5) 1289 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1290 else { 1291 VGfloat vals[5]; 1292 struct vg_paint *paint = (struct vg_paint *)object; 1293 vals[0] = values[0]; 1294 vals[1] = values[1]; 1295 vals[2] = values[2]; 1296 vals[3] = values[3]; 1297 vals[4] = values[4]; 1298 paint_set_radial_gradient(paint, vals); 1299 paint_set_radial_gradienti(paint, values); 1300 } 1301 } 1302 break; 1303 case VG_PATH_DATATYPE: 1304 case VG_PATH_FORMAT: 1305 case VG_PATH_SCALE: 1306 case VG_PATH_BIAS: 1307 case VG_PATH_NUM_SEGMENTS: 1308 case VG_PATH_NUM_COORDS: 1309 /* read only don't produce an error */ 1310 break; 1311 default: 1312 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1313 return; 1314 } 1315} 1316 1317VGint vegaGetParameterVectorSize(VGHandle object, 1318 VGint paramType) 1319{ 1320 struct vg_context *ctx = vg_current_context(); 1321 void *ptr = (void*)object; 1322 1323 if (!ptr || object == VG_INVALID_HANDLE) { 1324 vg_set_error(ctx, VG_BAD_HANDLE_ERROR); 1325 return 0; 1326 } 1327 1328 switch(paramType) { 1329 case VG_PAINT_TYPE: 1330 case VG_PAINT_COLOR_RAMP_SPREAD_MODE: 1331 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: 1332 case VG_PAINT_PATTERN_TILING_MODE: 1333 return 1; 1334 case VG_PAINT_COLOR: 1335 return 4; 1336 case VG_PAINT_COLOR_RAMP_STOPS: { 1337 struct vg_paint *p = (struct vg_paint *)object; 1338 return paint_num_ramp_stops(p); 1339 } 1340 break; 1341 case VG_PAINT_LINEAR_GRADIENT: 1342 return 4; 1343 case VG_PAINT_RADIAL_GRADIENT: 1344 return 5; 1345 1346 1347 case VG_PATH_FORMAT: 1348 case VG_PATH_DATATYPE: 1349 case VG_PATH_SCALE: 1350 case VG_PATH_BIAS: 1351 case VG_PATH_NUM_SEGMENTS: 1352 case VG_PATH_NUM_COORDS: 1353 return 1; 1354 1355 case VG_IMAGE_FORMAT: 1356 case VG_IMAGE_WIDTH: 1357 case VG_IMAGE_HEIGHT: 1358 return 1; 1359 1360#ifdef OPENVG_VERSION_1_1 1361 case VG_FONT_NUM_GLYPHS: 1362 return 1; 1363#endif 1364 1365 default: 1366 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1367 break; 1368 } 1369 return 0; 1370} 1371 1372 1373VGfloat vegaGetParameterf(VGHandle object, 1374 VGint paramType) 1375{ 1376 struct vg_context *ctx = vg_current_context(); 1377 void *ptr = (void*)object; 1378 1379 if (!ptr || object == VG_INVALID_HANDLE) { 1380 vg_set_error(ctx, VG_BAD_HANDLE_ERROR); 1381 return 0; 1382 } 1383 1384 switch(paramType) { 1385 case VG_PAINT_TYPE: 1386 case VG_PAINT_COLOR_RAMP_SPREAD_MODE: 1387 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: 1388 case VG_PAINT_PATTERN_TILING_MODE: 1389 return vgGetParameteri(object, paramType); 1390 break; 1391 case VG_PAINT_COLOR: 1392 case VG_PAINT_COLOR_RAMP_STOPS: 1393 case VG_PAINT_LINEAR_GRADIENT: 1394 case VG_PAINT_RADIAL_GRADIENT: 1395 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1396 break; 1397 1398 case VG_PATH_FORMAT: 1399 return VG_PATH_FORMAT_STANDARD; 1400 case VG_PATH_SCALE: { 1401 struct path *p = (struct path*)object; 1402 return path_scale(p); 1403 } 1404 case VG_PATH_BIAS: { 1405 struct path *p = (struct path*)object; 1406 return path_bias(p); 1407 } 1408 case VG_PATH_DATATYPE: 1409 case VG_PATH_NUM_SEGMENTS: 1410 case VG_PATH_NUM_COORDS: 1411 return vgGetParameteri(object, paramType); 1412 break; 1413 1414 case VG_IMAGE_FORMAT: 1415 case VG_IMAGE_WIDTH: 1416 case VG_IMAGE_HEIGHT: 1417#ifdef OPENVG_VERSION_1_1 1418 case VG_FONT_NUM_GLYPHS: 1419 return vgGetParameteri(object, paramType); 1420 break; 1421#endif 1422 1423 default: 1424 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1425 break; 1426 } 1427 return 0; 1428} 1429 1430VGint vegaGetParameteri(VGHandle object, 1431 VGint paramType) 1432{ 1433 struct vg_context *ctx = vg_current_context(); 1434 void *ptr = (void*)object; 1435 1436 if (!ptr || object == VG_INVALID_HANDLE) { 1437 vg_set_error(ctx, VG_BAD_HANDLE_ERROR); 1438 return 0; 1439 } 1440 1441 switch(paramType) { 1442 case VG_PAINT_TYPE: { 1443 struct vg_paint *paint = (struct vg_paint *)ptr; 1444 return paint_type(paint); 1445 } 1446 break; 1447 case VG_PAINT_COLOR_RAMP_SPREAD_MODE: { 1448 struct vg_paint *p = (struct vg_paint *)object; 1449 return paint_spread_mode(p); 1450 } 1451 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: { 1452 struct vg_paint *p = (struct vg_paint *)object; 1453 return paint_color_ramp_premultiplied(p); 1454 } 1455 break; 1456 case VG_PAINT_PATTERN_TILING_MODE: { 1457 struct vg_paint *p = (struct vg_paint *)object; 1458 return paint_pattern_tiling(p); 1459 } 1460 break; 1461 case VG_PAINT_COLOR: 1462 case VG_PAINT_COLOR_RAMP_STOPS: 1463 case VG_PAINT_LINEAR_GRADIENT: 1464 case VG_PAINT_RADIAL_GRADIENT: 1465 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1466 break; 1467 1468 case VG_PATH_FORMAT: 1469 return VG_PATH_FORMAT_STANDARD; 1470 case VG_PATH_SCALE: 1471 case VG_PATH_BIAS: 1472 return vgGetParameterf(object, paramType); 1473 case VG_PATH_DATATYPE: { 1474 struct path *p = (struct path*)object; 1475 return path_datatype(p); 1476 } 1477 case VG_PATH_NUM_SEGMENTS: { 1478 struct path *p = (struct path*)object; 1479 return path_num_segments(p); 1480 } 1481 case VG_PATH_NUM_COORDS: { 1482 struct path *p = (struct path*)object; 1483 return path_num_coords(p); 1484 } 1485 break; 1486 1487 case VG_IMAGE_FORMAT: { 1488 struct vg_image *img = (struct vg_image*)object; 1489 return img->format; 1490 } 1491 break; 1492 case VG_IMAGE_WIDTH: { 1493 struct vg_image *img = (struct vg_image*)object; 1494 return img->width; 1495 } 1496 break; 1497 case VG_IMAGE_HEIGHT: { 1498 struct vg_image *img = (struct vg_image*)object; 1499 return img->height; 1500 } 1501 break; 1502 1503#ifdef OPENVG_VERSION_1_1 1504 case VG_FONT_NUM_GLYPHS: { 1505 struct vg_font *font = (struct vg_font*)object; 1506 return font_num_glyphs(font); 1507 } 1508 break; 1509#endif 1510 1511 default: 1512 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1513 break; 1514 } 1515 return 0; 1516} 1517 1518void vegaGetParameterfv(VGHandle object, 1519 VGint paramType, 1520 VGint count, 1521 VGfloat * values) 1522{ 1523 struct vg_context *ctx = vg_current_context(); 1524 void *ptr = (void*)object; 1525 VGint real_count = vgGetParameterVectorSize(object, paramType); 1526 1527 if (!ptr || object == VG_INVALID_HANDLE) { 1528 vg_set_error(ctx, VG_BAD_HANDLE_ERROR); 1529 return; 1530 } 1531 1532 if (!values || count <= 0 || count > real_count || 1533 !is_aligned(values)) { 1534 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1535 return; 1536 } 1537 1538 switch(paramType) { 1539 case VG_PAINT_TYPE: { 1540 struct vg_paint *p = (struct vg_paint *)object; 1541 values[0] = paint_type(p); 1542 } 1543 break; 1544 case VG_PAINT_COLOR_RAMP_SPREAD_MODE: { 1545 struct vg_paint *p = (struct vg_paint *)object; 1546 values[0] = paint_spread_mode(p); 1547 } 1548 break; 1549 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: { 1550 struct vg_paint *p = (struct vg_paint *)object; 1551 values[0] = paint_color_ramp_premultiplied(p); 1552 } 1553 break; 1554 case VG_PAINT_PATTERN_TILING_MODE: { 1555 values[0] = vgGetParameterf(object, paramType); 1556 } 1557 break; 1558 case VG_PAINT_COLOR: { 1559 struct vg_paint *paint = (struct vg_paint *)object; 1560 paint_get_color(paint, values); 1561 } 1562 break; 1563 case VG_PAINT_COLOR_RAMP_STOPS: { 1564 struct vg_paint *paint = (struct vg_paint *)object; 1565 paint_ramp_stops(paint, values, count); 1566 } 1567 break; 1568 case VG_PAINT_LINEAR_GRADIENT: { 1569 struct vg_paint *paint = (struct vg_paint *)object; 1570 paint_linear_gradient(paint, values); 1571 } 1572 break; 1573 case VG_PAINT_RADIAL_GRADIENT: { 1574 struct vg_paint *paint = (struct vg_paint *)object; 1575 paint_radial_gradient(paint, values); 1576 } 1577 break; 1578 1579 case VG_PATH_FORMAT: 1580 case VG_PATH_DATATYPE: 1581 case VG_PATH_NUM_SEGMENTS: 1582 case VG_PATH_NUM_COORDS: 1583 values[0] = vgGetParameteri(object, paramType); 1584 break; 1585 case VG_PATH_SCALE: 1586 case VG_PATH_BIAS: 1587 values[0] = vgGetParameterf(object, paramType); 1588 break; 1589 1590 case VG_IMAGE_FORMAT: 1591 case VG_IMAGE_WIDTH: 1592 case VG_IMAGE_HEIGHT: 1593#ifdef OPENVG_VERSION_1_1 1594 case VG_FONT_NUM_GLYPHS: 1595 values[0] = vgGetParameteri(object, paramType); 1596 break; 1597#endif 1598 1599 default: 1600 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1601 break; 1602 } 1603} 1604 1605void vegaGetParameteriv(VGHandle object, 1606 VGint paramType, 1607 VGint count, 1608 VGint * values) 1609{ 1610 struct vg_context *ctx = vg_current_context(); 1611 void *ptr = (void*)object; 1612 VGint real_count = vgGetParameterVectorSize(object, paramType); 1613 1614 if (!ptr || object == VG_INVALID_HANDLE) { 1615 vg_set_error(ctx, VG_BAD_HANDLE_ERROR); 1616 return; 1617 } 1618 1619 if (!values || count <= 0 || count > real_count || 1620 !is_aligned(values)) { 1621 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1622 return; 1623 } 1624 1625 switch(paramType) { 1626 case VG_PAINT_TYPE: 1627 case VG_PAINT_COLOR_RAMP_SPREAD_MODE: 1628 case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: 1629 case VG_PAINT_PATTERN_TILING_MODE: 1630#ifdef OPENVG_VERSION_1_1 1631 case VG_FONT_NUM_GLYPHS: 1632 values[0] = vgGetParameteri(object, paramType); 1633 break; 1634#endif 1635 case VG_PAINT_COLOR: { 1636 struct vg_paint *paint = (struct vg_paint *)object; 1637 paint_get_coloriv(paint, values); 1638 } 1639 break; 1640 case VG_PAINT_COLOR_RAMP_STOPS: { 1641 struct vg_paint *paint = (struct vg_paint *)object; 1642 paint_ramp_stopsi(paint, values, count); 1643 } 1644 break; 1645 case VG_PAINT_LINEAR_GRADIENT: { 1646 struct vg_paint *paint = (struct vg_paint *)object; 1647 paint_linear_gradienti(paint, values); 1648 } 1649 break; 1650 case VG_PAINT_RADIAL_GRADIENT: { 1651 struct vg_paint *paint = (struct vg_paint *)object; 1652 paint_radial_gradienti(paint, values); 1653 } 1654 break; 1655 1656 case VG_PATH_SCALE: 1657 case VG_PATH_BIAS: 1658 values[0] = vgGetParameterf(object, paramType); 1659 break; 1660 case VG_PATH_FORMAT: 1661 case VG_PATH_DATATYPE: 1662 case VG_PATH_NUM_SEGMENTS: 1663 case VG_PATH_NUM_COORDS: 1664 values[0] = vgGetParameteri(object, paramType); 1665 break; 1666 1667 case VG_IMAGE_FORMAT: 1668 case VG_IMAGE_WIDTH: 1669 case VG_IMAGE_HEIGHT: 1670 values[0] = vgGetParameteri(object, paramType); 1671 break; 1672 1673 default: 1674 vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); 1675 break; 1676 } 1677} 1678