自学教程：C++ vg_set_error函数代码示例

void vegaSetGlyphToPath(VGFont font,                        VGuint glyphIndex,                        VGPath path,                        VGboolean isHinted,                        const VGfloat glyphOrigin[2],                        const VGfloat escapement[2]){   struct vg_context *ctx = vg_current_context();   struct path *pathObj;   struct vg_font *f;   if (font == VG_INVALID_HANDLE ||       !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, (void *)font)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (!glyphOrigin || !escapement ||       !is_aligned(glyphOrigin) || !is_aligned(escapement)) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (path != VG_INVALID_HANDLE &&       !vg_context_is_object_valid(ctx, VG_OBJECT_PATH, (void *)path)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   pathObj = (struct path*) path;   f = (struct vg_font*) font;   font_set_glyph_to_path(f, glyphIndex, pathObj,         isHinted, glyphOrigin, escapement);}

void vegaSetGlyphToImage(VGFont font,                         VGuint glyphIndex,                         VGImage image,                         const VGfloat glyphOrigin[2],                         const VGfloat escapement[2]){   struct vg_context *ctx = vg_current_context();   struct vg_image *img_obj;   struct vg_font *f;   if (font == VG_INVALID_HANDLE ||       !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, (void *)font)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (!glyphOrigin || !escapement ||       !is_aligned(glyphOrigin) || !is_aligned(escapement)) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (image != VG_INVALID_HANDLE &&       !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, (void *)image)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   img_obj = (struct vg_image*)image;   f = (struct vg_font*)font;   font_set_glyph_to_image(f, glyphIndex, img_obj, glyphOrigin, escapement);}

void vgDrawGlyph(VGFont font,                 VGuint glyphIndex,                 VGbitfield paintModes,                 VGboolean allowAutoHinting){   struct vg_context *ctx = vg_current_context();   struct vg_font *f;   if (font == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (glyphIndex <= 0) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (paintModes & (~(VG_STROKE_PATH|VG_FILL_PATH))) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   f = (struct vg_font*)font;   if (!font_contains_glyph(f, glyphIndex)) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }}

VGfloat vgPathLength(VGPath path,                     VGint startSegment,                     VGint numSegments){   struct vg_context *ctx = vg_current_context();   struct path *p = 0;   if (path == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return -1;   }   if (startSegment < 0) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return -1;   }   if (numSegments <= 0) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return -1;   }   p = (struct path*)path;   if (!(path_capabilities(p) & VG_PATH_CAPABILITY_PATH_LENGTH)) {      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);      return -1;   }   if (startSegment + numSegments > path_num_segments(p)) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return -1;   }   return path_length(p, startSegment, numSegments);}

VGImage vgChildImage(VGImage parent,                     VGint x, VGint y,                     VGint width, VGint height){   struct vg_context *ctx = vg_current_context();   struct vg_image *p;   if (parent == VG_INVALID_HANDLE ||       !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, (void*)parent) ||       !vg_object_is_valid((void*)parent, VG_OBJECT_IMAGE)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return VG_INVALID_HANDLE;   }   if (width <= 0 || height <= 0 || x < 0 || y < 0) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return VG_INVALID_HANDLE;   }   p = (struct vg_image *)parent;   if (x > p->width  || y > p->height) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return VG_INVALID_HANDLE;   }   if (x + width > p->width  || y + height > p->height) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return VG_INVALID_HANDLE;   }   return (VGImage)image_child_image(p, x, y, width, height);}

void vgClearGlyph(VGFont font,                  VGuint glyphIndex){   struct vg_context *ctx = vg_current_context();   struct vg_font *f;   VGint i;   if (font == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (glyphIndex <= 0) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   f = (struct vg_font*)font;   if (!font_contains_glyph(f, glyphIndex)) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   for (i = 0; i < f->num_glyphs; ++i) {      if (f->glyph_indices[i] == glyphIndex) {         /*FIXME*/         f->glyph_indices[f->num_glyphs] = 0;         --f->num_glyphs;         return;      }   }}

void vegaMask(VGHandle mask, VGMaskOperation operation,              VGint x, VGint y,              VGint width, VGint height){   struct vg_context *ctx = vg_current_context();   if (width <=0 || height <= 0) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (operation < VG_CLEAR_MASK || operation > VG_SUBTRACT_MASK) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   vg_validate_state(ctx);   if (operation == VG_CLEAR_MASK) {      mask_fill(x, y, width, height, 0.f);   } else if (operation == VG_FILL_MASK) {      mask_fill(x, y, width, height, 1.f);   } else if (vg_object_is_valid(mask, VG_OBJECT_IMAGE)) {      struct vg_image *image = handle_to_image(mask);      mask_using_image(image, operation, x, y, width, height);   } else if (vg_object_is_valid(mask, VG_OBJECT_MASK)) {      struct vg_mask_layer *layer = handle_to_masklayer(mask);      mask_using_layer(layer, operation, x, y, width, height);   } else {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);   }}

VGImage vgCreateImage(VGImageFormat format,                      VGint width, VGint height,                      VGbitfield allowedQuality){   struct vg_context *ctx = vg_current_context();   if (!supported_image_format(format)) {      vg_set_error(ctx, VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);      return VG_INVALID_HANDLE;   }   if (width <= 0 || height <= 0) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return VG_INVALID_HANDLE;   }   if (width > vgGeti(VG_MAX_IMAGE_WIDTH) ||       height > vgGeti(VG_MAX_IMAGE_HEIGHT)) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return VG_INVALID_HANDLE;   }   if (width * height > vgGeti(VG_MAX_IMAGE_PIXELS)) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return VG_INVALID_HANDLE;   }   if (!(allowedQuality & ((VG_IMAGE_QUALITY_NONANTIALIASED |                           VG_IMAGE_QUALITY_FASTER |                           VG_IMAGE_QUALITY_BETTER)))) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return VG_INVALID_HANDLE;   }   return (VGImage)image_create(format, width, height);}

VGPath vgCreatePath(VGint pathFormat,                    VGPathDatatype datatype,                    VGfloat scale, VGfloat bias,                    VGint segmentCapacityHint,                    VGint coordCapacityHint,                    VGbitfield capabilities){   struct vg_context *ctx = vg_current_context();   if (pathFormat != VG_PATH_FORMAT_STANDARD) {      vg_set_error(ctx, VG_UNSUPPORTED_PATH_FORMAT_ERROR);      return VG_INVALID_HANDLE;   }   if (datatype < VG_PATH_DATATYPE_S_8 ||       datatype > VG_PATH_DATATYPE_F) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return VG_INVALID_HANDLE;   }   if (!scale) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return VG_INVALID_HANDLE;   }   return (VGPath)path_create(datatype, scale, bias,                              segmentCapacityHint, coordCapacityHint,                              capabilities);}

void vegaCopyMask(VGMaskLayer maskLayer,                  VGint sx, VGint sy,                  VGint dx, VGint dy,                  VGint width, VGint height){   struct vg_context *ctx = vg_current_context();   struct vg_mask_layer *mask = 0;   if (maskLayer == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (width <= 0 || height <= 0) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   vg_validate_state(ctx);   mask = handle_to_masklayer(maskLayer);   mask_copy(mask, sx, sy, dx, dy, width, height);}

void vegaRenderToMask(VGPath path,                      VGbitfield paintModes,                      VGMaskOperation operation){   struct vg_context *ctx = vg_current_context();   if (path == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (!paintModes || (paintModes&(~(VG_STROKE_PATH|VG_FILL_PATH)))) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (operation < VG_CLEAR_MASK ||       operation > VG_SUBTRACT_MASK) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (!vg_object_is_valid(path, VG_OBJECT_PATH)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   vg_validate_state(ctx);   mask_render_to(handle_to_path(path), paintModes, operation);}

void vegaColorMatrix(VGImage dst, VGImage src,                     const VGfloat * matrix){   struct vg_context *ctx = vg_current_context();   struct vg_image *d, *s;   struct filter_info info;   if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (!matrix || !is_aligned(matrix)) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   d = handle_to_image(dst);   s = handle_to_image(src);   if (vg_image_overlaps(d, s)) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   info.dst = d;   info.src = s;   info.setup_shader = &setup_color_matrix;   info.user_data = NULL;   info.const_buffer = matrix;   info.const_buffer_len = 20 * sizeof(VGfloat);   info.tiling_mode = VG_TILE_PAD;   info.extra_texture_view = NULL;   execute_filter(ctx, &info);}

void vegaPaintPattern(VGPaint paint, VGImage pattern){   struct vg_context *ctx = vg_current_context();   if (paint == VG_INVALID_HANDLE ||       !vg_context_is_object_valid(ctx, VG_OBJECT_PAINT, (void *)paint)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (pattern == VG_INVALID_HANDLE) {      paint_set_type((struct vg_paint*)paint, VG_PAINT_TYPE_COLOR);      return;   }   if (!vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, (void *)pattern)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (!vg_object_is_valid((void*)paint, VG_OBJECT_PAINT) ||       !vg_object_is_valid((void*)pattern, VG_OBJECT_IMAGE)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   paint_set_pattern((struct vg_paint*)paint,                     (struct vg_image*)pattern);}

VGboolean vgInterpolatePath(VGPath dstPath,                            VGPath startPath,                            VGPath endPath,                            VGfloat amount){   struct vg_context *ctx = vg_current_context();   struct path *start = 0, *dst = 0, *end = 0;   if (dstPath == VG_INVALID_HANDLE ||       startPath == VG_INVALID_HANDLE ||       endPath == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return VG_FALSE;   }   dst = (struct path *)dstPath;   start = (struct path *)startPath;   end = (struct path *)endPath;   if (!(path_capabilities(dst) & VG_PATH_CAPABILITY_INTERPOLATE_TO) ||       !(path_capabilities(start) & VG_PATH_CAPABILITY_INTERPOLATE_FROM) ||       !(path_capabilities(end) & VG_PATH_CAPABILITY_INTERPOLATE_FROM)) {      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);      return VG_FALSE;   }   return path_interpolate(dst,                           start, end, amount);}

void image_sub_data(struct vg_image *image,                    const void * data,                    VGint dataStride,                    VGImageFormat dataFormat,                    VGint x, VGint y,                    VGint width, VGint height){   const VGint yStep = 1;   VGubyte *src = (VGubyte *)data;   VGfloat temp[VEGA_MAX_IMAGE_WIDTH][4];   VGfloat *df = (VGfloat*)temp;   VGint i;   struct vg_context *ctx = vg_current_context();   struct pipe_context *pipe = ctx->pipe;   struct pipe_resource *texture = image_texture(image);   VGint xoffset = 0, yoffset = 0;   if (x < 0) {      xoffset -= x;      width += x;      x = 0;   }   if (y < 0) {      yoffset -= y;      height += y;      y = 0;   }   if (width <= 0 || height <= 0) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (x > image->width || y > image->width) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (x + width > image->width) {      width = image->width - x;   }   if (y + height > image->height) {      height = image->height - y;   }   { /* upload color_data */      struct pipe_transfer *transfer = pipe_get_transfer(         pipe, texture, 0, 0,         PIPE_TRANSFER_WRITE, 0, 0, texture->width0, texture->height0);      src += (dataStride * yoffset);      for (i = 0; i < height; i++) {         _vega_unpack_float_span_rgba(ctx, width, xoffset, src, dataFormat, temp);         pipe_put_tile_rgba(pipe, transfer, x+image->x, y+image->y, width, 1, df);         y += yStep;         src += dataStride;      }      pipe->transfer_destroy(pipe, transfer);   }}

void vgModifyPathCoords(VGPath dstPath,                        VGint startIndex,                        VGint numSegments,                        const void * pathData){   struct vg_context *ctx = vg_current_context();   struct path *p = 0;   if (dstPath == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (startIndex < 0 || numSegments <= 0) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   p = (struct path *)dstPath;   if (!pathData || !is_aligned_to(pathData, path_datatype_size(p))) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (startIndex + numSegments > path_num_segments(p)) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (!(path_capabilities(p)&VG_PATH_CAPABILITY_MODIFY)) {      vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);      return;   }   path_modify_coords(p, startIndex, numSegments, pathData);}

void vgSetGlyphToImage(VGFont font,                       VGuint glyphIndex,                       VGImage image,                       VGfloat glyphOrigin [2],                       VGfloat escapement[2]){   struct vg_context *ctx = vg_current_context();   struct vg_object *img_obj;   struct vg_font *f;   if (font == VG_INVALID_HANDLE ||       !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, (void *)font)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (!glyphOrigin || !escapement ||       !is_aligned(glyphOrigin) || !is_aligned(escapement)) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (image != VG_INVALID_HANDLE &&       !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, (void *)image)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   img_obj = (struct vg_object*)image;   if (img_obj && img_obj->type != VG_OBJECT_IMAGE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   f = (struct vg_font*)font;   f->glyph_indices[f->num_glyphs] = glyphIndex;   ++f->num_glyphs;}

void vgGetImageSubData(VGImage image,                       void * data,                       VGint dataStride,                       VGImageFormat dataFormat,                       VGint x, VGint y,                       VGint width, VGint height){   struct vg_context *ctx = vg_current_context();   struct vg_image *img;   if (image == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (!supported_image_format(dataFormat)) {      vg_set_error(ctx, VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);      return;   }   if (width <= 0 || height <= 0 || !data || !is_aligned(data)) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   img = (struct vg_image*)image;   image_get_sub_data(img, data, dataStride, dataFormat,                      x, y, width, height);}

void vegaSetPaint(VGPaint paint, VGbitfield paintModes){   struct vg_context *ctx = vg_current_context();   if (paint == VG_INVALID_HANDLE) {      /* restore the default */      paint = paint_to_handle(ctx->default_paint);   } else if (!vg_object_is_valid(paint, VG_OBJECT_PAINT)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (!(paintModes & ((VG_FILL_PATH|VG_STROKE_PATH)))) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (paintModes & VG_FILL_PATH) {      ctx->state.vg.fill_paint = handle_to_paint(paint);   }   if (paintModes & VG_STROKE_PATH) {      ctx->state.vg.stroke_paint = handle_to_paint(paint);   }   ctx->state.dirty |= PAINT_DIRTY;}

void vegaLookup(VGImage dst, VGImage src,                const VGubyte * redLUT,                const VGubyte * greenLUT,                const VGubyte * blueLUT,                const VGubyte * alphaLUT,                VGboolean outputLinear,                VGboolean outputPremultiplied){   struct vg_context *ctx = vg_current_context();   struct vg_image *d, *s;   VGuint color_data[256];   VGint i;   struct pipe_sampler_view *lut_texture_view;   VGfloat buffer[4];   struct filter_info info;   if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (!redLUT || !greenLUT || !blueLUT || !alphaLUT) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   d = handle_to_image(dst);   s = handle_to_image(src);   if (vg_image_overlaps(d, s)) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   for (i = 0; i < 256; ++i) {      color_data[i] = blueLUT[i] << 24 | greenLUT[i] << 16 |                      redLUT[i]  <<  8 | alphaLUT[i];   }   lut_texture_view = create_texture_1d_view(ctx, color_data, 255);   buffer[0] = 0.f;   buffer[1] = 0.f;   buffer[2] = 1.f;   buffer[3] = 1.f;   info.dst = d;   info.src = s;   info.setup_shader = &setup_lookup;   info.user_data = NULL;   info.const_buffer = buffer;   info.const_buffer_len = 4 * sizeof(VGfloat);   info.tiling_mode = VG_TILE_PAD;   info.extra_texture_view = lut_texture_view;   execute_filter(ctx, &info);   pipe_sampler_view_reference(&lut_texture_view, NULL);}

void vgDestroyImage(VGImage image){   struct vg_context *ctx = vg_current_context();   struct vg_image *img = (struct vg_image *)image;   if (image == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (!vg_object_is_valid((void*)image, VG_OBJECT_IMAGE)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   image_destroy(img);}

void vegaDestroyFont(VGFont f){   struct vg_font *font = (struct vg_font *)f;   struct vg_context *ctx = vg_current_context();   if (f == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (!vg_object_is_valid((void *) font, VG_OBJECT_FONT)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   font_destroy(font);}

void font_draw_glyphs(struct vg_font *font,                      VGint glyphCount,                      const VGuint *glyphIndices,                      const VGfloat *adjustments_x,                      const VGfloat *adjustments_y,                      VGbitfield paintModes,                      VGboolean allowAutoHinting){   struct vg_context *ctx = vg_current_context();   VGint i;   for (i = 0; i < glyphCount; ++i) {      if (!get_glyph(font, glyphIndices[i])) {         vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);         return;      }   }   for (i = 0; i < glyphCount; ++i) {      struct vg_glyph *glyph;      VGfloat adj_x, adj_y;      glyph = get_glyph(font, glyphIndices[i]);      vg_render_glyph(ctx, glyph, paintModes, allowAutoHinting);      adj_x = (adjustments_x) ? adjustments_x[i] : 0.0f;      adj_y = (adjustments_y) ? adjustments_y[i] : 0.0f;      vg_advance_glyph(ctx, glyph, adj_x, adj_y, (i == glyphCount - 1));   }}

void vgCopyPixels(VGint dx, VGint dy,                  VGint sx, VGint sy,                  VGint width, VGint height){   struct vg_context *ctx = vg_current_context();   struct pipe_framebuffer_state *fb = &ctx->state.g3d.fb;   struct st_renderbuffer *strb = ctx->draw_buffer->strb;   if (width <= 0 || height <= 0) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   /* do nothing if we copy from outside the fb */   if (dx >= (VGint)fb->width || dy >= (VGint)fb->height ||       sx >= (VGint)fb->width || sy >= (VGint)fb->height)      return;   vg_validate_state(ctx);   /* make sure rendering has completed */   vgFinish();   vg_copy_surface(ctx, strb->surface, dx, dy,                   strb->surface, sx, sy, width, height);}

void vegaSeparableConvolve(VGImage dst, VGImage src,                           VGint kernelWidth,                           VGint kernelHeight,                           VGint shiftX, VGint shiftY,                           const VGshort * kernelX,                           const VGshort * kernelY,                           VGfloat scale,                           VGfloat bias,                           VGTilingMode tilingMode){   struct vg_context *ctx = vg_current_context();   VGshort *kernel;   VGint i, j, idx = 0;   const VGint max_kernel_size = vegaGeti(VG_MAX_SEPARABLE_KERNEL_SIZE);   if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (kernelWidth <= 0 || kernelHeight <= 0 ||       kernelWidth > max_kernel_size || kernelHeight > max_kernel_size) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (!kernelX || !kernelY ||       !is_aligned_to(kernelX, 2) || !is_aligned_to(kernelY, 2)) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (tilingMode < VG_TILE_FILL ||       tilingMode > VG_TILE_REFLECT) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   kernel = malloc(sizeof(VGshort)*kernelWidth*kernelHeight);   for (i = 0; i < kernelWidth; ++i) {      for (j = 0; j < kernelHeight; ++j) {         kernel[idx] = kernelX[i] * kernelY[j];         ++idx;      }   }   vegaConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY,                kernel, scale, bias, tilingMode);   free(kernel);}

void font_clear_glyph(struct vg_font *font,                      VGuint glyphIndex){   if (!del_glyph(font, glyphIndex)) {      struct vg_context *ctx = vg_current_context();      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);   }}

void vegaDestroyMaskLayer(VGMaskLayer maskLayer){   struct vg_mask_layer *mask = 0;   struct vg_context *ctx = vg_current_context();   if (maskLayer == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   mask = handle_to_masklayer(maskLayer);   mask_layer_destroy(mask);}

struct vg_context * vg_create_context(struct pipe_context *pipe,                                      const void *visual,                                      struct vg_context *share){   struct vg_context *ctx;   ctx = CALLOC_STRUCT(vg_context);   ctx->pipe = pipe;   if (!choose_depth_stencil_format(ctx)) {      FREE(ctx);      return NULL;   }   ctx->dispatch = api_create_dispatch();   vg_init_state(&ctx->state.vg);   ctx->state.dirty = ALL_DIRTY;   ctx->cso_context = cso_create_context(pipe);   ctx->default_paint = paint_create(ctx);   ctx->state.vg.stroke_paint = ctx->default_paint;   ctx->state.vg.fill_paint = ctx->default_paint;   ctx->mask.sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;   ctx->mask.sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;   ctx->mask.sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;   ctx->mask.sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;   ctx->mask.sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;   ctx->mask.sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;   ctx->mask.sampler.normalized_coords = 0;   ctx->blend_sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;   ctx->blend_sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;   ctx->blend_sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;   ctx->blend_sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;   ctx->blend_sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;   ctx->blend_sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;   ctx->blend_sampler.normalized_coords = 0;   vg_set_error(ctx, VG_NO_ERROR);   ctx->owned_objects[VG_OBJECT_PAINT] = cso_hash_create();   ctx->owned_objects[VG_OBJECT_IMAGE] = cso_hash_create();   ctx->owned_objects[VG_OBJECT_MASK] = cso_hash_create();   ctx->owned_objects[VG_OBJECT_FONT] = cso_hash_create();   ctx->owned_objects[VG_OBJECT_PATH] = cso_hash_create();   ctx->renderer = renderer_create(ctx);   ctx->sc = shaders_cache_create(ctx);   ctx->shader = shader_create(ctx);   ctx->blit = util_create_blit(ctx->pipe, ctx->cso_context);   return ctx;}

void vegaSetColor(VGPaint paint, VGuint rgba){   struct vg_context *ctx = vg_current_context();   if (paint == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (!vg_object_is_valid((void*)paint, VG_OBJECT_PAINT)) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   {      struct vg_paint *p = (struct vg_paint *)paint;      paint_set_colori(p, rgba);   }}

void vgDrawPath(VGPath path, VGbitfield paintModes){   struct vg_context *ctx = vg_current_context();   if (path == VG_INVALID_HANDLE) {      vg_set_error(ctx, VG_BAD_HANDLE_ERROR);      return;   }   if (!(paintModes & (VG_STROKE_PATH | VG_FILL_PATH))) {      vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);      return;   }   if (path_is_empty((struct path*)path))      return;   path_render((struct path*)path, paintModes);}