static int
icc_import_embedded_vec( im_object *argv )
{
int intent = *((int *) argv[2]);
return( im_icc_import_embedded( argv[0], argv[1], intent ) );
}
VALUE
img_icc_import_embedded(VALUE obj, VALUE intent)
{
ID id_intent = SYM2ID(intent);
GetImg(obj, data, im);
OutImg(obj, new, data_new, im_new);
if (im_icc_import_embedded(im, im_new, img_id_to_intent(id_intent)))
vips_lib_error();
return new;
}
static int
shrink_factor( IMAGE *in, IMAGE *out,
int shrink, double residual, VipsInterpolate *interp )
{
IMAGE *t[9];
VipsImage **s = (VipsImage **)
vips_object_local_array( VIPS_OBJECT( out ), 1 );
IMAGE *x;
int tile_width;
int tile_height;
int nlines;
if( im_open_local_array( out, t, 9, "thumbnail", "p" ) )
return( -1 );
x = in;
/* Unpack the two coded formats we support to float for processing.
*/
if( x->Coding == IM_CODING_LABQ ) {
if( verbose )
printf( "unpacking LAB to RGB\n" );
if( im_LabQ2disp( x, t[1], im_col_displays( 7 ) ) )
return( -1 );
x = t[1];
}
else if( x->Coding == IM_CODING_RAD ) {
if( verbose )
printf( "unpacking Rad to float\n" );
if( im_rad2float( x, t[1] ) )
return( -1 );
x = t[1];
}
if( im_shrink( x, t[2], shrink, shrink ) )
return( -1 );
/* We want to make sure we read the image sequentially.
* However, the convolution we may be doing later will force us
* into SMALLTILE or maybe FATSTRIP mode and that will break
* sequentiality.
*
* So ... read into a cache where tiles are scanlines, and make sure
* we keep enough scanlines to be able to serve a line of tiles.
*/
vips_get_tile_size( t[2],
&tile_width, &tile_height, &nlines );
if( vips_tilecache( t[2], &s[0],
"tile_width", t[2]->Xsize,
"tile_height", 10,
"max_tiles", (nlines * 2) / 10,
"strategy", VIPS_CACHE_SEQUENTIAL,
NULL ) ||
im_affinei_all( s[0], t[4],
interp, residual, 0, 0, residual, 0, 0 ) )
return( -1 );
x = t[4];
/* If we are upsampling, don't sharpen, since nearest looks dumb
* sharpened.
*/
if( shrink > 1 && residual <= 1.0 && !nosharpen ) {
if( verbose )
printf( "sharpening thumbnail\n" );
if( im_conv( x, t[5], sharpen_filter() ) )
return( -1 );
x = t[5];
}
/* Colour management: we can transform the image if we have an output
* profile and an input profile. The input profile can be in the
* image, or if there is no profile there, supplied by the user.
*/
if( export_profile &&
(im_header_get_typeof( x, IM_META_ICC_NAME ) ||
import_profile) ) {
if( im_header_get_typeof( x, IM_META_ICC_NAME ) ) {
if( verbose )
printf( "importing with embedded profile\n" );
if( im_icc_import_embedded( x, t[6],
IM_INTENT_RELATIVE_COLORIMETRIC ) )
return( -1 );
}
else {
if( verbose )
printf( "importing with profile %s\n",
import_profile );
if( im_icc_import( x, t[6],
import_profile,
IM_INTENT_RELATIVE_COLORIMETRIC ) )
return( -1 );
}
if( verbose )
printf( "exporting with profile %s\n", export_profile );
if( im_icc_export_depth( t[6], t[7],
8, export_profile,
IM_INTENT_RELATIVE_COLORIMETRIC ) )
return( -1 );
x = t[7];
}
if( delete_profile ) {
if( verbose )
printf( "deleting profile from output image\n" );
if( im_meta_get_typeof( x, IM_META_ICC_NAME ) &&
!im_meta_remove( x, IM_META_ICC_NAME ) )
return( -1 );
}
if( im_copy( x, out ) )
return( -1 );
return( 0 );
}