Writing a new loader

Add a new loader to VIPS by subclassing VipsForeignLoad. Subclasses need to implement at least header() .

header() must set at least the header fields of out . load() , if defined, must load the pixels to real .

The suffix list is used to select a format to save a file in, and to pick a loader if you don't define is_a().

You should also define nickname and description in VipsObject.

As a complete example, here's code for a PNG loader, minus the actual calls to libpng.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

typedef struct _VipsForeignLoadPng {
  VipsForeignLoad parent_object;

  char *filename; 
} VipsForeignLoadPng;

typedef VipsForeignLoadClass VipsForeignLoadPngClass;

G_DEFINE_TYPE( VipsForeignLoadPng, vips_foreign_load_png, 
  VIPS_TYPE_FOREIGN_LOAD );

static VipsForeignFlags
vips_foreign_load_png_get_flags_filename( const char *filename )
{
  VipsForeignFlags flags;

  flags = 0;
  if( vips__png_isinterlaced( filename ) )
  	flags = VIPS_FOREIGN_PARTIAL;
  else
  	flags = VIPS_FOREIGN_SEQUENTIAL;

  return( flags );
}

static VipsForeignFlags
vips_foreign_load_png_get_flags( VipsForeignLoad *load )
{
  VipsForeignLoadPng *png = (VipsForeignLoadPng *) load;

  return( vips_foreign_load_png_get_flags_filename( png->filename ) );
}

static int
vips_foreign_load_png_header( VipsForeignLoad *load )
{
  VipsForeignLoadPng *png = (VipsForeignLoadPng *) load;

  if( vips__png_header( png->filename, load->out ) )
  	return( -1 );

  return( 0 );
}

static int
vips_foreign_load_png_load( VipsForeignLoad *load )
{
  VipsForeignLoadPng *png = (VipsForeignLoadPng *) load;

  if( vips__png_read( png->filename, load->real ) )
  	return( -1 );

  return( 0 );
}

static void
vips_foreign_load_png_class_init( VipsForeignLoadPngClass *class )
{
  GObjectClass *gobject_class = G_OBJECT_CLASS( class );
  VipsObjectClass *object_class = (VipsObjectClass *) class;
  VipsForeignClass *foreign_class = (VipsForeignClass *) class;
  VipsForeignLoadClass *load_class = (VipsForeignLoadClass *) class;

  gobject_class->set_property = vips_object_set_property;
  gobject_class->get_property = vips_object_get_property;

  object_class->nickname = "pngload";
  object_class->description = _( "load png from file" );

  foreign_class->suffs = vips__png_suffs;

  load_class->is_a = vips__png_ispng;
  load_class->get_flags_filename = 
  	vips_foreign_load_png_get_flags_filename;
  load_class->get_flags = vips_foreign_load_png_get_flags;
  load_class->header = vips_foreign_load_png_header;
  load_class->load = vips_foreign_load_png_load;

  VIPS_ARG_STRING( class, "filename", 1, 
  	_( "Filename" ),
  	_( "Filename to load from" ),
  	VIPS_ARGUMENT_REQUIRED_INPUT, 
  	G_STRUCT_OFFSET( VipsForeignLoadPng, filename ),
  	NULL );
}

static void
vips_foreign_load_png_init( VipsForeignLoadPng *png )
{
}

Writing a new saver

Call your saver in the class' build() method after chaining up. The prepared image should be ready for you to save in ready .

As a complete example, here's the code for the CSV saver, minus the calls to the actual save routines.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

typedef struct _VipsForeignSaveCsv {
  VipsForeignSave parent_object;

  char *filename; 
  const char *separator;
} VipsForeignSaveCsv;

typedef VipsForeignSaveClass VipsForeignSaveCsvClass;

G_DEFINE_TYPE( VipsForeignSaveCsv, vips_foreign_save_csv, 
  VIPS_TYPE_FOREIGN_SAVE );

static int
vips_foreign_save_csv_build( VipsObject *object )
{
  VipsForeignSave *save = (VipsForeignSave *) object;
  VipsForeignSaveCsv *csv = (VipsForeignSaveCsv *) object;

  if( VIPS_OBJECT_CLASS( vips_foreign_save_csv_parent_class )->
  	build( object ) )
  	return( -1 );

  if( vips__csv_write( save->ready, csv->filename, csv->separator ) )
  	return( -1 );

  return( 0 );
}

static void
vips_foreign_save_csv_class_init( VipsForeignSaveCsvClass *class )
{
  GObjectClass *gobject_class = G_OBJECT_CLASS( class );
  VipsObjectClass *object_class = (VipsObjectClass *) class;
  VipsForeignClass *foreign_class = (VipsForeignClass *) class;
  VipsForeignSaveClass *save_class = (VipsForeignSaveClass *) class;

  gobject_class->set_property = vips_object_set_property;
  gobject_class->get_property = vips_object_get_property;

  object_class->nickname = "csvsave";
  object_class->description = _( "save image to csv file" );
  object_class->build = vips_foreign_save_csv_build;

  foreign_class->suffs = vips__foreign_csv_suffs;

  save_class->saveable = VIPS_SAVEABLE_MONO;
  // no need to define ->format_table, we don't want the input 
  // cast for us

  VIPS_ARG_STRING( class, "filename", 1, 
  	_( "Filename" ),
  	_( "Filename to save to" ),
  	VIPS_ARGUMENT_REQUIRED_INPUT, 
  	G_STRUCT_OFFSET( VipsForeignSaveCsv, filename ),
  	NULL );

  VIPS_ARG_STRING( class, "separator", 13, 
  	_( "Separator" ), 
  	_( "Separator characters" ),
  	VIPS_ARGUMENT_OPTIONAL_INPUT,
  	G_STRUCT_OFFSET( VipsForeignSaveCsv, separator ),
  	"\t" ); 
}

static void
vips_foreign_save_csv_init( VipsForeignSaveCsv *csv )
{
  csv->separator = g_strdup( "\t" );
}

vips_foreign_map ()

void *
vips_foreign_map (const char *base,
                  VipsSListMap2Fn fn,
                  void *a,
                  void *b);

Apply a function to every VipsForeignClass that VIPS knows about. Foreigns are presented to the function in priority order.

Like all VIPS map functions, if fn returns NULL, iteration continues. If it returns non-NULL, iteration terminates and that value is returned. The map function returns NULL if all calls return NULL.

See also: vips_slist_map().

vips_foreign_find_load ()

const char *
vips_foreign_find_load (const char *filename);

Searches for an operation you could use to load filename . Any trailing options on filename are stripped and ignored.

See also: vips_foreign_find_load_buffer(), vips_image_new_from_file().

vips_foreign_find_load_buffer ()

const char *
vips_foreign_find_load_buffer (const void *data,
                               size_t size);

Searches for an operation you could use to load a memory buffer. To see the range of buffer loaders supported by your vips, try something like:

vips -l | grep load_buffer

See also: vips_image_new_from_buffer().

vips_foreign_find_load_source ()

const char *
vips_foreign_find_load_source (VipsSource *source);

Searches for an operation you could use to load a source. To see the range of source loaders supported by your vips, try something like:

vips -l | grep load_source

See also: vips_image_new_from_source().

vips_foreign_flags ()

VipsForeignFlags
vips_foreign_flags (const char *loader,
                    const char *filename);

Return the flags for filename using loader . loader is something like "tiffload" or "VipsForeignLoadTiff".

vips_foreign_is_a ()

gboolean
vips_foreign_is_a (const char *loader,
                   const char *filename);

Return TRUE if filename can be loaded by loader . loader is something like "tiffload" or "VipsForeignLoadTiff".

vips_foreign_is_a_buffer ()

gboolean
vips_foreign_is_a_buffer (const char *loader,
                          const void *data,
                          size_t size);

Return TRUE if data can be loaded by loader . loader is something like "tiffload_buffer" or "VipsForeignLoadTiffBuffer".

vips_foreign_is_a_source ()

gboolean
vips_foreign_is_a_source (const char *loader,
                          VipsSource *source);

Return TRUE if source can be loaded by loader . loader is something like "tiffload_source" or "VipsForeignLoadTiffSource".

vips_foreign_load_invalidate ()

void
vips_foreign_load_invalidate (VipsImage *image);

Loaders can call this on the image they are making if they see a read error from the load library. It signals "invalidate" on the load operation and will cause it to be dropped from cache.

If we know a file will cause a read error, we don't want to cache the failing operation, we want to make sure the image will really be opened again if our caller tries again. For example, a broken file might be replaced by a working one.

[method]

vips_foreign_find_save ()

const char *
vips_foreign_find_save (const char *filename);

Searches for an operation you could use to write to filename . Any trailing options on filename are stripped and ignored.

See also: vips_foreign_find_save_buffer(), vips_image_write_to_file().

vips_foreign_get_suffixes ()

gchar **
vips_foreign_get_suffixes (void);

Get a NULL-terminated array listing all the supported suffixes.

This is not the same as all the supported file types, since libvips detects image format for load by testing the first few bytes.

Use vips_foreign_find_load() to detect type for a specific file.

Free the return result with g_strfreev().

vips_foreign_find_save_buffer ()

const char *
vips_foreign_find_save_buffer (const char *suffix);

Searches for an operation you could use to write to a buffer in suffix format.

See also: vips_image_write_to_buffer().

vips_foreign_find_save_target ()

const char *
vips_foreign_find_save_target (const char *suffix);

Searches for an operation you could use to write to a target in suffix format.

See also: vips_image_write_to_buffer().

vips_vipsload ()

int
vips_vipsload (const char *filename,
               VipsImage **out,
               ...);

Read in a vips image.

See also: vips_vipssave().

vips_vipsload_source ()

int
vips_vipsload_source (VipsSource *source,
                      VipsImage **out,
                      ...);

Exactly as vips_vipsload(), but read from a source.

vips_vipssave ()

int
vips_vipssave (VipsImage *in,
               const char *filename,
               ...);

Write in to filename in VIPS format.

See also: vips_vipsload().

[method]

vips_vipssave_target ()

int
vips_vipssave_target (VipsImage *in,
                      VipsTarget *target,
                      ...);

As vips_vipssave(), but save to a target.

[method]

vips_openslideload ()

int
vips_openslideload (const char *filename,
                    VipsImage **out,
                    ...);

Optional arguments:

Read a virtual slide supported by the OpenSlide library into a VIPS image. OpenSlide supports images in Aperio, Hamamatsu, MIRAX, Sakura, Trestle, and Ventana formats.

To facilitate zooming, virtual slide formats include multiple scaled-down versions of the high-resolution image. These are typically called "levels". By default, vips_openslideload() reads the highest-resolution level (level 0). Set level to the level number you want.

In addition to the slide image itself, virtual slide formats sometimes include additional images, such as a scan of the slide's barcode. OpenSlide calls these "associated images". To read an associated image, set associated to the image's name. A slide's associated images are listed in the "slide-associated-images" metadata item.

If you set attach_associated , then all associated images are attached as metadata items. Use vips_image_get_image() on out to retrieve them. Images are attached as "openslide-associated-XXXXX", where XXXXX is the name of the associated image.

The output of this operator is always RGBA.

See also: vips_image_new_from_file().

vips_openslideload_source ()

int
vips_openslideload_source (VipsSource *source,
                           VipsImage **out,
                           ...);

Optional arguments:

Exactly as vips_openslideload(), but read from a source.

vips_jpegload ()

int
vips_jpegload (const char *filename,
               VipsImage **out,
               ...);

Optional arguments:

Read a JPEG file into a VIPS image. It can read most 8-bit JPEG images, including CMYK and YCbCr.

shrink means shrink by this integer factor during load. Possible values are 1, 2, 4 and 8. Shrinking during read is very much faster than decompressing the whole image and then shrinking later.

Use fail_on to set the type of error that will cause load to fail. By default, loaders are permissive, that is, VIPS_FAIL_ON_NONE.

Setting autorotate to TRUE will make the loader interpret the orientation tag and automatically rotate the image appropriately during load.

If autorotate is FALSE, the metadata field VIPS_META_ORIENTATION is set to the value of the orientation tag. Applications may read and interpret this field as they wish later in processing. See vips_autorot(). Save operations will use VIPS_META_ORIENTATION, if present, to set the orientation of output images.

Example:

1
2
3
4

vips_jpegload( "fred.jpg", &out,
	"shrink", 8,
	"fail_on", VIPS_FAIL_ON_TRUNCATED,
	NULL );

Any embedded ICC profiles are ignored: you always just get the RGB from the file. Instead, the embedded profile will be attached to the image as VIPS_META_ICC_NAME. You need to use something like vips_icc_import() to get CIE values from the file.

EXIF metadata is attached as VIPS_META_EXIF_NAME, IPTC as VIPS_META_IPTC_NAME, and XMP as VIPS_META_XMP_NAME.

The int metadata item "jpeg-multiscan" is set to the result of jpeg_has_multiple_scans(). Interlaced jpeg images need a large amount of memory to load, so this field gives callers a chance to handle these images differently.

The string-valued field "jpeg-chroma-subsample" gives the chroma subsample in standard notation. 4:4:4 means no subsample, 4:2:0 means YCbCr with Cb and Cr subsampled horizontally and vertically, 4:4:4:4 means a CMYK image with no subsampling.

The EXIF thumbnail, if present, is attached to the image as "jpeg-thumbnail-data". See vips_image_get_blob().

See also: vips_jpegload_buffer(), vips_image_new_from_file(), vips_autorot().

vips_jpegload_buffer ()

int
vips_jpegload_buffer (void *buf,
                      size_t len,
                      VipsImage **out,
                      ...);

Optional arguments:

Read a JPEG-formatted memory block into a VIPS image. Exactly as vips_jpegload(), but read from a memory buffer.

You must not free the buffer while out is active. The “postclose” signal on out is a good place to free.

See also: vips_jpegload().

vips_jpegload_source ()

int
vips_jpegload_source (VipsSource *source,
                      VipsImage **out,
                      ...);

Optional arguments:

Read a JPEG-formatted memory block into a VIPS image. Exactly as vips_jpegload(), but read from a source.

See also: vips_jpegload().

vips_jpegsave_target ()

int
vips_jpegsave_target (VipsImage *in,
                      VipsTarget *target,
                      ...);

Optional arguments:

As vips_jpegsave(), but save to a target.

See also: vips_jpegsave(), vips_image_write_to_target().

[method]

vips_jpegsave ()

int
vips_jpegsave (VipsImage *in,
               const char *filename,
               ...);

Optional arguments:

Write a VIPS image to a file as JPEG.

Use Q to set the JPEG compression factor. Default 75.

Use profile to give the name of a profile to be embedded in the JPEG. This does not affect the pixels which are written, just the way they are tagged. See vips_profile_load() for details on profile naming.

If no profile is specified and the VIPS header contains an ICC profile named VIPS_META_ICC_NAME, the profile from the VIPS header will be attached.

If optimize_coding is set, the Huffman tables are optimized. This is sllightly slower and produces slightly smaller files.

If interlace is set, the jpeg files will be interlaced (progressive jpeg, in jpg parlance). These files may be better for display over a slow network conection, but need much more memory to encode and decode.

If strip is set, no EXIF data, IPTC data, ICC profile or XMP metadata is written into the output file.

Chroma subsampling is normally automatically disabled for Q >= 90. You can force the subsampling mode with subsample_mode .

If trellis_quant is set and the version of libjpeg supports it (e.g. mozjpeg >= 3.0), apply trellis quantisation to each 8x8 block. Reduces file size but increases compression time.

If overshoot_deringing is set and the version of libjpeg supports it (e.g. mozjpeg >= 3.0), apply overshooting to samples with extreme values for example 0 and 255 for 8-bit. Overshooting may reduce ringing artifacts from compression, in particular in areas where black text appears on a white background.

If optimize_scans is set and the version of libjpeg supports it (e.g. mozjpeg >= 3.0), split the spectrum of DCT coefficients into separate scans. Reduces file size but increases compression time.

If quant_table is set and the version of libjpeg supports it (e.g. mozjpeg >= 3.0) it selects the quantization table to use:

Quantization table 0 is the default in vips and libjpeg(-turbo), but it tends to favor detail over color accuracy, producting colored patches and stripes as well as heavy banding in flat areas at high compression ratios. Quantization table 2 is a good candidate to try if the default quantization table produces banding or color shifts and is well suited for hires images. Quantization table 3 is the default in mozjpeg and has been tuned to produce good results at the default quality setting; banding at high compression. Quantization table 4 is the most accurate at the cost of compression ratio. Tables 5-7 are based on older research papers, but generally achieve worse compression ratios and/or quality than 2 or 4.

For maximum compression with mozjpeg, a useful set of options is strip, optimize-coding, interlace, optimize-scans, trellis-quant, quant_table=3.

By default, the output stream won't have restart markers. If a non-zero restart_interval is specified, a restart marker will be added after each specified number of MCU blocks. This makes the stream more recoverable if there are transmission errors, but also allows for some decoders to read part of the JPEG without decoding the whole stream.

The image is automatically converted to RGB, Monochrome or CMYK before saving.

EXIF data is constructed from VIPS_META_EXIF_NAME, then modified with any other related tags on the image before being written to the file. VIPS_META_RESOLUTION_UNIT is used to set the EXIF resolution unit. VIPS_META_ORIENTATION is used to set the EXIF orientation tag.

IPTC as VIPS_META_IPTC_NAME and XMP as VIPS_META_XMP_NAME are coded and attached.

See also: vips_jpegsave_buffer(), vips_image_write_to_file().

[method]

vips_jpegsave_buffer ()

int
vips_jpegsave_buffer (VipsImage *in,
                      void **buf,
                      size_t *len,
                      ...);

Optional arguments:

As vips_jpegsave(), but save to a memory buffer.

The address of the buffer is returned in obuf , the length of the buffer in olen . You are responsible for freeing the buffer with g_free() when you are done with it.

See also: vips_jpegsave(), vips_image_write_to_file().

[method]

vips_jpegsave_mime ()

int
vips_jpegsave_mime (VipsImage *in,
                    ...);

Optional arguments:

As vips_jpegsave(), but save as a mime jpeg on stdout.

See also: vips_jpegsave(), vips_image_write_to_file().

[method]

vips_webpload_source ()

int
vips_webpload_source (VipsSource *source,
                      VipsImage **out,
                      ...);

Optional arguments:

Exactly as vips_webpload(), but read from a source.

See also: vips_webpload()

vips_webpload ()

int
vips_webpload (const char *filename,
               VipsImage **out,
               ...);

Optional arguments:

Read a WebP file into a VIPS image.

Use page to select a page to render, numbering from zero.

Use n to select the number of pages to render. The default is 1. Pages are rendered in a vertical column, with each individual page aligned to the left. Set to -1 to mean "until the end of the document". Use vips_grid() to change page layout.

Use scale to specify a scale-on-load factor. For example, 2.0 to double the size on load. Animated webp images don't support shrink-on-load, so a further resize may be necessary.

The loader supports ICC, EXIF and XMP metadata.

See also: vips_image_new_from_file().

vips_webpload_buffer ()

int
vips_webpload_buffer (void *buf,
                      size_t len,
                      VipsImage **out,
                      ...);

Optional arguments:

Read a WebP-formatted memory block into a VIPS image. Exactly as vips_webpload(), but read from a memory buffer.

You must not free the buffer while out is active. The “postclose” signal on out is a good place to free.

See also: vips_webpload()

vips_webpsave_target ()

int
vips_webpsave_target (VipsImage *in,
                      VipsTarget *target,
                      ...);

Optional arguments:

As vips_webpsave(), but save to a target.

See also: vips_webpsave().

[method]

vips_webpsave ()

int
vips_webpsave (VipsImage *in,
               const char *filename,
               ...);

Optional arguments:

Write an image to a file in WebP format.

By default, images are saved in lossy format, with Q giving the WebP quality factor. It has the range 0 - 100, with the default 75.

Use preset to hint the image type to the lossy compressor. The default is VIPS_FOREIGN_WEBP_PRESET_DEFAULT.

Set smart_subsample to enable high quality chroma subsampling.

Use alpha_q to set the quality for the alpha channel in lossy mode. It has the range 1 - 100, with the default 100.

Use effort to control how much CPU time to spend attempting to reduce file size. A higher value means more effort and therefore CPU time should be spent. It has the range 0-6 and a default value of 4.

Set lossless to use lossless compression, or combine near_lossless with Q 80, 60, 40 or 20 to apply increasing amounts of preprocessing which improves the near-lossless compression ratio by up to 50%.

For animated webp output, min_size will try to optimize for minimum size.

For animated webp output, kmax sets the maximum number of frames between keyframes. Setting 0 means only keyframes. kmin sets the minimum number of frames between frames. Setting 0 means no keyframes. By default, keyframes are disabled.

For animated webp output, mixed tries to improve the file size by mixing both lossy and lossless encoding.

Use profile to give the name of a profile to be embedded in the file. This does not affect the pixels which are written, just the way they are tagged. See vips_profile_load() for details on profile naming.

Use the metadata items loop and delay to set the number of loops for the animation and the frame delays.

The writer will attach ICC, EXIF and XMP metadata, unless strip is set to TRUE.

See also: vips_webpload(), vips_image_write_to_file().

[method]

vips_webpsave_buffer ()

int
vips_webpsave_buffer (VipsImage *in,
                      void **buf,
                      size_t *len,
                      ...);

Optional arguments:

As vips_webpsave(), but save to a memory buffer.

The address of the buffer is returned in buf , the length of the buffer in len . You are responsible for freeing the buffer with g_free() when you are done with it.

See also: vips_webpsave().

[method]

vips_webpsave_mime ()

int
vips_webpsave_mime (VipsImage *in,
                    ...);

Optional arguments:

As vips_webpsave(), but save as a mime webp on stdout.

See also: vips_webpsave(), vips_image_write_to_file().

[method]

vips_tiffload ()

int
vips_tiffload (const char *filename,
               VipsImage **out,
               ...);

Optional arguments:

Read a TIFF file into a VIPS image. It is a full baseline TIFF 6 reader, with extensions for tiled images, multipage images, XYZ and LAB colour space, pyramidal images and JPEG compression, including CMYK and YCbCr.

page means load this page from the file. By default the first page (page 0) is read.

n means load this many pages. By default a single page is read. All the pages must have the same dimensions, and they are loaded as a tall, thin "toilet roll" image. The VIPS_META_PAGE_HEIGHT metadata tag gives the height in pixels of each page. Use -1 to load all pages.

Setting autorotate to TRUE will make the loader interpret the orientation tag and automatically rotate the image appropriately during load.

If autorotate is FALSE, the metadata field VIPS_META_ORIENTATION is set to the value of the orientation tag. Applications may read and interpret this field as they wish later in processing. See vips_autorot(). Save operations will use VIPS_META_ORIENTATION, if present, to set the orientation of output images.

If autorotate is TRUE, the image will be rotated upright during load and no metadata attached. This can be very slow.

If subifd is -1 (the default), the main image is selected for each page. If it is 0 or greater and there is a SUBIFD tag, the indexed SUBIFD is selected. This can be used to read lower resolution layers from bioformats-style image pyramids.

Any ICC profile is read and attached to the VIPS image as VIPS_META_ICC_NAME. Any XMP metadata is read and attached to the image as VIPS_META_XMP_NAME. Any IPTC is attached as VIPS_META_IPTC_NAME. The image description is attached as VIPS_META_IMAGEDESCRIPTION. Data in the photoshop tag is attached as VIPS_META_PHOTOSHOP_NAME.

See also: vips_image_new_from_file(), vips_autorot().

vips_tiffload_buffer ()

int
vips_tiffload_buffer (void *buf,
                      size_t len,
                      VipsImage **out,
                      ...);

Optional arguments:

Read a TIFF-formatted memory block into a VIPS image. Exactly as vips_tiffload(), but read from a memory source.

You must not free the buffer while out is active. The “postclose” signal on out is a good place to free.

See also: vips_tiffload().

vips_tiffload_source ()

int
vips_tiffload_source (VipsSource *source,
                      VipsImage **out,
                      ...);

Optional arguments:

Exactly as vips_tiffload(), but read from a source.

See also: vips_tiffload().

vips_tiffsave ()

int
vips_tiffsave (VipsImage *in,
               const char *filename,
               ...);

Optional arguments:

Write a VIPS image to a file as TIFF.

If in has the VIPS_META_PAGE_HEIGHT metadata item, this is assumed to be a "toilet roll" image. It will be written as series of pages, each VIPS_META_PAGE_HEIGHT pixels high.

Use compression to set the tiff compression. Currently jpeg, packbits, fax4, lzw, none, deflate, webp and zstd are supported. The default is no compression. JPEG compression is a good lossy compressor for photographs, packbits is good for 1-bit images, and deflate is the best lossless compression TIFF can do.

XYZ images are automatically saved as libtiff LOGLUV with SGILOG compression. Float LAB images are saved as float CIELAB. Set bitdepth to save as 8-bit CIELAB.

Use Q to set the JPEG compression factor. Default 75.

User level to set the ZSTD compression level. Use lossless to set WEBP lossless mode on. Use Q to set the WEBP compression level.

Use predictor to set the predictor for lzw, deflate and zstd compression. It defaults to VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL, meaning horizontal differencing. Please refer to the libtiff specifications for further discussion of various predictors.

Use profile to give the filename of a profile to be embedded in the TIFF. This does not affect the pixels which are written, just the way they are tagged. See vips_profile_load() for details on profile naming.

If no profile is specified and the VIPS header contains an ICC profile named VIPS_META_ICC_NAME, the profile from the VIPS header will be attached.

Set tile to TRUE to write a tiled tiff. By default tiff are written in strips. Use tile_width and tile_height to set the tile size. The defaiult is 128 by 128.

Set pyramid to write the image as a set of images, one per page, of decreasing size. Use region_shrink to set how images will be shrunk: by default each 2x2 block is just averaged, but you can set MODE or MEDIAN as well.

By default, the pyramid stops when the image is small enough to fit in one tile. Use depth to stop when the image fits in one pixel, or to only write a single layer.

Set bitdepth to save 8-bit uchar images as 1, 2 or 4-bit TIFFs. In case of depth 1: Values >128 are written as white, values <=128 as black. Normally vips will write MINISBLACK TIFFs where black is a 0 bit, but if you set miniswhite , it will use 0 for a white bit. Many pre-press applications only work with images which use this sense. miniswhite only affects one-bit images, it does nothing for greyscale images. In case of depth 2: The same holds but values < 64 are written as black. For 64 <= values < 128 they are written as dark grey, for 128 <= values < 192 they are written as light gray and values above are written as white. In case miniswhite is set to true this behavior is inverted. In case of depth 4: values < 16 are written as black, and so on for the lighter shades. In case miniswhite is set to true this behavior is inverted.

Use resunit to override the default resolution unit. The default resolution unit is taken from the header field VIPS_META_RESOLUTION_UNIT. If this field is not set, then VIPS defaults to cm.

Use xres and yres to override the default horizontal and vertical resolutions. By default these values are taken from the VIPS image header. libvips resolution is always in pixels per millimetre.

Set bigtiff to attempt to write a bigtiff. Bigtiff is a variant of the TIFF format that allows more than 4GB in a file.

Set properties to write all vips metadata to the IMAGEDESCRIPTION tag as xml. If properties is not set, the value of VIPS_META_IMAGEDESCRIPTION is used instead.

The value of VIPS_META_XMP_NAME is written to the XMP tag. VIPS_META_ORIENTATION (if set) is used to set the value of the orientation tag. VIPS_META_IPTC (if set) is used to set the value of the IPTC tag. VIPS_META_PHOTOSHOP_NAME (if set) is used to set the value of the PHOTOSHOP tag.

By default, pyramid layers are saved as consecutive pages. Set subifd to save pyramid layers as sub-directories of the main image. Setting this option can improve compatibility with formats like OME.

Set premultiply to save with premultiplied alpha. Some programs, such as InDesign, will only work with premultiplied alpha.

See also: vips_tiffload(), vips_image_write_to_file().

[method]

vips_tiffsave_buffer ()

int
vips_tiffsave_buffer (VipsImage *in,
                      void **buf,
                      size_t *len,
                      ...);

Optional arguments:

As vips_tiffsave(), but save to a memory buffer.

The address of the buffer is returned in buf , the length of the buffer in len . You are responsible for freeing the buffer with g_free() when you are done with it.

See also: vips_tiffsave(), vips_image_write_to_file().

[method]

vips_tiffsave_target ()

int
vips_tiffsave_target (VipsImage *in,
                      VipsTarget *target,
                      ...);

Optional arguments:

As vips_tiffsave(), but save to a target.

See also: vips_tiffsave(), vips_image_write_to_target().

[method]

vips_openexrload ()

int
vips_openexrload (const char *filename,
                  VipsImage **out,
                  ...);

Read a OpenEXR file into a VIPS image.

The reader can handle scanline and tiled OpenEXR images. It can't handle OpenEXR colour management, image attributes, many pixel formats, anything other than RGBA.

This reader uses the rather limited OpenEXR C API. It should really be redone in C++.

See also: vips_image_new_from_file().

vips_fitsload ()

int
vips_fitsload (const char *filename,
               VipsImage **out,
               ...);

Read a FITS image file into a VIPS image.

This operation can read images with up to three dimensions. Any higher dimensions must be empty.

It can read 8, 16 and 32-bit integer images, signed and unsigned, float and double.

FITS metadata is attached with the "fits-" prefix.

See also: vips_image_new_from_file().

vips_fitssave ()

int
vips_fitssave (VipsImage *in,
               const char *filename,
               ...);

Write a VIPS image to a file in FITS format.

See also: vips_image_write_to_file().

[method]

vips_analyzeload ()

int
vips_analyzeload (const char *filename,
                  VipsImage **out,
                  ...);

Load an Analyze 6.0 file. If filename is "fred.img", this will look for an image header called "fred.hdr" and pixel data in "fred.img". You can also load "fred" or "fred.hdr".

Images are loaded lazilly and byte-swapped, if necessary. The Analyze metadata is read and attached.

See also: vips_image_new_from_file().

vips_rawload ()

int
vips_rawload (const char *filename,
              VipsImage **out,
              int width,
              int height,
              int bands,
              ...);

Optional arguments:

This operation mmaps the file, setting up out so that access to that image will read from the file.

By default, it assumes uchar pixels. Use format to select something else.

The image will be tagged as VIPS_INTERPRETATION_MULTIBAND. Use interpretation to select something else.

Use vips_byteswap() to reverse the byte ordering if necessary.

See also: vips_image_new_from_file(), vips_copy(), vips_byteswap().

vips_rawsave ()

int
vips_rawsave (VipsImage *in,
              const char *filename,
              ...);

Writes the pixels in in to the file filename with no header or other metadata.

See also: vips_image_write_to_file().

[method]

vips_rawsave_fd ()

int
vips_rawsave_fd (VipsImage *in,
                 int fd,
                 ...);

Writes the pixels in in to the fd with no header or other metadata. Handy for implementing other savers.

See also: vips_rawsave().

[method]

vips_csvload ()

int
vips_csvload (const char *filename,
              VipsImage **out,
              ...);

Optional arguments:

Load a CSV (comma-separated values) file. The output image is always 1 band (monochrome), VIPS_FORMAT_DOUBLE. Use vips_bandfold() to turn RGBRGBRGB mono images into colour iamges.

Items in lines can be either floating point numbers in the C locale, or strings enclosed in double-quotes ("), or empty. You can use a backslash() within the quotes to escape special characters, such as quote marks.

skip sets the number of lines to skip at the start of the file. Default zero.

lines sets the number of lines to read from the file. Default -1, meaning read all lines to end of file.

whitespace sets the skippable whitespace characters. Default <emphasis>space</emphasis>. Whitespace characters are always run together.

separator sets the characters that separate fields. Default ;,<emphasis>tab</emphasis>. Separators are never run together.

Use fail_on to set the type of error that will cause load to fail. By default, loaders are permissive, that is, VIPS_FAIL_ON_NONE.

See also: vips_image_new_from_file(), vips_bandfold().

vips_csvload_source ()

int
vips_csvload_source (VipsSource *source,
                     VipsImage **out,
                     ...);

Optional arguments:

Exactly as vips_csvload(), but read from a source.

See also: vips_csvload().

vips_csvsave ()

int
vips_csvsave (VipsImage *in,
              const char *filename,
              ...);

Optional arguments:

Writes the pixels in in to the filename as CSV (comma-separated values). The image is written one line of text per scanline. Complex numbers are written as "(real,imaginary)" and will need extra parsing I guess. Only the first band is written.

separator gives the string to use to separate numbers in the output. The default is "\t" (tab).

See also: vips_image_write_to_file().

[method]

vips_csvsave_target ()

int
vips_csvsave_target (VipsImage *in,
                     VipsTarget *target,
                     ...);

Optional arguments:

As vips_csvsave(), but save to a target.

See also: vips_csvsave().

[method]

vips_matrixload ()

int
vips_matrixload (const char *filename,
                 VipsImage **out,
                 ...);

Reads a matrix from a file.

Matrix files have a simple format that's supposed to be easy to create with a text editor or a spreadsheet.

The first line has four numbers for width, height, scale and offset (scale and offset may be omitted, in which case they default to 1.0 and 0.0). Scale must be non-zero. Width and height must be positive integers. The numbers are separated by any mixture of spaces, commas, tabs and quotation marks ("). The scale and offset fields may be floating-point, and must use '.' as a decimal separator.

Subsequent lines each hold one row of matrix data, with numbers again separated by any mixture of spaces, commas, tabs and quotation marks ("). The numbers may be floating-point, and must use '.' as a decimal separator.

Extra characters at the ends of lines or at the end of the file are ignored.

See also: vips_matrixload().

vips_matrixload_source ()

int
vips_matrixload_source (VipsSource *source,
                        VipsImage **out,
                        ...);

Exactly as vips_matrixload(), but read from a source.

See also: vips_matrixload().

vips_matrixsave ()

int
vips_matrixsave (VipsImage *in,
                 const char *filename,
                 ...);

Write in to filename in matrix format. See vips_matrixload() for a description of the format.

See also: vips_matrixload().

[method]

vips_matrixsave_target ()

int
vips_matrixsave_target (VipsImage *in,
                        VipsTarget *target,
                        ...);

As vips_matrixsave(), but save to a target.

See also: vips_matrixsave().

[method]

vips_matrixprint ()

int
vips_matrixprint (VipsImage *in,
                  ...);

Print in to stdout in matrix format. See vips_matrixload() for a description of the format.

See also: vips_matrixload().

[method]

vips_magickload ()

int
vips_magickload (const char *filename,
                 VipsImage **out,
                 ...);

Optional arguments: