static int
vips_replicate_build( VipsObject *object )
{
VipsConversion *conversion = VIPS_CONVERSION( object );
VipsReplicate *replicate = (VipsReplicate *) object;
if( VIPS_OBJECT_CLASS( vips_replicate_parent_class )->build( object ) )
return( -1 );
if( vips_image_pio_input( replicate->in ) )
return( -1 );
if( vips_image_copy_fields( conversion->out, replicate->in ) )
return( -1 );
vips_demand_hint( conversion->out,
VIPS_DEMAND_STYLE_SMALLTILE, replicate->in, NULL );
conversion->out->Xsize *= replicate->across;
conversion->out->Ysize *= replicate->down;
if( vips_image_generate( conversion->out,
vips_start_one, vips_replicate_gen, vips_stop_one,
replicate->in, replicate ) )
return( -1 );
return( 0 );
}
static int
vips_sequential_build( VipsObject *object )
{
VipsConversion *conversion = VIPS_CONVERSION( object );
VipsSequential *sequential = (VipsSequential *) object;
VipsImage *t;
VIPS_DEBUG_MSG( "vips_sequential_build\n" );
if( VIPS_OBJECT_CLASS( vips_sequential_parent_class )->build( object ) )
return( -1 );
if( vips_image_pio_input( sequential->in ) )
return( -1 );
if( vips_linecache( sequential->in, &t,
"tile_height", sequential->tile_height,
"access", sequential->access,
NULL ) )
return( -1 );
vips_object_local( object, t );
if( vips_image_pipelinev( conversion->out,
VIPS_DEMAND_STYLE_THINSTRIP, t, NULL ) )
return( -1 );
if( vips_image_generate( conversion->out,
vips_start_one, vips_sequential_generate, vips_stop_one,
t, sequential ) )
return( -1 );
return( 0 );
}
static int
vips_statistic_build( VipsObject *object )
{
VipsStatistic *statistic = VIPS_STATISTIC( object );
VipsObjectClass *class = VIPS_OBJECT_GET_CLASS( object );
const char *domain = class->nickname;
#ifdef DEBUG
printf( "vips_statistic_build: " );
vips_object_print_name( object );
printf( "\n" );
#endif /*DEBUG*/
if( VIPS_OBJECT_CLASS( vips_statistic_parent_class )->build( object ) )
return( -1 );
if( vips_image_pio_input( statistic->in ) ||
vips_check_uncoded( domain, statistic->in ) )
return( -1 );
if( vips_sink( statistic->in,
vips_statistic_scan_start,
vips_statistic_scan,
vips_statistic_scan_stop,
statistic, NULL ) )
return( -1 );
return( 0 );
}
static int
vips_tile_cache_build( VipsObject *object )
{
VipsConversion *conversion = VIPS_CONVERSION( object );
VipsTileCache *cache = (VipsTileCache *) object;
VIPS_DEBUG_MSG( "vips_tile_cache_build\n" );
if( VIPS_OBJECT_CLASS( vips_tile_cache_parent_class )->build( object ) )
return( -1 );
if( vips_image_pio_input( cache->in ) )
return( -1 );
if( vips_image_copy_fields( conversion->out, cache->in ) )
return( -1 );
vips_demand_hint( conversion->out,
VIPS_DEMAND_STYLE_SMALLTILE, cache->in, NULL );
if( vips_image_generate( conversion->out,
vips_start_one, vips_tile_cache_gen, vips_stop_one,
cache->in, cache ) )
return( -1 );
return( 0 );
}
int
vips__ppm_save( VipsImage *in, const char *filename, gboolean ascii )
{
Write *write;
if( vips_check_uintorf( "vips2ppm", in ) ||
vips_check_bands_1or3( "vips2ppm", in ) ||
vips_check_uncoded( "vips2ppm", in ) ||
vips_image_pio_input( in ) )
return( -1 );
/* We can only write >8 bit binary images in float.
*/
if( vips_format_sizeof( in->BandFmt ) > 1 &&
!ascii &&
in->BandFmt != VIPS_FORMAT_FLOAT ) {
vips_error( "vips2ppm",
"%s", _( "binary >8 bit images must be float" ) );
return( -1 );
}
if( !(write = write_new( in, filename )) )
return( -1 );
if( write_ppm( write, ascii ) ) {
write_destroy( write );
return( -1 );
}
write_destroy( write );
return( 0 );
}
static int
vips_sequential_build( VipsObject *object )
{
VipsConversion *conversion = VIPS_CONVERSION( object );
VipsSequential *sequential = (VipsSequential *) object;
VIPS_DEBUG_MSG( "vips_sequential_build\n" );
if( VIPS_OBJECT_CLASS( vips_sequential_parent_class )->build( object ) )
return( -1 );
if( vips_image_pio_input( sequential->in ) )
return( -1 );
if( vips_image_copy_fields( conversion->out, sequential->in ) )
return( -1 );
vips_demand_hint( conversion->out,
VIPS_DEMAND_STYLE_FATSTRIP, sequential->in, NULL );
if( vips_image_generate( conversion->out,
vips_start_one, vips_sequential_generate, vips_stop_one,
sequential->in, sequential ) )
return( -1 );
return( 0 );
}
static int
vips_recomb_build( VipsObject *object )
{
VipsConversion *conversion = (VipsConversion *) object;
VipsRecomb *recomb = (VipsRecomb *) object;
VipsImage **t = (VipsImage **) vips_object_local_array( object, 2 );
if( VIPS_OBJECT_CLASS( vips_recomb_parent_class )->build( object ) )
return( -1 );
if( vips_image_pio_input( recomb->in ) ||
vips_check_uncoded( "VipsRecomb", recomb->in ) ||
vips_check_noncomplex( "VipsRecomb", recomb->in ) )
return( -1 );
if( vips_image_pio_input( recomb->m ) ||
vips_check_uncoded( "VipsRecomb", recomb->m ) ||
vips_check_noncomplex( "VipsRecomb", recomb->m ) ||
vips_check_mono( "VipsRecomb", recomb->m ) )
return( -1 );
if( recomb->in->Bands != recomb->m->Xsize ) {
vips_error( "VipsRecomb",
"%s", _( "bands in must equal matrix width" ) );
return( -1 );
}
if( vips_cast( recomb->m, &t[0], VIPS_FORMAT_DOUBLE, NULL ) ||
vips_image_wio_input( t[0] ) )
return( -1 );
recomb->coeff = (double *) VIPS_IMAGE_ADDR( t[0], 0, 0 );
if( vips_image_copy_fields( conversion->out, recomb->in ) )
return( -1 );
vips_demand_hint( conversion->out,
VIPS_DEMAND_STYLE_THINSTRIP, recomb->in, NULL );
conversion->out->Bands = recomb->m->Ysize;
if( vips_bandfmt_isint( recomb->in->BandFmt ) )
conversion->out->BandFmt = VIPS_FORMAT_FLOAT;
if( vips_image_generate( conversion->out,
vips_start_one, vips_recomb_gen, vips_stop_one,
recomb->in, recomb ) )
return( -1 );
return( 0 );
}
static int
vips_bandary_build( VipsObject *object )
{
VipsConversion *conversion = VIPS_CONVERSION( object );
VipsBandary *bandary = (VipsBandary *) object;
int i;
VipsImage **format;
VipsImage **size;
if( VIPS_OBJECT_CLASS( vips_bandary_parent_class )->build( object ) )
return( -1 );
if( bandary->n <= 0 ) {
vips_error( "VipsBandary", "%s", _( "no input images" ) );
return( -1 );
}
if( bandary->n > MAX_INPUT_IMAGES ) {
vips_error( "VipsBandary", "%s", _( "too many input images" ) );
return( -1 );
}
if( vips_image_pio_output( conversion->out ) )
return( -1 );
for( i = 0; i < bandary->n; i++ )
if( vips_image_pio_input( bandary->in[i] ) ||
vips_check_uncoded( "VipsBandary", bandary->in[i] ) )
return( -1 );
format = (VipsImage **) vips_object_local_array( object, bandary->n );
size = (VipsImage **) vips_object_local_array( object, bandary->n );
if( vips__formatalike_vec( bandary->in, format, bandary->n ) ||
vips__sizealike_vec( format, size, bandary->n ) )
return( -1 );
bandary->ready = size;
if( vips_image_copy_fields_array( conversion->out, bandary->ready ) )
return( -1 );
vips_demand_hint_array( conversion->out,
VIPS_DEMAND_STYLE_THINSTRIP, bandary->ready );
conversion->out->Bands = bandary->out_bands;
if( vips_image_generate( conversion->out,
vips_start_many, vips_bandary_gen, vips_stop_many,
bandary->ready, bandary ) )
return( -1 );
return( 0 );
}
static int
vips_byteswap_build( VipsObject *object )
{
VipsConversion *conversion = VIPS_CONVERSION( object );
VipsByteswap *byteswap = (VipsByteswap *) object;
if( VIPS_OBJECT_CLASS( vips_byteswap_parent_class )->build( object ) )
return( -1 );
if( vips_image_pio_input( byteswap->in ) )
return( -1 );
if( vips_image_pipelinev( conversion->out,
VIPS_DEMAND_STYLE_THINSTRIP, byteswap->in, NULL ) )
return( -1 );
if( vips_image_generate( conversion->out,
vips_start_one, vips_byteswap_gen, vips_stop_one,
byteswap->in, byteswap ) )
return( -1 );
return( 0 );
}
static int
vips_flip_build( VipsObject *object )
{
VipsConversion *conversion = VIPS_CONVERSION( object );
VipsFlip *flip = (VipsFlip *) object;
VipsGenerateFn generate_fn;
if( VIPS_OBJECT_CLASS( vips_flip_parent_class )->build( object ) )
return( -1 );
if( vips_image_pio_input( flip->in ) )
return( -1 );
if( vips_image_copy_fields( conversion->out, flip->in ) )
return( -1 );
vips_demand_hint( conversion->out,
VIPS_DEMAND_STYLE_THINSTRIP, flip->in, NULL );
if( flip->direction == VIPS_DIRECTION_HORIZONTAL ) {
generate_fn = vips_flip_horizontal_gen;
conversion->out->Xoffset = flip->in->Xsize;
conversion->out->Yoffset = 0;
}
else {
generate_fn = vips_flip_vertical_gen;
conversion->out->Xoffset = 0;
conversion->out->Yoffset = flip->in->Ysize;
}
if( vips_image_generate( conversion->out,
vips_start_one, generate_fn, vips_stop_one,
flip->in, flip ) )
return( -1 );
return( 0 );
}
static int
vips_copy_build( VipsObject *object )
{
VipsConversion *conversion = VIPS_CONVERSION( object );
VipsCopy *copy = (VipsCopy *) object;
int i;
if( VIPS_OBJECT_CLASS( vips_copy_parent_class )->build( object ) )
return( -1 );
if( vips_image_pio_input( copy->in ) )
return( -1 );
if( vips_image_pipelinev( conversion->out,
VIPS_DEMAND_STYLE_THINSTRIP, copy->in, NULL ) )
return( -1 );
/* Use props to adjust header fields.
*/
for( i = 0; i < VIPS_NUMBER( vips_copy_names ); i++ ) {
const char *name = vips_copy_names[i];
GParamSpec *pspec;
VipsArgumentClass *argument_class;
VipsArgumentInstance *argument_instance;
if( vips_object_get_argument( object, name,
&pspec, &argument_class, &argument_instance ) )
return( -1 );
if( argument_instance->assigned ) {
GType type = G_PARAM_SPEC_VALUE_TYPE( pspec );
GValue value = { 0, };
g_value_init( &value, type );
g_object_get_property( G_OBJECT( object ),
name, &value );
#ifdef VIPS_DEBUG
{
char *str;
str = g_strdup_value_contents( &value );
printf( "vips_copy_build: %s = %s\n", name, str );
g_free( str );
}
#endif /* VIPS_DEBUG */
g_object_set_property( G_OBJECT( conversion->out ),
name, &value );
g_value_unset( &value );
}
}
if( vips_image_generate( conversion->out,
vips_start_one, vips_copy_gen, vips_stop_one,
copy->in, copy ) )
return( -1 );
return( 0 );
}
/* Write a VIPS image to PNG.
*/
static int
write_vips( Write *write,
int compress, int interlace, const char *profile,
VipsForeignPngFilter filter, gboolean strip )
{
VipsImage *in = write->in;
int bit_depth;
int color_type;
int interlace_type;
int i, nb_passes;
g_assert( in->BandFmt == VIPS_FORMAT_UCHAR ||
in->BandFmt == VIPS_FORMAT_USHORT );
g_assert( in->Coding == VIPS_CODING_NONE );
g_assert( in->Bands > 0 && in->Bands < 5 );
/* Catch PNG errors.
*/
if( setjmp( png_jmpbuf( write->pPng ) ) )
return( -1 );
/* Check input image. If we are writing interlaced, we need to make 7
* passes over the image. We advertise ourselves as seq, so to ensure
* we only suck once from upstream, switch to WIO.
*/
if( interlace ) {
if( !(write->memory = vips_image_copy_memory( in )) )
return( -1 );
in = write->memory;
}
else {
if( vips_image_pio_input( in ) )
return( -1 );
}
if( compress < 0 || compress > 9 ) {
vips_error( "vips2png",
"%s", _( "compress should be in [0,9]" ) );
return( -1 );
}
/* Set compression parameters.
*/
png_set_compression_level( write->pPng, compress );
/* Set row filter.
*/
png_set_filter( write->pPng, 0, filter );
bit_depth = in->BandFmt == VIPS_FORMAT_UCHAR ? 8 : 16;
switch( in->Bands ) {
case 1: color_type = PNG_COLOR_TYPE_GRAY; break;
case 2: color_type = PNG_COLOR_TYPE_GRAY_ALPHA; break;
case 3: color_type = PNG_COLOR_TYPE_RGB; break;
case 4: color_type = PNG_COLOR_TYPE_RGB_ALPHA; break;
default:
vips_error( "vips2png",
_( "can't save %d band image as png" ), in->Bands );
return( -1 );
}
interlace_type = interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE;
png_set_IHDR( write->pPng, write->pInfo,
in->Xsize, in->Ysize, bit_depth, color_type, interlace_type,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT );
/* Set resolution. libpng uses pixels per meter.
*/
png_set_pHYs( write->pPng, write->pInfo,
VIPS_RINT( in->Xres * 1000 ), VIPS_RINT( in->Yres * 1000 ),
PNG_RESOLUTION_METER );
/* Set ICC Profile.
*/
if( profile &&
!strip ) {
if( strcmp( profile, "none" ) != 0 ) {
void *data;
size_t length;
if( !(data = vips__file_read_name( profile,
VIPS_ICC_DIR, &length )) )
return( -1 );
#ifdef DEBUG
printf( "write_vips: "
"attaching %zd bytes of ICC profile\n",
length );
#endif /*DEBUG*/
png_set_iCCP( write->pPng, write->pInfo, "icc",
PNG_COMPRESSION_TYPE_BASE, data, length );
}
}
else if( vips_image_get_typeof( in, VIPS_META_ICC_NAME ) &&
!strip ) {
void *data;
size_t length;
if( vips_image_get_blob( in, VIPS_META_ICC_NAME,
&data, &length ) )
return( -1 );
#ifdef DEBUG
printf( "write_vips: attaching %zd bytes of ICC profile\n",
length );
#endif /*DEBUG*/
png_set_iCCP( write->pPng, write->pInfo, "icc",
PNG_COMPRESSION_TYPE_BASE, data, length );
}
png_write_info( write->pPng, write->pInfo );
/* If we're an intel byte order CPU and this is a 16bit image, we need
* to swap bytes.
*/
if( bit_depth > 8 && !vips_amiMSBfirst() )
png_set_swap( write->pPng );
if( interlace )
nb_passes = png_set_interlace_handling( write->pPng );
else
nb_passes = 1;
/* Write data.
*/
for( i = 0; i < nb_passes; i++ )
if( vips_sink_disc( in, write_png_block, write ) )
return( -1 );
/* The setjmp() was held by our background writer: reset it.
*/
if( setjmp( png_jmpbuf( write->pPng ) ) )
return( -1 );
png_write_end( write->pPng, write->pInfo );
return( 0 );
}
/* Write a VIPS image to PNG.
*/
static int
write_vips( Write *write, int compress, int interlace )
{
VipsImage *in = write->in;
int bit_depth;
int color_type;
int interlace_type;
int i, nb_passes;
g_assert( in->BandFmt == VIPS_FORMAT_UCHAR ||
in->BandFmt == VIPS_FORMAT_USHORT );
g_assert( in->Coding == VIPS_CODING_NONE );
g_assert( in->Bands > 0 && in->Bands < 5 );
/* Catch PNG errors.
*/
if( setjmp( png_jmpbuf( write->pPng ) ) )
return( -1 );
/* Check input image.
*/
if( vips_image_pio_input( in ) )
return( -1 );
if( compress < 0 || compress > 9 ) {
vips_error( "vips2png",
"%s", _( "compress should be in [0,9]" ) );
return( -1 );
}
/* Set compression parameters.
*/
png_set_compression_level( write->pPng, compress );
bit_depth = in->BandFmt == VIPS_FORMAT_UCHAR ? 8 : 16;
switch( in->Bands ) {
case 1: color_type = PNG_COLOR_TYPE_GRAY; break;
case 2: color_type = PNG_COLOR_TYPE_GRAY_ALPHA; break;
case 3: color_type = PNG_COLOR_TYPE_RGB; break;
case 4: color_type = PNG_COLOR_TYPE_RGB_ALPHA; break;
default:
g_assert( 0 );
/* Keep -Wall happy.
*/
return( 0 );
}
interlace_type = interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE;
png_set_IHDR( write->pPng, write->pInfo,
in->Xsize, in->Ysize, bit_depth, color_type, interlace_type,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT );
/* Set resolution. libpnbg uses pixels per meter.
*/
png_set_pHYs( write->pPng, write->pInfo,
VIPS_RINT( in->Xres * 1000 ), VIPS_RINT( in->Yres * 1000 ),
PNG_RESOLUTION_METER );
/* Set ICC Profile.
*/
if( vips_image_get_typeof( in, VIPS_META_ICC_NAME ) ) {
void *profile;
size_t profile_length;
if( vips_image_get_blob( in, VIPS_META_ICC_NAME,
&profile, &profile_length ) )
return( -1 );
#ifdef DEBUG
printf( "write_vips: attaching %zd bytes of ICC profile\n",
profile_length );
#endif /*DEBUG*/
png_set_iCCP( write->pPng, write->pInfo, "icc",
PNG_COMPRESSION_TYPE_BASE, profile, profile_length );
}
png_write_info( write->pPng, write->pInfo );
/* If we're an intel byte order CPU and this is a 16bit image, we need
* to swap bytes.
*/
if( bit_depth > 8 && !vips_amiMSBfirst() )
png_set_swap( write->pPng );
if( interlace )
nb_passes = png_set_interlace_handling( write->pPng );
else
nb_passes = 1;
/* Write data.
*/
for( i = 0; i < nb_passes; i++ )
if( vips_sink_disc( write->in, write_png_block, write ) )
return( -1 );
/* The setjmp() was held by our background writer: reset it.
*/
if( setjmp( png_jmpbuf( write->pPng ) ) )
return( -1 );
png_write_end( write->pPng, write->pInfo );
return( 0 );
}
/* Write a VIPS image to PNG.
*/
static int
write_vips( Write *write,
int compress, int interlace, const char *profile,
VipsForeignPngFilter filter, gboolean strip,
gboolean palette, int colours, int Q, double dither )
{
VipsImage *in = write->in;
int bit_depth;
int color_type;
int interlace_type;
int i, nb_passes;
g_assert( in->BandFmt == VIPS_FORMAT_UCHAR ||
in->BandFmt == VIPS_FORMAT_USHORT );
g_assert( in->Coding == VIPS_CODING_NONE );
g_assert( in->Bands > 0 && in->Bands < 5 );
/* Catch PNG errors.
*/
if( setjmp( png_jmpbuf( write->pPng ) ) )
return( -1 );
/* Check input image. If we are writing interlaced, we need to make 7
* passes over the image. We advertise ourselves as seq, so to ensure
* we only suck once from upstream, switch to WIO.
*/
if( interlace ) {
if( !(write->memory = vips_image_copy_memory( in )) )
return( -1 );
in = write->memory;
}
else {
if( vips_image_pio_input( in ) )
return( -1 );
}
if( compress < 0 || compress > 9 ) {
vips_error( "vips2png",
"%s", _( "compress should be in [0,9]" ) );
return( -1 );
}
/* Set compression parameters.
*/
png_set_compression_level( write->pPng, compress );
/* Set row filter.
*/
png_set_filter( write->pPng, 0, filter );
bit_depth = in->BandFmt == VIPS_FORMAT_UCHAR ? 8 : 16;
switch( in->Bands ) {
case 1: color_type = PNG_COLOR_TYPE_GRAY; break;
case 2: color_type = PNG_COLOR_TYPE_GRAY_ALPHA; break;
case 3: color_type = PNG_COLOR_TYPE_RGB; break;
case 4: color_type = PNG_COLOR_TYPE_RGB_ALPHA; break;
default:
vips_error( "vips2png",
_( "can't save %d band image as png" ), in->Bands );
return( -1 );
}
#ifdef HAVE_IMAGEQUANT
/* Enable image quantisation to paletted 8bpp PNG if colours is set.
*/
if( palette ) {
g_assert( colours >= 2 &&
colours <= 256 );
bit_depth = 8;
color_type = PNG_COLOR_TYPE_PALETTE;
}
#else
if( palette )
g_warning( "%s",
_( "ignoring palette (no quantisation support)" ) );
#endif /*HAVE_IMAGEQUANT*/
interlace_type = interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE;
png_set_IHDR( write->pPng, write->pInfo,
in->Xsize, in->Ysize, bit_depth, color_type, interlace_type,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT );
/* Set resolution. libpng uses pixels per meter.
*/
png_set_pHYs( write->pPng, write->pInfo,
VIPS_RINT( in->Xres * 1000 ), VIPS_RINT( in->Yres * 1000 ),
PNG_RESOLUTION_METER );
/* Set ICC Profile.
*/
if( profile &&
!strip ) {
if( strcmp( profile, "none" ) != 0 ) {
void *data;
size_t length;
if( !(data = vips__file_read_name( profile,
vips__icc_dir(), &length )) )
return( -1 );
#ifdef DEBUG
printf( "write_vips: "
"attaching %zd bytes of ICC profile\n",
length );
#endif /*DEBUG*/
png_set_iCCP( write->pPng, write->pInfo, "icc",
PNG_COMPRESSION_TYPE_BASE, data, length );
}
}
else if( vips_image_get_typeof( in, VIPS_META_ICC_NAME ) &&
!strip ) {
void *data;
size_t length;
if( vips_image_get_blob( in, VIPS_META_ICC_NAME,
&data, &length ) )
return( -1 );
#ifdef DEBUG
printf( "write_vips: attaching %zd bytes of ICC profile\n",
length );
#endif /*DEBUG*/
png_set_iCCP( write->pPng, write->pInfo, "icc",
PNG_COMPRESSION_TYPE_BASE, data, length );
}
if( vips_image_get_typeof( in, VIPS_META_XMP_NAME ) ) {
const char *str;
if( vips_image_get_string( in, VIPS_META_XMP_NAME, &str ) )
return( -1 );
vips__png_set_text( write->pPng, write->pInfo,
"XML:com.adobe.xmp", str );
}
/* Set any "png-comment-xx-yyy" metadata items.
*/
if( vips_image_map( in,
write_png_comment, write ) )
return( -1 );
#ifdef HAVE_IMAGEQUANT
if( palette ) {
VipsImage *im_index;
VipsImage *im_palette;
int palette_count;
png_color *png_palette;
png_byte *png_trans;
int trans_count;
if( vips__quantise_image( in, &im_index, &im_palette,
colours, Q, dither ) )
return( -1 );
palette_count = im_palette->Xsize;
g_assert( palette_count <= PNG_MAX_PALETTE_LENGTH );
png_palette = (png_color *) png_malloc( write->pPng,
palette_count * sizeof( png_color ) );
png_trans = (png_byte *) png_malloc( write->pPng,
palette_count * sizeof( png_byte ) );
trans_count = 0;
for( i = 0; i < palette_count; i++ ) {
VipsPel *p = (VipsPel *)
VIPS_IMAGE_ADDR( im_palette, i, 0 );
png_color *col = &png_palette[i];
col->red = p[0];
col->green = p[1];
col->blue = p[2];
png_trans[i] = p[3];
if( p[3] != 255 )
trans_count = i + 1;
#ifdef DEBUG
printf( "write_vips: palette[%d] %d %d %d %d\n",
i + 1, p[0], p[1], p[2], p[3] );
#endif /*DEBUG*/
}
#ifdef DEBUG
printf( "write_vips: attaching %d color palette\n",
palette_count );
#endif /*DEBUG*/
png_set_PLTE( write->pPng, write->pInfo, png_palette,
palette_count );
if( trans_count ) {
#ifdef DEBUG
printf( "write_vips: attaching %d alpha values\n",
trans_count );
#endif /*DEBUG*/
png_set_tRNS( write->pPng, write->pInfo, png_trans,
trans_count, NULL );
}
png_free( write->pPng, (void *) png_palette );
png_free( write->pPng, (void *) png_trans );
VIPS_UNREF( im_palette );
VIPS_UNREF( write->memory );
write->memory = im_index;
in = write->memory;
}
#endif /*HAVE_IMAGEQUANT*/
png_write_info( write->pPng, write->pInfo );
/* If we're an intel byte order CPU and this is a 16bit image, we need
* to swap bytes.
*/
if( bit_depth > 8 &&
!vips_amiMSBfirst() )
png_set_swap( write->pPng );
if( interlace )
nb_passes = png_set_interlace_handling( write->pPng );
else
nb_passes = 1;
/* Write data.
*/
for( i = 0; i < nb_passes; i++ )
if( vips_sink_disc( in, write_png_block, write ) )
return( -1 );
/* The setjmp() was held by our background writer: reset it.
*/
if( setjmp( png_jmpbuf( write->pPng ) ) )
return( -1 );
png_write_end( write->pPng, write->pInfo );
return( 0 );
}
static int
vips_rot_build( VipsObject *object )
{
VipsConversion *conversion = VIPS_CONVERSION( object );
VipsRot *rot = (VipsRot *) object;
VipsGenerateFn generate_fn;
VipsDemandStyle hint;
if( VIPS_OBJECT_CLASS( vips_rot_parent_class )->build( object ) )
return( -1 );
if( rot->angle == VIPS_ANGLE_0 )
return( vips_image_write( rot->in, conversion->out ) );
if( vips_image_pio_input( rot->in ) )
return( -1 );
if( vips_image_copy_fields( conversion->out, rot->in ) )
return( -1 );
switch( rot->angle ) {
case VIPS_ANGLE_90:
generate_fn = vips_rot90_gen;
hint = VIPS_DEMAND_STYLE_SMALLTILE;
conversion->out->Xsize = rot->in->Ysize;
conversion->out->Ysize = rot->in->Xsize;
conversion->out->Xoffset = rot->in->Ysize;
conversion->out->Yoffset = 0;
break;
case VIPS_ANGLE_180:
generate_fn = vips_rot180_gen;
hint = VIPS_DEMAND_STYLE_THINSTRIP;
conversion->out->Xoffset = rot->in->Xsize;
conversion->out->Yoffset = rot->in->Ysize;
break;
case VIPS_ANGLE_270:
generate_fn = vips_rot270_gen;
hint = VIPS_DEMAND_STYLE_SMALLTILE;
conversion->out->Xsize = rot->in->Ysize;
conversion->out->Ysize = rot->in->Xsize;
conversion->out->Xoffset = 0;
conversion->out->Yoffset = rot->in->Xsize;
break;
default:
g_assert( 0 );
/* Keep -Wall happy.
*/
return( 0 );
}
vips_demand_hint( conversion->out, hint, rot->in, NULL );
if( vips_image_generate( conversion->out,
vips_start_one, generate_fn, vips_stop_one,
rot->in, rot ) )
return( -1 );
return( 0 );
}
/* Write a VIPS image to a JPEG compress struct.
*/
static int
write_vips( Write *write, int qfac, const char *profile,
gboolean optimize_coding, gboolean progressive, gboolean strip,
gboolean no_subsample, gboolean trellis_quant,
gboolean overshoot_deringing, gboolean optimize_scans, int quant_table )
{
VipsImage *in;
J_COLOR_SPACE space;
/* The image we'll be writing ... can change, see CMYK.
*/
in = write->in;
/* Should have been converted for save.
*/
g_assert( in->BandFmt == VIPS_FORMAT_UCHAR );
g_assert( in->Coding == VIPS_CODING_NONE );
g_assert( in->Bands == 1 ||
in->Bands == 3 ||
in->Bands == 4 );
/* Check input image.
*/
if( vips_image_pio_input( in ) )
return( -1 );
/* Set compression parameters.
*/
write->cinfo.image_width = in->Xsize;
write->cinfo.image_height = in->Ysize;
write->cinfo.input_components = in->Bands;
if( in->Bands == 4 &&
in->Type == VIPS_INTERPRETATION_CMYK ) {
space = JCS_CMYK;
/* IJG always sets an Adobe marker, so we should invert CMYK.
*/
if( vips_invert( in, &write->inverted, NULL ) )
return( -1 );
in = write->inverted;
}
else if( in->Bands == 3 )
space = JCS_RGB;
else if( in->Bands == 1 )
space = JCS_GRAYSCALE;
else
/* Use luminance compression for all channels.
*/
space = JCS_UNKNOWN;
write->cinfo.in_color_space = space;
/* Build VIPS output stuff now we know the image we'll be writing.
*/
if( !(write->row_pointer = VIPS_ARRAY( NULL, in->Ysize, JSAMPROW )) )
return( -1 );
#ifdef HAVE_JPEG_EXT_PARAMS
/* Reset compression profile to libjpeg defaults
*/
if( jpeg_c_int_param_supported( &write->cinfo, JINT_COMPRESS_PROFILE ) )
jpeg_c_set_int_param( &write->cinfo,
JINT_COMPRESS_PROFILE, JCP_FASTEST );
#endif
/* Reset to default.
*/
jpeg_set_defaults( &write->cinfo );
/* Compute optimal Huffman coding tables.
*/
write->cinfo.optimize_coding = optimize_coding;
#ifdef HAVE_JPEG_EXT_PARAMS
/* Apply trellis quantisation to each 8x8 block. Implies
* "optimize_coding".
*/
if( trellis_quant ) {
if( jpeg_c_bool_param_supported( &write->cinfo,
JBOOLEAN_TRELLIS_QUANT ) ) {
jpeg_c_set_bool_param( &write->cinfo,
JBOOLEAN_TRELLIS_QUANT, TRUE );
write->cinfo.optimize_coding = TRUE;
}
else
vips_warn( "vips2jpeg",
"%s", _( "trellis_quant unsupported" ) );
}
/* Apply overshooting to samples with extreme values e.g. 0 & 255
* for 8-bit.
*/
if( overshoot_deringing ) {
if( jpeg_c_bool_param_supported( &write->cinfo,
JBOOLEAN_OVERSHOOT_DERINGING ) )
jpeg_c_set_bool_param( &write->cinfo,
JBOOLEAN_OVERSHOOT_DERINGING, TRUE );
else
vips_warn( "vips2jpeg",
"%s", _( "overshoot_deringing unsupported" ) );
}
/* Split the spectrum of DCT coefficients into separate scans.
* Requires progressive output. Must be set before
* jpeg_simple_progression.
*/
if( optimize_scans ) {
if( progressive ) {
if( jpeg_c_bool_param_supported( &write->cinfo,
JBOOLEAN_OPTIMIZE_SCANS ) )
jpeg_c_set_bool_param( &write->cinfo,
JBOOLEAN_OPTIMIZE_SCANS, TRUE );
else
vips_warn( "vips2jpeg",
"%s", _( "Ignoring optimize_scans" ) );
}
else
vips_warn( "vips2jpeg", "%s",
_( "Ignoring optimize_scans for baseline" ) );
}
/* Use predefined quantization table.
*/
if( quant_table > 0 ) {
if( jpeg_c_int_param_supported( &write->cinfo,
JINT_BASE_QUANT_TBL_IDX ) )
jpeg_c_set_int_param( &write->cinfo,
JINT_BASE_QUANT_TBL_IDX, quant_table );
else
vips_warn( "vips2jpeg",
"%s", _( "Setting quant_table unsupported" ) );
}
#else
/* Using jpeglib.h without extension parameters, warn of ignored
* options.
*/
if( trellis_quant )
vips_warn( "vips2jpeg", "%s", _( "Ignoring trellis_quant" ) );
if( overshoot_deringing )
vips_warn( "vips2jpeg",
"%s", _( "Ignoring overshoot_deringing" ) );
if( optimize_scans )
vips_warn( "vips2jpeg", "%s", _( "Ignoring optimize_scans" ) );
if( quant_table > 0 )
vips_warn( "vips2jpeg", "%s", _( "Ignoring quant_table" ) );
#endif
/* Set compression quality. Must be called after setting params above.
*/
jpeg_set_quality( &write->cinfo, qfac, TRUE );
/* Enable progressive write.
*/
if( progressive )
jpeg_simple_progression( &write->cinfo );
/* Turn off chroma subsampling. Follow IM and do it automatically for
* high Q.
*/
if( no_subsample ||
qfac > 90 ) {
int i;
for( i = 0; i < in->Bands; i++ ) {
write->cinfo.comp_info[i].h_samp_factor = 1;
write->cinfo.comp_info[i].v_samp_factor = 1;
}
}
/* Don't write the APP0 JFIF headers if we are stripping.
*/
if( strip )
write->cinfo.write_JFIF_header = FALSE;
/* Build compress tables.
*/
jpeg_start_compress( &write->cinfo, TRUE );
/* Write any APP markers we need.
*/
if( !strip ) {
if( write_exif( write ) ||
write_blob( write,
VIPS_META_XMP_NAME, JPEG_APP0 + 1 ) ||
write_blob( write,
VIPS_META_IPCT_NAME, JPEG_APP0 + 13 ) )
return( -1 );
/* A profile supplied as an argument overrides an embedded
* profile. "none" means don't attach a profile.
*/
if( profile &&
strcmp( profile, "none" ) != 0 &&
write_profile_file( write, profile ) )
return( -1 );
if( !profile &&
vips_image_get_typeof( in, VIPS_META_ICC_NAME ) &&
write_profile_meta( write ) )
return( -1 );
}
/* Write data. Note that the write function grabs the longjmp()!
*/
if( vips_sink_disc( in, write_jpeg_block, write ) )
return( -1 );
/* We have to reinstate the setjmp() before we jpeg_finish_compress().
*/
if( setjmp( write->eman.jmp ) )
return( -1 );
jpeg_finish_compress( &write->cinfo );
return( 0 );
}