/* usershape described by a postscript file */
static void lasi_loadimage_ps(GVJ_t * job, usershape_t *us, boxf b, boolean filled)
{
assert(job);
assert(us);
assert(us->name);
if (us->data) {
if (us->datafree != ps_freeimage) {
us->datafree(us); /* free incompatible cache data */
us->data = NULL;
us->datafree = NULL;
us->datasize = 0;
}
}
if (!us->data) { /* read file into cache */
int fd;
struct stat statbuf;
if (!gvusershape_file_access(us))
return;
fd = fileno(us->f);
switch (us->type) {
case FT_PS:
case FT_EPS:
fstat(fd, &statbuf);
us->datasize = statbuf.st_size;
#if HAVE_SYS_MMAN_H
us->data = mmap(0, statbuf.st_size, PROT_READ, MAP_SHARED, fd, 0);
#else
us->data = malloc(statbuf.st_size);
read(fd, us->data, statbuf.st_size);
#endif
us->must_inline = TRUE;
break;
default:
break;
}
if (us->data)
us->datafree = ps_freeimage;
gvusershape_file_release(us);
}
if (us->data) {
gvprintf(job, "gsave %g %g translate newpath\n",
b.LL.x - (double)(us->x), b.LL.y - (double)(us->y));
if (us->must_inline)
epsf_emit_body(job, us);
else
gvprintf(job, "user_shape_%d\n", us->macro_id);
gvprintf(job, "grestore\n");
}
}
static int gvloadimage_process_file(GVJ_t *job, usershape_t *us, void *instance)
{
int rc = 0, exit_code;
if (! gvusershape_file_access(us)) {
job->common->errorfn("Failure to read shape file\n");
return -1;
}
rc = gsapi_run_file(instance, us->name, -1, &exit_code);
if (rc) {
gs_error(job, us->name, "gsapi_run_file", rc);
}
gvusershape_file_release(us);
return rc;
}
static cairo_surface_t* cairo_loadimage(GVJ_t * job, usershape_t *us)
{
cairo_surface_t *surface = NULL; /* source surface */
assert(job);
assert(us);
assert(us->name);
assert(us->name[0]);
if (us->data) {
if (us->datafree == cairo_freeimage)
surface = (cairo_surface_t*)(us->data); /* use cached data */
else {
us->datafree(us); /* free incompatible cache data */
us->datafree = NULL;
us->data = NULL;
}
}
if (!surface) { /* read file into cache */
if (!gvusershape_file_access(us))
return NULL;
assert(us->f);
switch (us->type) {
#ifdef CAIRO_HAS_PNG_FUNCTIONS
case FT_PNG:
surface = cairo_image_surface_create_from_png_stream(reader, us->f);
cairo_surface_reference(surface);
break;
#endif
default:
surface = NULL;
}
if (surface) {
us->data = (void*)surface;
us->datafree = cairo_freeimage;
}
gvusershape_file_release(us);
}
return surface;
}
static CGImageRef quartz_loadimage(GVJ_t * job, usershape_t *us)
{
assert(job);
assert(us);
assert(us->name);
if (us->data && us->datafree != quartz_freeimage) {
us->datafree(us); /* free incompatible cache data */
us->data = NULL;
us->datafree = NULL;
}
if (!us->data) { /* read file into cache */
if (!gvusershape_file_access(us))
return NULL;
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1050 || __IPHONE_OS_VERSION_MIN_REQUIRED >= 20000
CGDataProviderRef data_provider = CGDataProviderCreateSequential(us->f, &file_data_provider_callbacks);
#else
CGDataProviderRef data_provider = CGDataProviderCreate(us->f, &file_data_provider_callbacks);
#endif
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1040
/* match usershape format to a UTI for type hinting, if possible */
format_type hint_format_type;
switch (us->type) {
case FT_BMP:
hint_format_type = FORMAT_BMP;
break;
case FT_GIF:
hint_format_type = FORMAT_GIF;
break;
case FT_PNG:
hint_format_type = FORMAT_PNG;
break;
case FT_JPEG:
hint_format_type = FORMAT_JPEG;
break;
case FT_PDF:
hint_format_type = FORMAT_PDF;
break;
default:
hint_format_type = FORMAT_NONE;
break;
}
CFDictionaryRef options = hint_format_type == FORMAT_NONE ? NULL : CFDictionaryCreate(
kCFAllocatorDefault,
(const void **)&kCGImageSourceTypeIdentifierHint,
(const void **)(format_uti + hint_format_type),
1,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
/* get first image from usershape file */
CGImageSourceRef image_source = CGImageSourceCreateWithDataProvider(data_provider, options);
us->data = CGImageSourceCreateImageAtIndex(image_source, 0, NULL);
if (image_source)
CFRelease(image_source);
if (options)
CFRelease(options);
#else
switch (us->type) {
case FT_PNG:
us->data = CGImageCreateWithPNGDataProvider(data_provider, NULL, false, kCGRenderingIntentDefault);
break;
case FT_JPEG:
us->data = CGImageCreateWithJPEGDataProvider(data_provider, NULL, false, kCGRenderingIntentDefault);
break;
default:
us->data = NULL;
break;
}
#endif
/* clean up */
if (us->data)
us->datafree = quartz_freeimage;
CGDataProviderRelease(data_provider);
gvusershape_file_release(us);
}
return (CGImageRef)(us->data);
}
static PopplerDocument* gvloadimage_poppler_load(GVJ_t * job, usershape_t *us)
{
PopplerDocument *document = NULL;
GError *error;
gchar *absolute, *uri;
int num_pages;
assert(job);
assert(us);
assert(us->name);
if (us->data) {
if (us->datafree == gvloadimage_poppler_free)
document = (PopplerDocument*)(us->data); /* use cached data */
else {
us->datafree(us); /* free incompatible cache data */
us->data = NULL;
us->datafree = NULL;
}
}
if (!document) { /* read file into cache */
if (!gvusershape_file_access(us))
return NULL;
switch (us->type) {
case FT_PDF:
if (g_path_is_absolute(us->name)) {
absolute = g_strdup (us->name);
} else {
gchar *dir = g_get_current_dir ();
absolute = g_build_filename (dir, us->name, (gchar *) 0);
free (dir);
}
uri = g_filename_to_uri (absolute, NULL, &error);
free (absolute);
if (uri == NULL) {
printf("%s\n", error->message);
return NULL;
}
document = poppler_document_new_from_file (uri, NULL, &error);
if (document == NULL) {
printf("%s\n", error->message);
return NULL;
}
// check page 1 exists
num_pages = poppler_document_get_n_pages (document);
if (num_pages < 1) {
printf("poppler fail: num_pages %d, must be at least 1", num_pages);
return NULL;
}
break;
default:
break;
}
if (document) {
us->data = (void*)document;
us->datafree = gvloadimage_poppler_free;
}
gvusershape_file_release(us);
}
return document;
}
static RsvgHandle* gvloadimage_rsvg_load(GVJ_t * job, usershape_t *us)
{
RsvgHandle* rsvgh = NULL;
guchar *fileBuf = NULL;
GError *err = NULL;
gsize fileSize;
gint result;
int fd;
struct stat stbuf;
assert(job);
assert(us);
assert(us->name);
if (us->data) {
if (us->datafree == gvloadimage_rsvg_free)
rsvgh = (RsvgHandle*)(us->data); /* use cached data */
else {
us->datafree(us); /* free incompatible cache data */
us->data = NULL;
}
}
if (!rsvgh) { /* read file into cache */
if (!gvusershape_file_access(us))
return NULL;
switch (us->type) {
case FT_SVG:
rsvg_init();
rsvgh = rsvg_handle_new();
if (rsvgh == NULL) {
fprintf(stderr, "rsvg_handle_new_from_file returned an error: %s\n", err->message);
rsvg_term();
return NULL;
}
fd = fileno(us->f);
fstat(fd, &stbuf);
fileSize = stbuf.st_size;
fileBuf = calloc(fileSize + 1, sizeof(guchar));
if (fileBuf == NULL) {
rsvg_handle_free(rsvgh);
rsvg_term();
return NULL;
}
rewind(us->f);
if ((result = fread(fileBuf, 1, fileSize, us->f)) < fileSize) {
rsvg_handle_free(rsvgh);
rsvg_term();
return NULL;
}
if (rsvg_handle_write(rsvgh, (const guchar *)fileBuf, (gsize)fileSize, &err) == FALSE) {
fprintf(stderr, "rsvg_handle_write returned an error: %s\n", err->message);
free(fileBuf);
rsvg_handle_free(rsvgh);
rsvg_term();
return NULL;
}
free(fileBuf);
rsvg_handle_close(rsvgh, &err);
rsvg_handle_set_dpi(rsvgh, POINTS_PER_INCH);
break;
default:
rsvgh = NULL;
}
if (rsvgh) {
us->data = (void*)rsvgh;
us->datafree = gvloadimage_rsvg_free;
}
gvusershape_file_release(us);
}
return rsvgh;
}
static gdImagePtr gd_loadimage(GVJ_t * job, usershape_t *us)
{
assert(job);
assert(us);
assert(us->name);
if (us->data) {
if (us->datafree != gd_freeimage) {
us->datafree(us); /* free incompatible cache data */
us->data = NULL;
us->datafree = NULL;
}
}
if (!us->data) { /* read file into cache */
if (!gvusershape_file_access(us))
return NULL;
switch (us->type) {
#if 0
case FT_GD:
im = gdImageCreateFromGd(us->f);
break;
case FT_GD2:
im = gdImageCreateFromGd2(us->f);
break;
#endif
#ifdef HAVE_GD_PNG
case FT_PNG:
us->data = (void*)gdImageCreateFromPng(us->f);
break;
#endif
#ifdef HAVE_GD_GIF
case FT_GIF:
us->data = (void*)gdImageCreateFromGif(us->f);
break;
#endif
#ifdef HAVE_GD_JPEG
case FT_JPEG:
us->data = (void*)gdImageCreateFromJpeg(us->f);
break;
#endif
#if 0
#ifdef HAVE_GD_XPM
case FT_XPM:
us->data = (void*)gdImageCreateFromXpm(us->f);
break;
#endif
#ifdef HAVE_GD_WBMP
case FT_WBMP:
us->data = (void*)gdImageCreateFromWbmp(us->f);
break;
#endif
#endif
default:
break;
}
if (us->data)
us->datafree = gd_freeimage;
gvusershape_file_release(us);
}
return (gdImagePtr)(us->data);
}
