542 lines
13 KiB
C
542 lines
13 KiB
C
/* VIPS function dispatch tables for conversion.
|
|
*
|
|
* J. Cupitt, 8/4/93.
|
|
*/
|
|
|
|
/*
|
|
|
|
This file is part of VIPS.
|
|
|
|
VIPS is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk
|
|
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif /*HAVE_CONFIG_H*/
|
|
#include <vips/intl.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <vips/vips.h>
|
|
|
|
#ifdef WITH_DMALLOC
|
|
#include <dmalloc.h>
|
|
#endif /*WITH_DMALLOC*/
|
|
|
|
static int
|
|
jpeg2vips_vec( im_object *argv )
|
|
{
|
|
char *in = argv[0];
|
|
IMAGE *out = argv[1];
|
|
|
|
if( im_jpeg2vips( in, out ) )
|
|
return( -1 );
|
|
|
|
return( 0 );
|
|
}
|
|
|
|
static im_arg_desc jpeg2vips_args[] = {
|
|
IM_INPUT_STRING( "in" ),
|
|
IM_OUTPUT_IMAGE( "out" )
|
|
};
|
|
|
|
static im_function jpeg2vips_desc = {
|
|
"im_jpeg2vips", /* Name */
|
|
"convert from jpeg", /* Description */
|
|
0, /* Flags */
|
|
jpeg2vips_vec, /* Dispatch function */
|
|
IM_NUMBER( jpeg2vips_args ), /* Size of arg list */
|
|
jpeg2vips_args /* Arg list */
|
|
};
|
|
|
|
static int
|
|
vips2jpeg_vec( im_object *argv )
|
|
{
|
|
IMAGE *in = argv[0];
|
|
char *out = argv[1];
|
|
|
|
if( im_vips2jpeg( in, out ) )
|
|
return( -1 );
|
|
|
|
return( 0 );
|
|
}
|
|
|
|
static im_arg_desc vips2jpeg_args[] = {
|
|
IM_INPUT_IMAGE( "in" ),
|
|
IM_INPUT_STRING( "out" )
|
|
};
|
|
|
|
static im_function vips2jpeg_desc = {
|
|
"im_vips2jpeg", /* Name */
|
|
"convert to jpeg", /* Description */
|
|
0, /* Flags */
|
|
vips2jpeg_vec, /* Dispatch function */
|
|
IM_NUMBER( vips2jpeg_args ), /* Size of arg list */
|
|
vips2jpeg_args /* Arg list */
|
|
};
|
|
|
|
static int
|
|
vips2mimejpeg_vec( im_object *argv )
|
|
{
|
|
IMAGE *in = argv[0];
|
|
int qfac = *((int *) argv[1]);
|
|
|
|
if( im_vips2mimejpeg( in, qfac ) )
|
|
return( -1 );
|
|
|
|
return( 0 );
|
|
}
|
|
|
|
static im_arg_desc vips2mimejpeg_args[] = {
|
|
IM_INPUT_IMAGE( "in" ),
|
|
IM_INPUT_INT( "qfac" )
|
|
};
|
|
|
|
static im_function vips2mimejpeg_desc = {
|
|
"im_vips2mimejpeg", /* Name */
|
|
"convert to jpeg as mime type on stdout", /* Description */
|
|
0, /* Flags */
|
|
vips2mimejpeg_vec, /* Dispatch function */
|
|
IM_NUMBER( vips2mimejpeg_args ), /* Size of arg list */
|
|
vips2mimejpeg_args /* Arg list */
|
|
};
|
|
|
|
/* Args for vips2png.
|
|
*/
|
|
static im_arg_desc vips2png_args[] = {
|
|
IM_INPUT_IMAGE( "in" ),
|
|
IM_INPUT_STRING( "out" )
|
|
};
|
|
|
|
/* Call im_vips2png via arg vector.
|
|
*/
|
|
static int
|
|
vips2png_vec( im_object *argv )
|
|
{
|
|
return( im_vips2png( argv[0], argv[1] ) );
|
|
}
|
|
|
|
/* Description of im_vips2png.
|
|
*/
|
|
static im_function vips2png_desc = {
|
|
"im_vips2png", /* Name */
|
|
"convert VIPS image to PNG file", /* Description */
|
|
0,
|
|
vips2png_vec, /* Dispatch function */
|
|
IM_NUMBER( vips2png_args ), /* Size of arg list */
|
|
vips2png_args /* Arg list */
|
|
};
|
|
|
|
/* Args for png2vips.
|
|
*/
|
|
static im_arg_desc png2vips_args[] = {
|
|
IM_INPUT_STRING( "in" ),
|
|
IM_OUTPUT_IMAGE( "out" )
|
|
};
|
|
|
|
/* Call im_png2vips via arg vector.
|
|
*/
|
|
static int
|
|
png2vips_vec( im_object *argv )
|
|
{
|
|
return( im_png2vips( argv[0], argv[1] ) );
|
|
}
|
|
|
|
/* Description of im_png2vips.
|
|
*/
|
|
static im_function png2vips_desc = {
|
|
"im_png2vips", /* Name */
|
|
"convert PNG file to VIPS image", /* Description */
|
|
0,
|
|
png2vips_vec, /* Dispatch function */
|
|
IM_NUMBER( png2vips_args ), /* Size of arg list */
|
|
png2vips_args /* Arg list */
|
|
};
|
|
|
|
/* Args for exr2vips.
|
|
*/
|
|
static im_arg_desc exr2vips_args[] = {
|
|
IM_INPUT_STRING( "in" ),
|
|
IM_OUTPUT_IMAGE( "out" )
|
|
};
|
|
|
|
/* Call im_exr2vips via arg vector.
|
|
*/
|
|
static int
|
|
exr2vips_vec( im_object *argv )
|
|
{
|
|
return( im_exr2vips( argv[0], argv[1] ) );
|
|
}
|
|
|
|
/* Description of im_exr2vips.
|
|
*/
|
|
static im_function exr2vips_desc = {
|
|
"im_exr2vips", /* Name */
|
|
"convert an OpenEXR file to VIPS", /* Description */
|
|
0,
|
|
exr2vips_vec, /* Dispatch function */
|
|
IM_NUMBER( exr2vips_args ), /* Size of arg list */
|
|
exr2vips_args /* Arg list */
|
|
};
|
|
|
|
/* Args for vips2tiff.
|
|
*/
|
|
static im_arg_desc vips2tiff_args[] = {
|
|
IM_INPUT_IMAGE( "in" ),
|
|
IM_INPUT_STRING( "out" )
|
|
};
|
|
|
|
/* Call im_vips2tiff via arg vector.
|
|
*/
|
|
static int
|
|
vips2tiff_vec( im_object *argv )
|
|
{
|
|
return( im_vips2tiff( argv[0], argv[1] ) );
|
|
}
|
|
|
|
/* Description of im_vips2tiff.
|
|
*/
|
|
static im_function vips2tiff_desc = {
|
|
"im_vips2tiff", /* Name */
|
|
"convert VIPS image to TIFF file", /* Description */
|
|
0,
|
|
vips2tiff_vec, /* Dispatch function */
|
|
IM_NUMBER( vips2tiff_args ), /* Size of arg list */
|
|
vips2tiff_args /* Arg list */
|
|
};
|
|
|
|
/* Args for magick2vips.
|
|
*/
|
|
static im_arg_desc magick2vips_args[] = {
|
|
IM_INPUT_STRING( "in" ),
|
|
IM_OUTPUT_IMAGE( "out" )
|
|
};
|
|
|
|
/* Call im_magick2vips via arg vector.
|
|
*/
|
|
static int
|
|
magick2vips_vec( im_object *argv )
|
|
{
|
|
return( im_magick2vips( argv[0], argv[1] ) );
|
|
}
|
|
|
|
/* Description of im_magick2vips.
|
|
*/
|
|
static im_function magick2vips_desc = {
|
|
"im_magick2vips", /* Name */
|
|
"load file with libMagick", /* Description */
|
|
0,
|
|
magick2vips_vec, /* Dispatch function */
|
|
IM_NUMBER( magick2vips_args ), /* Size of arg list */
|
|
magick2vips_args /* Arg list */
|
|
};
|
|
|
|
/* Args for tiff2vips.
|
|
*/
|
|
static im_arg_desc tiff2vips_args[] = {
|
|
IM_INPUT_STRING( "in" ),
|
|
IM_OUTPUT_IMAGE( "out" )
|
|
};
|
|
|
|
/* Call im_tiff2vips via arg vector.
|
|
*/
|
|
static int
|
|
tiff2vips_vec( im_object *argv )
|
|
{
|
|
return( im_tiff2vips( argv[0], argv[1] ) );
|
|
}
|
|
|
|
/* Description of im_tiff2vips.
|
|
*/
|
|
static im_function tiff2vips_desc = {
|
|
"im_tiff2vips", /* Name */
|
|
"convert TIFF file to VIPS image", /* Description */
|
|
0,
|
|
tiff2vips_vec, /* Dispatch function */
|
|
IM_NUMBER( tiff2vips_args ), /* Size of arg list */
|
|
tiff2vips_args /* Arg list */
|
|
};
|
|
|
|
static int
|
|
analyze2vips_vec( im_object *argv )
|
|
{
|
|
const char *in = argv[0];
|
|
IMAGE *out = argv[1];
|
|
|
|
return( im_analyze2vips( in, out ) );
|
|
}
|
|
|
|
static im_arg_desc analyze2vips_arg_types[] = {
|
|
IM_INPUT_STRING( "filename" ),
|
|
IM_OUTPUT_IMAGE( "im" )
|
|
};
|
|
|
|
static im_function analyze2vips_desc = {
|
|
"im_analyze2vips", /* Name */
|
|
"read a file in analyze format",/* Description */
|
|
0, /* Flags */
|
|
analyze2vips_vec, /* Dispatch function */
|
|
IM_NUMBER( analyze2vips_arg_types ),/* Size of arg list */
|
|
analyze2vips_arg_types /* Arg list */
|
|
};
|
|
|
|
static int
|
|
csv2vips_vec( im_object *argv )
|
|
{
|
|
const char *in = argv[0];
|
|
IMAGE *out = argv[1];
|
|
|
|
return( im_csv2vips( in, out ) );
|
|
}
|
|
|
|
static im_arg_desc csv2vips_arg_types[] = {
|
|
IM_INPUT_STRING( "filename" ),
|
|
IM_OUTPUT_IMAGE( "im" )
|
|
};
|
|
|
|
static im_function csv2vips_desc = {
|
|
"im_csv2vips", /* Name */
|
|
"read a file in csv format",/* Description */
|
|
0, /* Flags */
|
|
csv2vips_vec, /* Dispatch function */
|
|
IM_NUMBER( csv2vips_arg_types ),/* Size of arg list */
|
|
csv2vips_arg_types /* Arg list */
|
|
};
|
|
|
|
static int
|
|
vips2csv_vec( im_object *argv )
|
|
{
|
|
IMAGE *in = argv[0];
|
|
const char *filename = argv[1];
|
|
|
|
return( im_vips2csv( in, filename ) );
|
|
}
|
|
|
|
static im_arg_desc vips2csv_arg_types[] = {
|
|
IM_INPUT_IMAGE( "in" ),
|
|
IM_INPUT_STRING( "filename" )
|
|
};
|
|
|
|
static im_function vips2csv_desc = {
|
|
"im_vips2csv", /* Name */
|
|
"write an image in csv format", /* Description */
|
|
0, /* Flags */
|
|
vips2csv_vec, /* Dispatch function */
|
|
IM_NUMBER( vips2csv_arg_types ),/* Size of arg list */
|
|
vips2csv_arg_types /* Arg list */
|
|
};
|
|
|
|
static int
|
|
ppm2vips_vec( im_object *argv )
|
|
{
|
|
const char *in = argv[0];
|
|
IMAGE *out = argv[1];
|
|
|
|
return( im_ppm2vips( in, out ) );
|
|
}
|
|
|
|
static im_arg_desc ppm2vips_arg_types[] = {
|
|
IM_INPUT_STRING( "filename" ),
|
|
IM_OUTPUT_IMAGE( "im" )
|
|
};
|
|
|
|
static im_function ppm2vips_desc = {
|
|
"im_ppm2vips", /* Name */
|
|
"read a file in pbm/pgm/ppm format", /* Description */
|
|
0, /* Flags */
|
|
ppm2vips_vec, /* Dispatch function */
|
|
IM_NUMBER( ppm2vips_arg_types ),/* Size of arg list */
|
|
ppm2vips_arg_types /* Arg list */
|
|
};
|
|
|
|
static int
|
|
vips2ppm_vec( im_object *argv )
|
|
{
|
|
IMAGE *im = argv[0];
|
|
const char *filename = argv[1];
|
|
|
|
return( im_vips2ppm( im, filename ) );
|
|
}
|
|
|
|
static im_arg_desc vips2ppm_arg_types[] = {
|
|
IM_INPUT_IMAGE( "im" ),
|
|
IM_INPUT_STRING( "filename" )
|
|
};
|
|
|
|
static im_function vips2ppm_desc = {
|
|
"im_vips2ppm", /* Name */
|
|
"write a file in pbm/pgm/ppm format", /* Description */
|
|
0, /* Flags */
|
|
vips2ppm_vec, /* Dispatch function */
|
|
IM_NUMBER( vips2ppm_arg_types ),/* Size of arg list */
|
|
vips2ppm_arg_types /* Arg list */
|
|
};
|
|
|
|
/* Package up all these functions.
|
|
*/
|
|
static im_function *list[] = {
|
|
&csv2vips_desc,
|
|
&jpeg2vips_desc,
|
|
&magick2vips_desc,
|
|
&png2vips_desc,
|
|
&exr2vips_desc,
|
|
&ppm2vips_desc,
|
|
&analyze2vips_desc,
|
|
&tiff2vips_desc,
|
|
&vips2csv_desc,
|
|
&vips2jpeg_desc,
|
|
&vips2mimejpeg_desc,
|
|
&vips2png_desc,
|
|
&vips2ppm_desc,
|
|
&vips2tiff_desc
|
|
};
|
|
|
|
/* Package of functions.
|
|
*/
|
|
im_package im__format = {
|
|
"format",
|
|
IM_NUMBER( list ),
|
|
list
|
|
};
|
|
|
|
/* Suffix sets.
|
|
*/
|
|
static const char *tiff_suffs[] = { ".tif", ".tiff", NULL };
|
|
static const char *jpeg_suffs[] = { ".jpg", ".jpeg", ".jpe", NULL };
|
|
static const char *png_suffs[] = { ".png", NULL };
|
|
static const char *csv_suffs[] = { ".csv", NULL };
|
|
static const char *ppm_suffs[] = { ".ppm", ".pgm", ".pbm", NULL };
|
|
static const char *exr_suffs[] = { ".exr", NULL };
|
|
static const char *analyze_suffs[] = { ".img", ".hdr", NULL };
|
|
static const char *magick_suffs[] = { NULL };
|
|
|
|
/* VIPS image formats.
|
|
*/
|
|
static im_format jpeg_desc = {
|
|
"jpeg", /* internal name */
|
|
N_( "JPEG" ), /* i18n'd visible name */
|
|
0, /* Priority */
|
|
jpeg_suffs, /* Allowed suffixes */
|
|
im_isjpeg, /* is_a */
|
|
im_jpeg2vips_header, /* Load header only */
|
|
im_jpeg2vips, /* Load */
|
|
im_vips2jpeg /* Save */
|
|
};
|
|
|
|
static im_format tiff_desc = {
|
|
"tiff", /* internal name */
|
|
N_( "TIFF" ), /* i18n'd visible name */
|
|
0, /* Priority */
|
|
tiff_suffs, /* Allowed suffixes */
|
|
im_istiff, /* is_a */
|
|
im_tiff2vips_header, /* Load header only */
|
|
im_tiff2vips, /* Load */
|
|
im_vips2tiff /* Save */
|
|
};
|
|
|
|
static im_format png_desc = {
|
|
"png", /* internal name */
|
|
N_( "PNG" ), /* i18n'd visible name */
|
|
0, /* Priority */
|
|
png_suffs, /* Allowed suffixes */
|
|
im_ispng, /* is_a */
|
|
im_png2vips_header, /* Load header only */
|
|
im_png2vips, /* Load */
|
|
im_vips2png /* Save */
|
|
};
|
|
|
|
static im_format csv_desc = {
|
|
"csv", /* internal name */
|
|
N_( "CSV" ), /* i18n'd visible name */
|
|
0, /* Priority */
|
|
csv_suffs, /* Allowed suffixes */
|
|
NULL, /* is_a */
|
|
im_csv2vips_header, /* Load header only */
|
|
im_csv2vips, /* Load */
|
|
im_vips2csv /* Save */
|
|
};
|
|
|
|
static im_format ppm_desc = {
|
|
"ppm", /* internal name */
|
|
N_( "PPM/PBM/PNM" ), /* i18n'd visible name */
|
|
0, /* Priority */
|
|
ppm_suffs, /* Allowed suffixes */
|
|
im_isppm, /* is_a */
|
|
im_ppm2vips_header, /* Load header only */
|
|
im_ppm2vips, /* Load */
|
|
im_vips2ppm /* Save */
|
|
};
|
|
|
|
static im_format analyze_desc = {
|
|
"analyze", /* internal name */
|
|
N_( "Analyze 6.0" ), /* i18n'd visible name */
|
|
0, /* Priority */
|
|
analyze_suffs, /* Allowed suffixes */
|
|
im_isanalyze, /* is_a */
|
|
im_analyze2vips_header, /* Load header only */
|
|
im_analyze2vips, /* Load */
|
|
NULL /* Save */
|
|
};
|
|
|
|
static im_format exr_desc = {
|
|
"exr", /* internal name */
|
|
N_( "OpenEXR" ), /* i18n'd visible name */
|
|
0, /* Priority */
|
|
exr_suffs, /* Allowed suffixes */
|
|
im_isexr, /* is_a */
|
|
im_exr2vips_header, /* Load header only */
|
|
im_exr2vips, /* Load */
|
|
NULL /* Save */
|
|
};
|
|
|
|
static im_format magick_desc = {
|
|
"magick", /* internal name */
|
|
N_( "ImageMagick-supported format" ), /* i18n'd visible name */
|
|
-1000, /* Priority */
|
|
magick_suffs, /* Allowed suffixes */
|
|
im_ismagick, /* is_a */
|
|
im_magick2vips_header, /* Load header only */
|
|
im_magick2vips, /* Load */
|
|
NULL /* Save */
|
|
};
|
|
|
|
/* Package up all these formats.
|
|
*/
|
|
static im_format *format_list[] = {
|
|
&csv_desc,
|
|
&jpeg_desc,
|
|
&magick_desc,
|
|
&png_desc,
|
|
&exr_desc,
|
|
&ppm_desc,
|
|
&analyze_desc,
|
|
&tiff_desc
|
|
};
|
|
|
|
/* Package of format.
|
|
*/
|
|
im_format_package im__format_format = {
|
|
"format",
|
|
IM_NUMBER( format_list ),
|
|
format_list
|
|
};
|