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