/* Read an ascii 1 bit file.
*/
static int
read_1bit_ascii( FILE *fp, IMAGE *out )
{
int x, y;
PEL *buf;
if( im_outcheck( out ) || im_setupout( out ) ||
!(buf = IM_ARRAY( out, IM_IMAGE_SIZEOF_LINE( out ), PEL )) )
return( -1 );
for( y = 0; y < out->Ysize; y++ ) {
for( x = 0; x < out->Xsize * out->Bands; x++ ) {
int val;
if( read_int( fp, &val ) )
return( -1 );
if( val == 1 )
buf[x] = 0;
else
buf[x] = 255;
}
if( im_writeline( y, out, buf ) )
return( -1 );
}
return( 0 );
}
/* Read a 1 bit binary file.
*/
static int
read_1bit_binary( FILE *fp, IMAGE *out )
{
int x, y, i;
int bits;
PEL *buf;
if( im_outcheck( out ) || im_setupout( out ) ||
!(buf = IM_ARRAY( out, IM_IMAGE_SIZEOF_LINE( out ), PEL )) )
return( -1 );
bits = fgetc( fp );
for( i = 0, y = 0; y < out->Ysize; y++ ) {
for( x = 0; x < out->Xsize * out->Bands; x++, i++ ) {
buf[x] = (bits & 128) ? 255 : 0;
bits <<= 1;
if( (i & 7) == 7 )
bits = fgetc( fp );
}
if( im_writeline( y, out, buf ) )
return( -1 );
}
return( 0 );
}
/* Yuk! Have to malloc enough space for the whole image. Interlaced PNG
* is not really suitable for large objects ...
*/
static int
png2vips_interlace( Read *read )
{
const int rowbytes = IM_IMAGE_SIZEOF_LINE( read->out );
int y;
if( !(read->row_pointer = IM_ARRAY( NULL,
read->pInfo->height, png_bytep )) )
return( -1 );
if( !(read->data = (png_bytep) im_malloc( NULL,
read->pInfo->height * rowbytes )) )
return( -1 );
for( y = 0; y < (int) read->pInfo->height; y++ )
read->row_pointer[y] = read->data + y * rowbytes;
if( im_outcheck( read->out ) ||
im_setupout( read->out ) ||
setjmp( read->pPng->jmpbuf ) )
return( -1 );
png_read_image( read->pPng, read->row_pointer );
for( y = 0; y < (int) read->pInfo->height; y++ )
if( im_writeline( y, read->out, read->row_pointer[y] ) )
return( -1 );
return( 0 );
}
static int
mat2vips_get_data( mat_t *mat, matvar_t *var, IMAGE *im )
{
int y;
PEL *buffer;
const int es = IM_IMAGE_SIZEOF_ELEMENT( im );
/* Matlab images are plane-separate, so we have to assemble bands in
* image-size chunks.
*/
const int is = es * im->Xsize * im->Ysize;
if( Mat_VarReadDataAll( mat, var ) ) {
im_error( "im_mat2vips", "%s",
_( "Mat_VarReadDataAll failed" ) );
return( -1 );
}
if( im_outcheck( im ) ||
im_setupout( im ) )
return( -1 );
/* Matlab images are in columns, so we have to transpose into
* scanlines with this buffer.
*/
if( !(buffer = IM_ARRAY( im, IM_IMAGE_SIZEOF_LINE( im ), PEL )) )
return( -1 );
for( y = 0; y < im->Ysize; y++ ) {
const PEL *p = var->data + y * es;
int x;
PEL *q;
q = buffer;
for( x = 0; x < im->Xsize; x++ ) {
int b;
for( b = 0; b < im->Bands; b++ ) {
const PEL *p2 = p + b * is;
int z;
for( z = 0; z < es; z++ )
q[z] = p2[z];
q += es;
}
p += es * im->Ysize;
}
if( im_writeline( y, im, buffer ) )
return( -1 );
}
return( 0 );
}
/* Morph start function.
*/
static void *
morph_start( IMAGE *out, void *a, void *b )
{
IMAGE *in = (IMAGE *) a;
Morph *morph = (Morph *) b;
int n_mask = morph->mask->xsize * morph->mask->ysize;
int sz = IM_IMAGE_N_ELEMENTS( in );
MorphSequence *seq;
if( !(seq = IM_NEW( out, MorphSequence )) )
return( NULL );
/* Init!
*/
seq->morph = morph;
seq->ir = NULL;
seq->soff = NULL;
seq->ss = 0;
seq->coff = NULL;
seq->cs = 0;
seq->last_bpl = -1;
seq->t1 = NULL;
seq->t2 = NULL;
/* Attach region and arrays.
*/
seq->ir = im_region_create( in );
seq->soff = IM_ARRAY( out, n_mask, int );
seq->coff = IM_ARRAY( out, n_mask, int );
seq->t1 = IM_ARRAY( NULL, sz, VipsPel );
seq->t2 = IM_ARRAY( NULL, sz, VipsPel );
if( !seq->ir || !seq->soff || !seq->coff || !seq->t1 || !seq->t2 ) {
morph_stop( seq, in, NULL );
return( NULL );
}
return( seq );
}
/* Build a lut table.
*/
static LutInfo *
build_luts( IMAGE *out, IMAGE *lut )
{
LutInfo *st;
int i, x;
VipsPel *q;
if( !(st = IM_NEW( out, LutInfo )) )
return( NULL );
/* Make luts. We unpack the LUT image into a C 2D array to speed
* processing.
*/
st->fmt = lut->BandFmt;
st->es = IM_IMAGE_SIZEOF_ELEMENT( lut );
st->nb = lut->Bands;
st->sz = lut->Xsize * lut->Ysize;
st->clp = st->sz - 1;
st->overflow = 0;
st->table = NULL;
if( im_add_evalstart_callback( out,
(im_callback_fn) lut_start, st, NULL ) ||
im_add_evalend_callback( out,
(im_callback_fn) lut_end, st, NULL ) )
return( NULL );
/* Attach tables.
*/
if( !(st->table = IM_ARRAY( out, lut->Bands, VipsPel * )) )
return( NULL );
for( i = 0; i < lut->Bands; i++ )
if( !(st->table[i] = IM_ARRAY( out, st->sz * st->es, VipsPel )) )
return( NULL );
/* Scan LUT and fill table.
*/
q = (VipsPel *) lut->data;
for( x = 0; x < st->sz; x++ )
for( i = 0; i < st->nb; i++ ) {
memcpy( st->table[i] + x * st->es, q, st->es );
q += st->es;
}
return( st );
}
/* Read an ascii ppm/pgm file.
*/
static int
read_ascii( FILE *fp, IMAGE *out )
{
int x, y;
PEL *buf;
if( im_outcheck( out ) || im_setupout( out ) ||
!(buf = IM_ARRAY( out, IM_IMAGE_SIZEOF_LINE( out ), PEL )) )
return( -1 );
for( y = 0; y < out->Ysize; y++ ) {
for( x = 0; x < out->Xsize * out->Bands; x++ ) {
int val;
if( read_int( fp, &val ) )
return( -1 );
switch( out->BandFmt ) {
case IM_BANDFMT_UCHAR:
buf[x] = IM_CLIP( 0, val, 255 );
break;
case IM_BANDFMT_USHORT:
((unsigned short *) buf)[x] =
IM_CLIP( 0, val, 65535 );
break;
case IM_BANDFMT_UINT:
((unsigned int *) buf)[x] = val;
break;
default:
g_assert( 0 );
}
}
if( im_writeline( y, out, buf ) )
return( -1 );
}
return( 0 );
}
/* Call rfftw for a 1 band real image.
*/
static int
rfwfft1( IMAGE *dummy, IMAGE *in, IMAGE *out )
{
const int size = in->Xsize * in->Ysize;
const int half_width = in->Xsize / 2 + 1;
/* Pack to double real here.
*/
IMAGE *real = im_open_local( dummy, "fwfft1:1", "t" );
/* Transform to halfcomplex here.
*/
double *half_complex = IM_ARRAY( dummy,
in->Ysize * half_width * 2, double );
rfftwnd_plan plan;
double *buf, *q, *p;
int x, y;
if( !real || !half_complex || im_pincheck( in ) || im_outcheck( out ) )
return( -1 );
if( in->Coding != IM_CODING_NONE || in->Bands != 1 ) {
im_error( "im_fwfft", _( "one band uncoded only" ) );
return( -1 );
}
if( im_clip2d( in, real ) )
return( -1 );
/* Make the plan for the transform. Yes, they really do use nx for
* height and ny for width.
*/
if( !(plan = rfftw2d_create_plan( in->Ysize, in->Xsize,
FFTW_FORWARD, FFTW_MEASURE | FFTW_USE_WISDOM )) ) {
im_error( "im_fwfft", _( "unable to create transform plan" ) );
return( -1 );
}
rfftwnd_one_real_to_complex( plan,
(fftw_real *) real->data, (fftw_complex *) half_complex );
rfftwnd_destroy_plan( plan );
/* WIO to out.
*/
if( im_cp_desc( out, in ) )
return( -1 );
out->Bbits = IM_BBITS_DPCOMPLEX;
out->BandFmt = IM_BANDFMT_DPCOMPLEX;
if( im_setupout( out ) )
return( -1 );
if( !(buf = (double *) IM_ARRAY( dummy,
IM_IMAGE_SIZEOF_LINE( out ), PEL )) )
return( -1 );
/* Copy to out and normalise. The right half is the up/down and
* left/right flip of the left, but conjugated. Do the first
* row separately, then mirror around the centre row.
*/
p = half_complex;
q = buf;
for( x = 0; x < half_width; x++ ) {
q[0] = p[0] / size;
q[1] = p[1] / size;
p += 2;
q += 2;
}
p = half_complex + ((in->Xsize + 1) / 2 - 1) * 2;
for( x = half_width; x < out->Xsize; x++ ) {
q[0] = p[0] / size;
q[1] = -1.0 * p[1] / size;
p -= 2;
q += 2;
}
if( im_writeline( 0, out, (PEL *) buf ) )
return( -1 );
for( y = 1; y < out->Ysize; y++ ) {
p = half_complex + y * half_width * 2;
q = buf;
for( x = 0; x < half_width; x++ ) {
q[0] = p[0] / size;
q[1] = p[1] / size;
p += 2;
q += 2;
}
/* Good grief.
*/
p = half_complex + 2 *
((out->Ysize - y + 1) * half_width - 2 +
(in->Xsize & 1));
for( x = half_width; x < out->Xsize; x++ ) {
q[0] = p[0] / size;
q[1] = -1.0 * p[1] / size;
p -= 2;
q += 2;
}
if( im_writeline( y, out, (PEL *) buf ) )
return( -1 );
}
return( 0 );
}
/* Transform a 1 band image with vips's built-in fft routine.
*/
static int
fwfft1( IMAGE *dummy, IMAGE *in, IMAGE *out )
{
int size = in->Xsize * in->Ysize;
int bpx = im_ispoweroftwo( in->Xsize );
int bpy = im_ispoweroftwo( in->Ysize );
float *buf, *q, *p1, *p2;
int x, y;
/* Buffers for real and imaginary parts.
*/
IMAGE *real = im_open_local( dummy, "fwfft1:1", "t" );
IMAGE *imag = im_open_local( dummy, "fwfft1:2", "t" );
/* Temporaries.
*/
IMAGE *t1 = im_open_local( dummy, "fwfft1:3", "p" );
if( !real || !imag || !t1 )
return( -1 );
if( im_pincheck( in ) || im_outcheck( out ) )
return( -1 );
if( in->Coding != IM_CODING_NONE || in->Bands != 1 ||
im_iscomplex( in ) ) {
im_error( "im_fwfft",
_( "one band non-complex uncoded only" ) );
return( -1 );
}
if( !bpx || !bpy ) {
im_error( "im_fwfft", _( "sides must be power of 2" ) );
return( -1 );
}
/* Make sure we have a float input image.
*/
if( im_clip2f( in, real ) )
return( -1 );
/* Make a buffer of 0 floats of the same size for the imaginary part.
*/
if( im_black( t1, in->Xsize, in->Ysize, 1 ) )
return( -1 );
if( im_clip2f( t1, imag ) )
return( -1 );
/* Transform!
*/
if( im__fft_sp( (float *) real->data, (float *) imag->data,
bpx - 1, bpy - 1 ) ) {
im_error( "im_fwfft", _( "fft_sp failed" ) );
return( -1 );
}
/* WIO to out.
*/
if( im_cp_desc( out, in ) )
return( -1 );
out->Bbits = IM_BBITS_COMPLEX;
out->BandFmt = IM_BANDFMT_COMPLEX;
if( im_setupout( out ) )
return( -1 );
if( !(buf = (float *) IM_ARRAY( dummy,
IM_IMAGE_SIZEOF_LINE( out ), PEL )) )
return( -1 );
/* Gather together real and imag parts. We have to normalise output!
*/
for( p1 = (float *) real->data, p2 = (float *) imag->data,
y = 0; y < out->Ysize; y++ ) {
q = buf;
for( x = 0; x < out->Xsize; x++ ) {
q[0] = *p1++ / size;
q[1] = *p2++ / size;
q += 2;
}
if( im_writeline( y, out, (PEL *) buf ) )
return( -1 );
}
return( 0 );
}
/* Complex to complex forward transform.
*/
static int
cfwfft1( IMAGE *dummy, IMAGE *in, IMAGE *out )
{
fftw_plan plan;
double *buf, *q, *p;
int x, y;
IMAGE *cmplx = im_open_local( dummy, "fwfft1:1", "t" );
/* We have to have a separate buffer for the planner to work on.
*/
double *planner_scratch = IM_ARRAY( dummy,
in->Xsize * in->Ysize * 2, double );
/* Make dp complex image.
*/
if( !cmplx || im_pincheck( in ) || im_outcheck( out ) )
return( -1 );
if( in->Coding != IM_CODING_NONE || in->Bands != 1 ) {
im_error( "im_fwfft", _( "one band uncoded only" ) );
return( -1 );
}
if( im_clip2dcm( in, cmplx ) )
return( -1 );
/* Make the plan for the transform.
*/
if( !(plan = fftw_plan_dft_2d( in->Ysize, in->Xsize,
(fftw_complex *) planner_scratch,
(fftw_complex *) planner_scratch,
FFTW_FORWARD,
0 )) ) {
im_error( "im_fwfft", _( "unable to create transform plan" ) );
return( -1 );
}
fftw_execute_dft( plan,
(fftw_complex *) cmplx->data, (fftw_complex *) cmplx->data );
fftw_destroy_plan( plan );
/* WIO to out.
*/
if( im_cp_desc( out, in ) )
return( -1 );
out->Bbits = IM_BBITS_DPCOMPLEX;
out->BandFmt = IM_BANDFMT_DPCOMPLEX;
if( im_setupout( out ) )
return( -1 );
if( !(buf = (double *) IM_ARRAY( dummy,
IM_IMAGE_SIZEOF_LINE( out ), PEL )) )
return( -1 );
/* Copy to out, normalise.
*/
for( p = (double *) cmplx->data, y = 0; y < out->Ysize; y++ ) {
int size = out->Xsize * out->Ysize;
q = buf;
for( x = 0; x < out->Xsize; x++ ) {
q[0] = p[0] / size;
q[1] = p[1] / size;
p += 2;
q += 2;
}
if( im_writeline( y, out, (PEL *) buf ) )
return( -1 );
}
return( 0 );
}
int
im_resize_linear( IMAGE *in, IMAGE *out, int X, int Y )
{
double dx, dy, xscale, yscale;
double Xnew, Ynew; /* inv. coord. of the interpolated pt */
int x, y;
int Xint, Yint;
int bb;
PEL *input, *opline;
PEL *q, *p;
int ils, ips, ies; /* Input and output line, pel and */
int ols, ops, oes; /* element sizes */
if( im_iocheck( in, out ) )
return( -1 );
if( im_iscomplex( in ) ) {
im_errormsg( "im_lowpass: non-complex input only" );
return( -1 );
}
if( in->Coding != IM_CODING_NONE ) {
im_errormsg("im_lowpass: input should be uncoded");
return( -1 );
}
if( im_cp_desc( out, in ) )
return( -1 );
out->Xsize = X;
out->Ysize = Y;
if( im_setupout( out ) )
return( -1 );
ils = IM_IMAGE_SIZEOF_LINE( in );
ips = IM_IMAGE_SIZEOF_PEL( in );
ies = IM_IMAGE_SIZEOF_ELEMENT( in );
ols = IM_IMAGE_SIZEOF_LINE( out );
ops = IM_IMAGE_SIZEOF_PEL( out );
oes = IM_IMAGE_SIZEOF_ELEMENT( out );
/* buffer lines
***************/
if( !(opline = IM_ARRAY( out, ols, PEL )) )
return( -1 );
/* Resampling
*************/
input = (PEL*) in->data;
xscale = ((double)in->Xsize-1)/(X-1);
yscale = ((double)in->Ysize-1)/(Y-1);
for (y=0; y<Y; y++)
{
q = opline;
for (x=0; x<X; x++)
{
Xnew = x*xscale;
Ynew = y*yscale;
Xint = floor(Xnew);
Yint = floor(Ynew);
dx = Xnew - Xint;
dy = Ynew - Yint;
p = input + Xint*ips + Yint*ils;
switch( in->BandFmt ) {
case IM_BANDFMT_UCHAR: LOOP( unsigned char); break;
case IM_BANDFMT_USHORT: LOOP( unsigned short ); break;
case IM_BANDFMT_UINT: LOOP( unsigned int ); break;
case IM_BANDFMT_CHAR: LOOP( signed char ); break;
case IM_BANDFMT_SHORT: LOOP( signed short ); break;
case IM_BANDFMT_INT: LOOP( signed int ); break;
case IM_BANDFMT_FLOAT: LOOP( float ); break;
case IM_BANDFMT_DOUBLE: LOOP( double ); break;
default:
im_errormsg( "im_lowpass: unsupported image type" );
return( -1 );
/*NOTREACHED*/
}
}
if (im_writeline(y, out, opline) )
return(-1);
}
return(0);
}
/* Write a VIPS image to a JPEG compress struct.
*/
static int
write_vips( Write *write, int qfac, const char *profile )
{
IMAGE *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 == IM_BANDFMT_UCHAR );
g_assert( in->Coding == IM_CODING_NONE );
g_assert( in->Bands == 1 || in->Bands == 3 || in->Bands == 4 );
/* Check input image.
*/
if( im_pincheck( in ) )
return( -1 );
if( qfac < 0 || qfac > 100 ) {
im_error( "im_vips2jpeg",
"%s", _( "qfac should be in 0-100" ) );
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 == IM_TYPE_CMYK ) {
space = JCS_CMYK;
/* IJG always sets an Adobe marker, so we should invert CMYK.
*/
if( !(write->inverted = im_open( "vips2jpeg_invert", "p" )) ||
im_invert( in, write->inverted ) )
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 =
IM_ARRAY( NULL, write->in->Ysize, JSAMPROW )) )
return( -1 );
/* Rest to default.
*/
jpeg_set_defaults( &write->cinfo );
jpeg_set_quality( &write->cinfo, qfac, TRUE );
/* Build compress tables.
*/
jpeg_start_compress( &write->cinfo, TRUE );
/* Write any APP markers we need.
*/
if( write_exif( write ) )
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 &&
im_header_get_typeof( in, IM_META_ICC_NAME ) &&
write_profile_meta( write ) )
return( -1 );
/* Write data. Note that the write function grabs the longjmp()!
*/
if( vips_sink_disc( write->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 );
}
/* Fall back to vips's built-in fft.
*/
static int
invfft1( IMAGE *dummy, IMAGE *in, IMAGE *out )
{
int bpx = im_ispoweroftwo( in->Xsize );
int bpy = im_ispoweroftwo( in->Ysize );
float *buf, *q, *p1;
int x, y;
/* Buffers for real and imaginary parts.
*/
IMAGE *real = im_open_local( dummy, "invfft1:1", "t" );
IMAGE *imag = im_open_local( dummy, "invfft1:2", "t" );
/* Temps.
*/
IMAGE *t1 = im_open_local( dummy, "invfft1:3", "p" );
IMAGE *t2 = im_open_local( dummy, "invfft1:4", "p" );
if( !real || !imag || !t1 )
return( -1 );
if( im_pincheck( in ) || im_outcheck( out ) )
return( -1 );
if( in->Coding != IM_CODING_NONE ||
in->Bands != 1 || !im_iscomplex( in ) ) {
im_error( "im_invfft",
"%s", _( "one band complex uncoded only" ) );
return( -1 );
}
if( !bpx || !bpy ) {
im_error( "im_invfft",
"%s", _( "sides must be power of 2" ) );
return( -1 );
}
/* Make sure we have a single-precision complex input image.
*/
if( im_clip2fmt( in, t1, IM_BANDFMT_COMPLEX ) )
return( -1 );
/* Extract real and imag parts. We have to complement the imaginary.
*/
if( im_c2real( t1, real ) )
return( -1 );
if( im_c2imag( t1, t2 ) || im_lintra( -1.0, t2, 0.0, imag ) )
return( -1 );
/* Transform!
*/
if( im__fft_sp( (float *) real->data, (float *) imag->data,
bpx - 1, bpy - 1 ) ) {
im_error( "im_invfft",
"%s", _( "fft_sp failed" ) );
return( -1 );
}
/* WIO to out.
*/
if( im_cp_desc( out, in ) )
return( -1 );
out->BandFmt = IM_BANDFMT_FLOAT;
if( im_setupout( out ) )
return( -1 );
if( !(buf = (float *) IM_ARRAY( dummy,
IM_IMAGE_SIZEOF_LINE( out ), PEL )) )
return( -1 );
/* Just write real part.
*/
for( p1 = (float *) real->data, y = 0; y < out->Ysize; y++ ) {
q = buf;
for( x = 0; x < out->Xsize; x++ ) {
q[x] = *p1++;
}
if( im_writeline( y, out, (PEL *) buf ) )
return( -1 );
}
return( 0 );
}
int
im_msb_band (IMAGE * in, IMAGE * out, int band)
{
#define FUNCTION_NAME "im_msb_band"
size_t *params;
im_wrapone_fn func;
#define index (params[0])
#define width (params[1])
#define repeat (params[2])
if (band < 0)
{
im_error (FUNCTION_NAME, _("bad arguments"));
return -1;
}
if (im_piocheck (in, out))
return -1;
params = IM_ARRAY (out, 3, size_t);
if (!params)
return -1;
if (IM_UNCODED (in))
{
if (!IM_ANY_INT (in))
{
im_error (FUNCTION_NAME, _("char, short or int only"));
return -1;
}
if (band >= in->Bands)
{
im_error (FUNCTION_NAME, _("image does not have that many bands"));
return -1;
}
width = SIZEOF_BAND (in->BandFmt);
#if G_BYTE_ORDER == G_BIG_ENDIAN
index = width * band;
#else
index = (width * (band + 1)) - 1;
#endif
width *= in->Bands;
repeat = 1;
if (IM_UNSIGNED (in))
func = (im_wrapone_fn) byte_select;
else
func = (im_wrapone_fn) byte_select_flip;
}
else if (IM_CODING_LABQ == in->Coding)
{
if (band > 2)
{
im_error (FUNCTION_NAME, _("image does not have that many bands"));
return -1;
}
width = 4;
repeat = 1;
index = band;
if (band)
func = (im_wrapone_fn) byte_select_flip;
else
func = (im_wrapone_fn) byte_select;
}
else
{
im_error (FUNCTION_NAME, _("unknown coding"));
return -1;
}
if (im_cp_desc (out, in))
return -1;
out->Bands = 1;
out->Bbits = sizeof (unsigned char) << 3;
out->BandFmt = IM_BANDFMT_UCHAR;
out->Coding = IM_CODING_NONE;
return im_wrapone (in, out, func, (void *) params, NULL);
#undef index
#undef width
#undef repeat
#undef FUNCTION_NAME
}
int
im_msb (IMAGE * in, IMAGE * out)
{
#define FUNCTION_NAME "im_msb"
size_t *params;
im_wrapone_fn func;
#define index (params[0])
#define width (params[1])
#define repeat (params[2])
if (im_piocheck (in, out))
return -1;
/* Stops a used-before-set warning.
*/
params = NULL;
if (IM_UNCODED (in))
{
if (!IM_ANY_INT (in))
{
im_error (FUNCTION_NAME, _("char, short or int only"));
return -1;
}
params = IM_ARRAY (out, 3, size_t);
if (!params)
return -1;
width = SIZEOF_BAND (in->BandFmt);
#if G_BYTE_ORDER == G_BIG_ENDIAN
index = 0;
#else
index = width - 1;
#endif
repeat = in->Bands;
if (IM_UNSIGNED (in))
func = (im_wrapone_fn) byte_select;
else
func = (im_wrapone_fn) byte_select_flip;
if (1 == width && (im_wrapone_fn) byte_select == func)
{
return im_copy (in, out);
}
}
else if (IM_CODING_LABQ == in->Coding)
func = (im_wrapone_fn) msb_labq;
else
{
im_error (FUNCTION_NAME, _("unknown coding"));
return -1;
}
if (im_cp_desc (out, in))
return -1;
out->Bbits = sizeof (unsigned char) << 3;
out->BandFmt = IM_BANDFMT_UCHAR;
out->Coding = IM_CODING_NONE;
return im_wrapone (in, out, func, (void *) params, NULL);
#undef index
#undef width
#undef repeat
#undef FUNCTION_NAME
}