/* METH_O */ static PyObject * surface_write_to_png (PycairoSurface *o, PyObject *file) { cairo_status_t status; if (PyObject_TypeCheck (file, &PyBaseString_Type)) { /* string (filename) argument */ status = cairo_surface_write_to_png (o->surface, PyString_AsString(file)); } else { /* file or file-like object argument */ PyObject* writer = PyObject_GetAttrString (file, "write"); if (writer == NULL || !PyCallable_Check (writer)) { Py_XDECREF(writer); PyErr_SetString(PyExc_TypeError, "Surface.write_to_png takes one argument which must be a filename (str), file " "object, or a file-like object which has a \"write\" method (like StringIO)"); return NULL; } Py_DECREF(writer); status = cairo_surface_write_to_png_stream (o->surface, _write_func, file); } RETURN_NULL_IF_CAIRO_ERROR(status); Py_RETURN_NONE; }
static cairo_status_t write_png (cairo_surface_t *surface, const char *filename) { cairo_status_t status; FILE *png_file; if (filename != NULL) { png_file = fopen (filename, "wb"); if (png_file == NULL) { switch (errno) { case ENOMEM: return CAIRO_STATUS_NO_MEMORY; default: return CAIRO_STATUS_WRITE_ERROR; } } } else png_file = stdout; status = cairo_surface_write_to_png_stream (surface, stdio_write_func, png_file); if (png_file != stdout) fclose (png_file); return status; }
/* METH_O */ static PyObject * surface_write_to_png (PycairoSurface *o, PyObject *file) { FILE *fp; cairo_status_t status; if (PyObject_TypeCheck (file, &PyBaseString_Type)) { fp = fopen (PyString_AsString(file), "wb"); if (fp == NULL) { PyErr_SetString(PyExc_IOError, "unable to open file for writing"); return NULL; } } else if (PyObject_TypeCheck (file, &PyFile_Type)) { fp = PyFile_AsFile(file); } else { PyErr_SetString(PyExc_TypeError, "Surface.write_to_png takes one argument " "which must be a filename (str) or file object"); return NULL; } status = cairo_surface_write_to_png_stream (o->surface, _write_func, fp); if (PyObject_TypeCheck (file, &PyBaseString_Type)) fclose (fp); if (Pycairo_Check_Status (status)) return NULL; Py_RETURN_NONE; }
void XmlImageNode::writeOut(OutputStream* out) { XOJ_CHECK_TYPE(XmlImageNode); out->write("<"); out->write(tag); writeAttributes(out); out->write(">"); if (this->img == NULL) { g_error("XmlImageNode::writeOut(); this->img == NULL"); } else { this->out = out; this->pos = 0; cairo_surface_write_to_png_stream(this->img, (cairo_write_func_t) &pngWriteFunction, this); gchar* base64_str = g_base64_encode(this->buffer, this->pos); out->write(base64_str); g_free(base64_str); this->out = NULL; } out->write("</"); out->write(tag); out->write(">\n"); }
void CairoPainter::WriteImage(std::ostream& ofs) { if (!m_cairo || !m_surface) return; vector<char> in; cairo_surface_write_to_png_stream(m_surface, writeFunction, &in); for (unsigned int i = 0; i < in.size(); ++i) ofs << in.at(i); }
static void dumpBitmap(cairo_surface_t* surface, const char* checksum) { Vector<unsigned char> pixelData; cairo_surface_write_to_png_stream(surface, writeFunction, &pixelData); const size_t dataLength = pixelData.size(); const unsigned char* data = pixelData.data(); printPNG(data, dataLength, checksum); }
void TileSet::save(const std::wstring filename) { FILE *file; errno_t err; if ((err = _wfopen_s(&file, filename.c_str(), L"wb")) == 0) { cairo_surface_flush(surf); cairo_surface_write_to_png_stream(surf, cairo_write_to_file_cb, file); fclose(file); } }
static cairo_test_status_t test_cairo_surface_write_to_png_stream (cairo_surface_t *surface) { cairo_status_t status; status = cairo_surface_write_to_png_stream (surface, write_func_that_always_fails, NULL); return status && status != CAIRO_STATUS_WRITE_ERROR ? CAIRO_TEST_SUCCESS : CAIRO_TEST_ERROR; }
static svg_cairo_status_t write_surface_to_png_file (cairo_surface_t *surface, FILE *file) { cairo_status_t status; status = cairo_surface_write_to_png_stream (surface, write_callback, file); if (status) return SVG_CAIRO_STATUS_IO_ERROR; else return SVG_CAIRO_STATUS_SUCCESS; }
char* get_data_uri_by_surface(cairo_surface_t* surface) { __data_base64 = NULL; __data_size = 0; cairo_surface_write_to_png_stream(surface, (cairo_write_func_t)write_func, NULL); gchar* base64 = g_base64_encode(__data_base64, __data_size); g_free(__data_base64); char* ret = g_strconcat("data:image/png;base64,", base64, NULL); g_free(base64); return ret; }
void br_file_done(duc_graph *g) { struct cairo_backend_data *bd = g->backend_data; switch(bd->fmt) { case DUC_GRAPH_FORMAT_PNG: cairo_surface_write_to_png_stream(bd->cs, cairo_writer, bd->fout); break; default: break; } cairo_destroy(bd->cr); cairo_surface_destroy(bd->cs); }
static VALUE cr_surface_write_to_png_stream (VALUE self, VALUE target) { cairo_status_t status; cr_io_callback_closure_t closure; closure.target = target; closure.error = Qnil; status = cairo_surface_write_to_png_stream (_SELF, cr_surface_write_func, (void *)&closure); if (!NIL_P (closure.error)) rb_exc_raise (closure.error); rb_cairo_check_status (status); return self; }
String ImageBuffer::toDataURL(const String& mimeType) const { cairo_surface_t* image = cairo_get_target(context()->platformContext()); if (!image) return "data:,"; String actualMimeType("image/png"); if (MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType)) actualMimeType = mimeType; Vector<char> in; // Only PNG output is supported for now. cairo_surface_write_to_png_stream(image, writeFunction, &in); Vector<char> out; base64Encode(in, out); return "data:" + actualMimeType + ";base64," + String(out.data(), out.size()); }
/* Rasterise given SVG image into the PNG format. When dimensions (width and * height) are set to -1, than SVG view-box is used. If only height is set to * -1, then original aspect ratio is preserved and image is resized according * to the width parameter. Upon failure this function returns NULL. */ struct raster_png *raster_svg_to_png(const char *svg, unsigned int width, unsigned int height) { RsvgHandle *rsvg; RsvgDimensionData dimension; cairo_t *cr; cairo_surface_t *surface; cairo_matrix_t matrix; struct raster_png *png; if ((png = calloc(1, sizeof(*png))) == NULL) return NULL; if ((rsvg = rsvg_handle_new_from_data(svg, strlen(svg), NULL)) == NULL) { raster_png_free(png); return NULL; } /* initialize default dimensions based on the SVG view-box */ rsvg_handle_get_dimensions(rsvg, &dimension); if (width == -1) width = dimension.width; if (height == -1) height = round((double)(width * dimension.height) / dimension.width); /* scale SVG image according to the given dimensions */ cairo_matrix_init_scale(&matrix, (double)width / dimension.width, (double)height / dimension.height); surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height); cr = cairo_create(surface); cairo_set_matrix(cr, &matrix); /* draw our SVG data to the Cairo surface */ if (rsvg_handle_render_cairo(rsvg, cr)) cairo_surface_write_to_png_stream(surface, _png_write_callback, png); cairo_destroy(cr); cairo_surface_destroy(surface); g_object_unref(G_OBJECT(rsvg)); return png; }
static void cairogen_end_page(GVJ_t * job) { cairo_t *cr = (cairo_t *) job->context; cairo_surface_t *surface; cairo_status_t status; switch (job->render.id) { #ifdef CAIRO_HAS_PNG_FUNCTIONS case FORMAT_PNG: surface = cairo_get_target(cr); cairo_surface_write_to_png_stream(surface, writer, job); break; #endif case FORMAT_PS: case FORMAT_PDF: case FORMAT_SVG: cairo_show_page(cr); surface = cairo_surface_reference(cairo_get_target(cr)); cairo_surface_finish(surface); status = cairo_surface_status(surface); cairo_surface_destroy(surface); if (status != CAIRO_STATUS_SUCCESS) fprintf(stderr, "cairo: %s\n", cairo_status_to_string(status)); break; case FORMAT_CAIRO: default: surface = cairo_get_target(cr); if (cairo_image_surface_get_width(surface) == 0 || cairo_image_surface_get_height(surface) == 0) { /* apparently cairo never allocates a surface if nothing was ever written to it */ /* but suppress this error message since a zero area surface seems to happen during normal operations, particular in -Tx11 fprintf(stderr, "ERROR: cairo surface has zero area, this may indicate some problem during rendering shapes.\n"); - jce */ } job->imagedata = (char *)(cairo_image_surface_get_data(surface)); break; /* formatting will be done by gvdevice_format() */ } }
static void surface_print (cairo_surface_t *surface, GString * string) { #if CAIRO_HAS_PNG_FUNCTIONS GByteArray *array; char *base64; array = g_byte_array_new (); cairo_surface_write_to_png_stream (surface, surface_write, array); base64 = g_base64_encode (array->data, array->len); g_byte_array_free (array, TRUE); g_string_append (string, "url(\"data:image/png;base64,"); g_string_append (string, base64); g_string_append (string, "\")"); g_free (base64); #else g_string_append (string, "none /* you need cairo png functions enabled to make this work */"); #endif }
static void gtk_css_image_url_print (GtkCssImage *image, GString *string) { #if CAIRO_HAS_PNG_FUNCTIONS GtkCssImageUrl *url = GTK_CSS_IMAGE_URL (image); GByteArray *array; char *base64; array = g_byte_array_new (); cairo_surface_write_to_png_stream (url->surface, surface_write, array); base64 = g_base64_encode (array->data, array->len); g_byte_array_free (array, TRUE); g_string_append (string, "url(\"data:image/png;base64,"); g_string_append (string, base64); g_string_append (string, "\")"); g_free (base64); #else g_string_append (string, "none /* you need cairo png functions enabled to make this work */"); #endif }
static int surface_write_to_png (lua_State *L) { cairo_surface_t **obj = luaL_checkudata(L, 1, OOCAIRO_MT_NAME_SURFACE); int filetype = lua_type(L, 2); if (filetype == LUA_TSTRING || filetype == LUA_TNUMBER) { const char *filename = lua_tostring(L, 2); if (cairo_surface_write_to_png(*obj, filename) != CAIRO_STATUS_SUCCESS) return luaL_error(L, "error writing surface to PNG file '%s'", filename); } else if (filetype == LUA_TUSERDATA || filetype == LUA_TTABLE) { SurfaceUserdata info; init_surface_userdata(L, &info); lua_pushvalue(L, 2); info.fhref = luaL_ref(L, LUA_REGISTRYINDEX); if (cairo_surface_write_to_png_stream(*obj, write_chunk_to_fh, &info) != CAIRO_STATUS_SUCCESS) { lua_pushliteral(L, "error writing PNG file to Lua file handle"); if (info.errmsg) { lua_pushliteral(L, ": "); lua_pushstring(L, info.errmsg); lua_concat(L, 3); } free_surface_userdata(&info); return lua_error(L); } free_surface_userdata(&info); } else return luaL_typerror(L, 1, "filename or file handle object"); return 0; }
void gt_graphics_cairo_save_to_stream(const GtGraphics *gg, GtStr *stream) { const GtGraphicsCairo *g = (const GtGraphicsCairo*) gg; GT_UNUSED cairo_status_t rval; cairo_surface_t *bgsurf = NULL; cairo_t *bgc = NULL; gt_assert(g && stream); /* do nothing if no surface was created */ if (g->from_context) return; switch (g->type) { case GT_GRAPHICS_PNG: /* blend rendered image with background color */ bgsurf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, g->width, g->height); bgc = cairo_create(bgsurf); cairo_set_source_rgba(bgc, g->bg_color.red, g->bg_color.green, g->bg_color.blue, g->bg_color.alpha); cairo_paint(bgc); cairo_set_source_surface(bgc, g->surf, 0, 0); cairo_paint(bgc); rval = cairo_surface_write_to_png_stream(bgsurf, str_write_func, stream); gt_assert(rval == CAIRO_STATUS_SUCCESS); /* str_write_func() is sane */ cairo_destroy(bgc); cairo_surface_destroy(bgsurf); break; default: cairo_show_page(g->cr); cairo_surface_flush(g->surf); cairo_surface_finish(g->surf); gt_str_reset(stream); gt_str_append_str(stream, g->outbuf); gt_assert(gt_str_length(stream) > 0); } }
ETERM * write_to_png_stream(ETERM* arg, int c_node) { cairo_context * const ctx = get_cairo_context(arg); if(!ctx) return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT); struct png_data out = {}; const int status = cairo_surface_write_to_png_stream(ctx->sf, write_cb, &out); ETERM *term = NULL; ei_x_buff req; ei_x_new_with_version(&req); ei_x_encode_tuple_header(&req, 3); ei_x_encode_atom(&req, "c_node"); ei_x_encode_long(&req, c_node); ei_x_encode_tuple_header(&req, 2); ei_x_encode_atom(&req, "ok"); ei_x_encode_binary(&req, out.buf, out.written); int index = 0; ei_decode_term(req.buff, &index, &term); ei_x_free(&req); free(out.buf); return term; }
/** * Implementation of guac_png_write() which uses Cairo's own PNG encoder to * write PNG data, rather than using libpng directly. * * @param socket * The socket to send PNG blobs over. * * @param stream * The stream to associate with each blob. * * @param surface * The Cairo surface to write to the given stream and socket as PNG blobs. * * @return * Zero if the encoding operation is successful, non-zero otherwise. */ static int guac_png_cairo_write(guac_socket* socket, guac_stream* stream, cairo_surface_t* surface) { guac_png_write_state write_state; /* Init write state */ write_state.socket = socket; write_state.stream = stream; write_state.buffer_size = 0; /* Write surface as PNG */ if (cairo_surface_write_to_png_stream(surface, guac_png_cairo_write_handler, &write_state) != CAIRO_STATUS_SUCCESS) { guac_error = GUAC_STATUS_INTERNAL_ERROR; guac_error_message = "Cairo PNG backend failed"; return -1; } /* Flush remaining PNG data */ guac_png_flush_data(&write_state); return 0; }
static cairo_status_t _cairo_xml_emit_image (cairo_xml_t *xml, cairo_image_surface_t *image) { cairo_output_stream_t *stream; cairo_status_t status; _cairo_xml_printf_start (xml, "<image width='%d' height='%d' format='%s'>", image->width, image->height, _format_to_string (image->format)); stream = _cairo_base64_stream_create (xml->stream); status = cairo_surface_write_to_png_stream (&image->base, _write_func, stream); assert (status == CAIRO_STATUS_SUCCESS); status = _cairo_output_stream_destroy (stream); if (unlikely (status)) return status; _cairo_xml_printf_end (xml, "</image>"); return CAIRO_STATUS_SUCCESS; }
virtual void write(const Cairo::RefPtr<Cairo::Surface>& surface) { surface->flush(); //surface->write_to_png_stream(sigc::mem_fun(*this, &Renderer::PNGWriter::cairoWriter)); cairo_surface_write_to_png_stream(surface->cobj(), cairoWriter, (void*) buffer.get()); }
static bool encodeImage(cairo_surface_t* image, const String& mimeType, Vector<char>* output) { ASSERT(mimeType == "image/png"); // Only PNG output is supported for now. return cairo_surface_write_to_png_stream(image, writeFunction, output) == CAIRO_STATUS_SUCCESS; }
static bool encodeImagePNG(cairo_surface_t* image, Vector<char>* output) { return cairo_surface_write_to_png_stream(image, writeFunction, output) == CAIRO_STATUS_SUCCESS; }
int draw(tr_params * render) { fontface * face = NULL; cairo_surface_t * sub_surface; cairo_t * sub_context; cairo_status_t status; cairo_text_extents_t text_extents, help_extents; int stride; cairo_matrix_t matrix; double elapsed; #ifdef __linux struct timespec tp_start, tp_end; #else clock_t start, end; #endif #ifdef __linux clock_gettime(CLOCK_REALTIME, &tp_start); #else start = clock(); #endif if ( render->text == NULL || strlen(render->text) == 0 ) { fwrite(nullpng, 1, sizeof(nullpng), stdout); return 0; } if ( render->font != NULL ) face = hash_get(faces, render->font); if ( face == NULL ) face = hash_get(faces, "__DEFAULT__"); cairo_set_font_size(main_context, render->size); cairo_set_font_face(main_context, face->cface); // the help parameter will probably alter the text to draw, so let's check it first if ( render->help != NULL && strncmp(render->help, "debug", sizeof("debug")) != 0 ) render->text = help_text(render); // how big will the rendered text be? cairo_text_extents(main_context, render->text, &text_extents); // we'll might also need to know the extents of the help text if ( render->help != NULL && strncmp(render->help, "debug", sizeof("debug")) == 0 ) cairo_text_extents(main_context, help_text(render), &help_extents); // since Cairo origins it's draw from the lower-left (for l2r text) we have to adjust y if ( render->y == _DEFAULT_Y ) render->y = text_extents.height; // TODO - if helptext, grow render w and h as needed... // 1.06 is a swizzle factor to compensate for the incorrect extents cairo produces if ( render->w == _DEFAULT_WIDTH ) { render->w = ceil(render->x) + ceil(text_extents.width * 1.06); } if ( render->h == _DEFAULT_HEIGHT ) { render->h = ceil(render->y) + ceil(text_extents.height); } stride = cairo_image_surface_get_stride(main_surface); // we know how big the image will be, create our sub_surface from the main_surface sub_surface = cairo_image_surface_create_for_data(cairo_image_surface_get_data(main_surface), CAIRO_FORMAT_ARGB32, render->w, render->h, stride); sub_context = cairo_create(sub_surface); // Remember, this is a new surface that just happens to share the same // buffer as main_surface so we have to set the font size and face for it cairo_set_font_size(sub_context, render->size); cairo_set_font_face(sub_context, face->cface); // clear the buffer of left-over data cairo_set_operator(sub_context, CAIRO_OPERATOR_CLEAR); cairo_paint(sub_context); // And now we're ready to draw! cairo_set_operator(sub_context, CAIRO_OPERATOR_OVER); // do we need to show a background color? if ( render->bgr != 0.0 || render->bgg != 0.0 || render->bgb != 0.0 || render->bga != 0.0 ) { cairo_set_source_rgba(sub_context, render->bgr, render->bgg, render->bgb, render->bga); cairo_paint_with_alpha(sub_context, render->bga); } // set text color cairo_set_source_rgba(sub_context, render->r, render->g, render->b, render->a); cairo_move_to(sub_context, render->x, render->y); /* // TODO: rotation currently rotates around the upper-left corner, fix to rotate around text center if ( render->th != 0.0 ) { cairo_get_font_matrix(sub_context, &matrix); cairo_matrix_rotate(&matrix, render->th); cairo_set_font_matrix(sub_context, &matrix); } */ cairo_show_text(sub_context, render->text); // if we're set to debug, we'll have attempted a render above, and now we draw a parameters placard if ( render->help != NULL && (strncmp(render->help, "debug", sizeof("debug")) == 0) ) { // half-transparent black fill cairo_set_source_rgba(sub_context, 0, 0, 0, 1.0); cairo_paint_with_alpha(sub_context, 0.5); face = hash_get(faces, "__DEFAULT__"); cairo_set_font_face(sub_context, face->cface); cairo_set_font_size(sub_context, 12); cairo_move_to(sub_context, 0, 12); cairo_set_source_rgba(sub_context, 1, 1, 1, 1.0); cairo_show_text(sub_context, help_text(render)); } status = cairo_surface_write_to_png_stream(sub_surface, FCGI_cairo_write_stream, NULL); cairo_destroy(sub_context); cairo_surface_destroy(sub_surface); #ifdef __linux clock_gettime(CLOCK_REALTIME, &tp_end); elapsed = tp_end.tv_sec - tp_start.tv_sec; elapsed += (tp_end.tv_nsec - tp_start.tv_nsec)/1000000000.0; #else end = clock(); elapsed = ((double) (end - start)) / CLOCKS_PER_SEC; #endif // fprintf(stderr, "elapsed: %.3fms", elapsed*1000); // logging }
static int ro_composite_tile_read(struct storage_backend * store, const char *xmlconfig, const char *options, int x, int y, int z, char *buf, size_t sz, int * compressed, char * log_msg) { struct ro_composite_ctx * ctx = (struct ro_composite_ctx *)(store->storage_ctx); cairo_surface_t *imageA; cairo_surface_t *imageB; cairo_surface_t *imageC; cairo_t *cr; png_stream_to_byte_array_closure_t closure; if(ctx->store_primary->tile_read(ctx->store_primary, ctx->xmlconfig_primary, options, x, y, z, buf, sz, compressed, log_msg) < 0) { snprintf(log_msg,1024, "ro_composite_tile_read: Failed to read tile data of primary backend\n"); return -1; } closure.data = buf; closure.pos = 0; closure.max_size = sz; imageA = cairo_image_surface_create_from_png_stream(&read_png_stream_from_byte_array, &closure); if (!imageA) { snprintf(log_msg,1024, "ro_composite_tile_read: Failed to decode png data from primary backend\n"); return -1; } if(ctx->store_secondary->tile_read(ctx->store_secondary, ctx->xmlconfig_secondary, options, x, y, z, buf, sz, compressed, log_msg) < 0) { snprintf(log_msg,1024, "ro_composite_tile_read: Failed to read tile data of secondary backend\n"); cairo_surface_destroy(imageA); return -1; } closure.data = buf; closure.pos = 0; closure.max_size = sz; imageB = cairo_image_surface_create_from_png_stream(&read_png_stream_from_byte_array, &closure); if (!imageB) { snprintf(log_msg,1024, "ro_composite_tile_read: Failed to decode png data from secondary backend\n"); cairo_surface_destroy(imageA); return -1; } imageC = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, ctx->render_size, ctx->render_size); if (!imageC) { snprintf(log_msg,1024, "ro_composite_tile_read: Failed to create output png\n"); cairo_surface_destroy(imageA); cairo_surface_destroy(imageB); return -1; } //Create the cairo context cr = cairo_create(imageC); cairo_set_source_surface(cr, imageA, 0, 0); cairo_paint(cr); cairo_set_source_surface(cr, imageB, 0, 0); cairo_paint(cr); cairo_surface_flush(imageC); cairo_destroy(cr); closure.data = buf; closure.pos = 0; closure.max_size = sz; cairo_surface_write_to_png_stream(imageC, &write_png_stream_to_byte_array, &closure); cairo_surface_destroy(imageA); cairo_surface_destroy(imageB); cairo_surface_destroy(imageC); return closure.pos; }
void soy_sg_k2_png_converter_sgk2png (soySGK2PNGConverter* self, guchar* sgk_data, int sgk_data_length1) { RsvgHandle* handle = NULL; cairo_surface_t* surface = NULL; cairo_t* context = NULL; GError * _inner_error_ = NULL; #line 29 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" g_return_if_fail (self != NULL); #line 138 "sgk2png.c" { RsvgHandle* _tmp0_ = NULL; guchar* _tmp1_ = NULL; gint _tmp1__length1 = 0; RsvgHandle* _tmp2_ = NULL; RsvgHandle* _tmp3_ = NULL; gint _tmp4_ = 0; gint _tmp5_ = 0; RsvgHandle* _tmp6_ = NULL; gint _tmp7_ = 0; gint _tmp8_ = 0; cairo_surface_t* _tmp9_ = NULL; cairo_surface_t* _tmp10_ = NULL; cairo_t* _tmp11_ = NULL; RsvgHandle* _tmp12_ = NULL; cairo_t* _tmp13_ = NULL; cairo_surface_t* _tmp14_ = NULL; #line 35 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp1_ = sgk_data; #line 35 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp1__length1 = sgk_data_length1; #line 35 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp2_ = rsvg_handle_new_from_data (_tmp1_, _tmp1__length1, &_inner_error_); #line 35 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp0_ = _tmp2_; #line 35 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" if (_inner_error_ != NULL) { #line 166 "sgk2png.c" goto __catch9_g_error; } #line 35 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _g_object_unref0 (handle); #line 35 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" handle = _tmp0_; #line 36 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp3_ = handle; #line 36 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" g_object_get (_tmp3_, "width", &_tmp4_, NULL); #line 36 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp5_ = _tmp4_; #line 36 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp6_ = handle; #line 36 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" g_object_get (_tmp6_, "height", &_tmp7_, NULL); #line 36 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp8_ = _tmp7_; #line 36 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp9_ = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, _tmp5_, _tmp8_); #line 36 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _cairo_surface_destroy0 (surface); #line 36 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" surface = _tmp9_; #line 37 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp10_ = surface; #line 37 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp11_ = cairo_create (_tmp10_); #line 37 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _cairo_destroy0 (context); #line 37 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" context = _tmp11_; #line 38 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp12_ = handle; #line 38 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp13_ = context; #line 38 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" rsvg_handle_render_cairo (_tmp12_, _tmp13_); #line 39 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp14_ = surface; #line 39 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" cairo_surface_write_to_png_stream (_tmp14_, _soy_sg_k2_png_converter_writefunc_cairo_write_func_t, self); #line 209 "sgk2png.c" } goto __finally9; __catch9_g_error: { GError* g = NULL; FILE* _tmp15_ = NULL; GError* _tmp16_ = NULL; const gchar* _tmp17_ = NULL; #line 34 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" g = _inner_error_; #line 34 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _inner_error_ = NULL; #line 41 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp15_ = stdout; #line 41 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp16_ = g; #line 41 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _tmp17_ = _tmp16_->message; #line 41 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" fprintf (_tmp15_, "Error: %s\n", _tmp17_); #line 42 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _g_error_free0 (g); #line 42 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _cairo_destroy0 (context); #line 42 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _cairo_surface_destroy0 (surface); #line 42 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _g_object_unref0 (handle); #line 42 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" return; #line 240 "sgk2png.c" } __finally9: #line 34 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" if (_inner_error_ != NULL) { #line 34 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _cairo_destroy0 (context); #line 34 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _cairo_surface_destroy0 (surface); #line 34 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _g_object_unref0 (handle); #line 34 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); #line 34 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" g_clear_error (&_inner_error_); #line 34 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" return; #line 257 "sgk2png.c" } #line 44 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _cairo_destroy0 (context); #line 44 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _cairo_surface_destroy0 (surface); #line 44 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" _g_object_unref0 (handle); #line 44 "/home/jeff/Documents/libraries/libsoy/src/sgk2png.gs" return; #line 267 "sgk2png.c" }
static ngx_int_t ngx_http_fun_handler(ngx_http_request_t * r) { ngx_int_t rc; ngx_chain_t out; struct closure c = { r, &out, 0 }; char *uri; ngx_http_fun_loc_conf_t *cglcf; cglcf = ngx_http_get_module_loc_conf(r, ngx_http_fun_module); // we response to 'GET' and 'HEAD' requests only if (!(r->method & (NGX_HTTP_GET|NGX_HTTP_HEAD))) { return NGX_HTTP_NOT_ALLOWED; } // discard request body, since we don't need it here rc = ngx_http_discard_request_body(r); if (rc != NGX_OK) { return rc; } int angle = 0; if ( r->uri.len > 3 ) { uri = (char *)r->uri.data + r->uri.len - 3; angle = strtol(uri, NULL, 10); } // Let's do the cairo-stuff. cairo_surface_t *surface; cairo_t *cr; surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, cglcf->radius*2 + 64, cglcf->radius*2 + 64); cr = cairo_create (surface); double xc = cglcf->radius + 32; double yc = cglcf->radius + 32; double radius = cglcf->radius; double angle1 = 0.0; /* angles are specified */ double angle2 = angle * (M_PI/180.0); /* in radians */ cairo_set_line_width (cr, 10.0); cairo_arc (cr, xc, yc, radius, angle1, angle2); cairo_stroke (cr); /* draw helping lines */ cairo_set_source_rgba (cr, 1, 0.2, 0.2, 0.6); cairo_set_line_width (cr, 6.0); cairo_arc (cr, xc, yc, 10.0, 0, 2*M_PI); cairo_fill (cr); cairo_arc (cr, xc, yc, radius, angle1, angle1); cairo_line_to (cr, xc, yc); cairo_arc (cr, xc, yc, radius, angle2, angle2); cairo_line_to (cr, xc, yc); cairo_stroke (cr); out.buf = NULL; out.next = NULL; // Copy the png image to our buffer chain (we provide our own callback-function) rc = cairo_surface_write_to_png_stream(surface, copy_png_to_chain, &c); // Free cairo stuff. cairo_destroy(cr); cairo_surface_destroy(surface); // If we for some reason didn't manage to copy the png to our buffer, throw 503. if ( rc != CAIRO_STATUS_SUCCESS ) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } // set the 'Content-type' header r->headers_out.content_type_len = sizeof("image/png") - 1; r->headers_out.content_type.len = sizeof("image/png") - 1; r->headers_out.content_type.data = (u_char * ) "image/png"; // set the status line r->headers_out.status = NGX_HTTP_OK; r->headers_out.content_length_n = c.length; // send the headers of your response rc = ngx_http_send_header(r); // We've added the NGX_HTTP_HEAD check here, because we're unable to set content length before // we've actually calculated it (which is done by generating the image). // This is a waste of resources, and is why caching solutions exist. if (rc == NGX_ERROR || rc > NGX_OK || r->header_only || r->method == NGX_HTTP_HEAD) { return rc; } // send the buffer chain of your response return ngx_http_output_filter(r, &out); }
static cairo_test_status_t preamble (cairo_test_context_t *ctx) { char *filename; cairo_surface_t *surface; cairo_status_t status; cairo_test_status_t result = CAIRO_TEST_SUCCESS; surface = cairo_image_surface_create_from_png ("___THIS_FILE_DOES_NOT_EXIST___"); if (cairo_surface_status (surface) != CAIRO_STATUS_FILE_NOT_FOUND) { result = cairo_test_status_from_status (ctx, cairo_surface_status (surface)); if (result == CAIRO_TEST_FAILURE) { cairo_test_log (ctx, "Error: expected \"file not found\", but got: %s\n", cairo_status_to_string (cairo_surface_status (surface))); } } cairo_surface_destroy (surface); if (result != CAIRO_TEST_SUCCESS) return result; surface = cairo_image_surface_create_from_png_stream (no_memory_error, NULL); if (cairo_surface_status (surface) != CAIRO_STATUS_NO_MEMORY) { result = cairo_test_status_from_status (ctx, cairo_surface_status (surface)); if (result == CAIRO_TEST_FAILURE) { cairo_test_log (ctx, "Error: expected \"out of memory\", but got: %s\n", cairo_status_to_string (cairo_surface_status (surface))); } } cairo_surface_destroy (surface); if (result != CAIRO_TEST_SUCCESS) return result; surface = cairo_image_surface_create_from_png_stream (read_error, NULL); if (cairo_surface_status (surface) != CAIRO_STATUS_READ_ERROR) { result = cairo_test_status_from_status (ctx, cairo_surface_status (surface)); if (result == CAIRO_TEST_FAILURE) { cairo_test_log (ctx, "Error: expected \"read error\", but got: %s\n", cairo_status_to_string (cairo_surface_status (surface))); } } cairo_surface_destroy (surface); if (result != CAIRO_TEST_SUCCESS) return result; /* cheekily test error propagation from the user write funcs as well ... */ xasprintf (&filename, "%s/%s", ctx->srcdir, "create-from-png.ref.png"); surface = cairo_image_surface_create_from_png (filename); if (cairo_surface_status (surface)) { result = cairo_test_status_from_status (ctx, cairo_surface_status (surface)); if (result == CAIRO_TEST_FAILURE) { cairo_test_log (ctx, "Error reading PNG image %s: %s\n", filename, cairo_status_to_string (cairo_surface_status (surface))); } } else { status = cairo_surface_write_to_png_stream (surface, (cairo_write_func_t) no_memory_error, NULL); if (status != CAIRO_STATUS_NO_MEMORY) { result = cairo_test_status_from_status (ctx, status); if (result == CAIRO_TEST_FAILURE) { cairo_test_log (ctx, "Error: expected \"out of memory\", but got: %s\n", cairo_status_to_string (status)); } } status = cairo_surface_write_to_png_stream (surface, (cairo_write_func_t) read_error, NULL); if (status != CAIRO_STATUS_READ_ERROR) { result = cairo_test_status_from_status (ctx, status); if (result == CAIRO_TEST_FAILURE) { cairo_test_log (ctx, "Error: expected \"read error\", but got: %s\n", cairo_status_to_string (status)); } } /* and check that error has not propagated to the surface */ if (cairo_surface_status (surface)) { result = cairo_test_status_from_status (ctx, cairo_surface_status (surface)); if (result == CAIRO_TEST_FAILURE) { cairo_test_log (ctx, "Error: user write error propagated to surface: %s", cairo_status_to_string (cairo_surface_status (surface))); } } } cairo_surface_destroy (surface); free (filename); if (result != CAIRO_TEST_SUCCESS) return result; /* check that loading alpha/opaque PNGs generate the correct surfaces */ xasprintf (&filename, "%s/%s", ctx->srcdir, "create-from-png.alpha.ref.png"); surface = cairo_image_surface_create_from_png (filename); if (cairo_surface_status (surface)) { result = cairo_test_status_from_status (ctx, cairo_surface_status (surface)); if (result == CAIRO_TEST_FAILURE) { cairo_test_log (ctx, "Error reading PNG image %s: %s\n", filename, cairo_status_to_string (cairo_surface_status (surface))); } } else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_ARGB32) { cairo_test_log (ctx, "Error reading PNG image %s: did not create an ARGB32 image\n", filename); result = CAIRO_TEST_FAILURE; } free (filename); cairo_surface_destroy (surface); if (result != CAIRO_TEST_SUCCESS) return result; xasprintf (&filename, "%s/%s", ctx->srcdir, "create-from-png.ref.png"); surface = cairo_image_surface_create_from_png (filename); if (cairo_surface_status (surface)) { result = cairo_test_status_from_status (ctx, cairo_surface_status (surface)); if (result == CAIRO_TEST_FAILURE) { cairo_test_log (ctx, "Error reading PNG image %s: %s\n", filename, cairo_status_to_string (cairo_surface_status (surface))); } } else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_RGB24) { cairo_test_log (ctx, "Error reading PNG image %s: did not create an RGB24 image\n", filename); result = CAIRO_TEST_FAILURE; } free (filename); cairo_surface_destroy (surface); if (result != CAIRO_TEST_SUCCESS) return result; /* check paletted PNGs */ xasprintf (&filename, "%s/%s", ctx->srcdir, "create-from-png.indexed-alpha.ref.png"); surface = cairo_image_surface_create_from_png (filename); if (cairo_surface_status (surface)) { result = cairo_test_status_from_status (ctx, cairo_surface_status (surface)); if (result == CAIRO_TEST_FAILURE) { cairo_test_log (ctx, "Error reading PNG image %s: %s\n", filename, cairo_status_to_string (cairo_surface_status (surface))); } } else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_ARGB32) { cairo_test_log (ctx, "Error reading PNG image %s: did not create an ARGB32 image\n", filename); result = CAIRO_TEST_FAILURE; } free (filename); cairo_surface_destroy (surface); if (result != CAIRO_TEST_SUCCESS) return result; xasprintf (&filename, "%s/%s", ctx->srcdir, "create-from-png.indexed.ref.png"); surface = cairo_image_surface_create_from_png (filename); if (cairo_surface_status (surface)) { result = cairo_test_status_from_status (ctx, cairo_surface_status (surface)); if (result == CAIRO_TEST_FAILURE) { cairo_test_log (ctx, "Error reading PNG image %s: %s\n", filename, cairo_status_to_string (cairo_surface_status (surface))); } } else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_RGB24) { cairo_test_log (ctx, "Error reading PNG image %s: did not create an RGB24 image\n", filename); result = CAIRO_TEST_FAILURE; } free (filename); cairo_surface_destroy (surface); if (result != CAIRO_TEST_SUCCESS) return result; /* check grayscale PNGs */ xasprintf (&filename, "%s/%s", ctx->srcdir, "create-from-png.gray-alpha.ref.png"); surface = cairo_image_surface_create_from_png (filename); if (cairo_surface_status (surface)) { result = cairo_test_status_from_status (ctx, cairo_surface_status (surface)); if (result == CAIRO_TEST_FAILURE) { cairo_test_log (ctx, "Error reading PNG image %s: %s\n", filename, cairo_status_to_string (cairo_surface_status (surface))); } } else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_ARGB32) { cairo_test_log (ctx, "Error reading PNG image %s: did not create an ARGB32 image\n", filename); result = CAIRO_TEST_FAILURE; } free (filename); cairo_surface_destroy (surface); if (result != CAIRO_TEST_SUCCESS) return result; xasprintf (&filename, "%s/%s", ctx->srcdir, "create-from-png.gray.ref.png"); surface = cairo_image_surface_create_from_png (filename); if (cairo_surface_status (surface)) { result = cairo_test_status_from_status (ctx, cairo_surface_status (surface)); if (result == CAIRO_TEST_FAILURE) { cairo_test_log (ctx, "Error reading PNG image %s: %s\n", filename, cairo_status_to_string (cairo_surface_status (surface))); } } else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_RGB24) { cairo_test_log (ctx, "Error reading PNG image %s: did not create an RGB24 image\n", filename); result = CAIRO_TEST_FAILURE; } free (filename); cairo_surface_destroy (surface); return result; }