% November 2001 %
% %
% %
-% Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2015 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
size_t
file_size;
- ExceptionInfo
- *exception;
+ size_t
+ number_layers;
} XCFDocInfo;
typedef struct
{
switch ( blendMode )
{
- case GIMP_NORMAL_MODE: return( OverCompositeOp );
- case GIMP_DISSOLVE_MODE: return( DissolveCompositeOp );
- case GIMP_MULTIPLY_MODE: return( MultiplyCompositeOp );
- case GIMP_SCREEN_MODE: return( ScreenCompositeOp );
- case GIMP_OVERLAY_MODE: return( OverlayCompositeOp );
- case GIMP_DIFFERENCE_MODE: return( DifferenceCompositeOp );
- case GIMP_ADDITION_MODE: return( ModulusAddCompositeOp );
- case GIMP_SUBTRACT_MODE: return( ModulusSubtractCompositeOp );
- case GIMP_DARKEN_ONLY_MODE: return( DarkenCompositeOp );
- case GIMP_LIGHTEN_ONLY_MODE:return( LightenCompositeOp );
- case GIMP_HUE_MODE: return( HueCompositeOp );
- case GIMP_SATURATION_MODE: return( SaturateCompositeOp );
- case GIMP_COLOR_MODE: return( ColorizeCompositeOp );
- case GIMP_DODGE_MODE: return( ColorDodgeCompositeOp );
- case GIMP_BURN_MODE: return( ColorBurnCompositeOp );
- case GIMP_HARDLIGHT_MODE: return( HardLightCompositeOp );
- case GIMP_DIVIDE_MODE: return( DivideDstCompositeOp );
+ case GIMP_NORMAL_MODE: return(OverCompositeOp);
+ case GIMP_DISSOLVE_MODE: return(DissolveCompositeOp);
+ case GIMP_MULTIPLY_MODE: return(MultiplyCompositeOp);
+ case GIMP_SCREEN_MODE: return(ScreenCompositeOp);
+ case GIMP_OVERLAY_MODE: return(OverlayCompositeOp);
+ case GIMP_DIFFERENCE_MODE: return(DifferenceCompositeOp);
+ case GIMP_ADDITION_MODE: return(ModulusAddCompositeOp);
+ case GIMP_SUBTRACT_MODE: return(ModulusSubtractCompositeOp);
+ case GIMP_DARKEN_ONLY_MODE: return(DarkenCompositeOp);
+ case GIMP_LIGHTEN_ONLY_MODE: return(LightenCompositeOp);
+ case GIMP_HUE_MODE: return(HueCompositeOp);
+ case GIMP_SATURATION_MODE: return(SaturateCompositeOp);
+ case GIMP_COLOR_MODE: return(ColorizeCompositeOp);
+ case GIMP_DODGE_MODE: return(ColorDodgeCompositeOp);
+ case GIMP_BURN_MODE: return(ColorBurnCompositeOp);
+ case GIMP_HARDLIGHT_MODE: return(HardLightCompositeOp);
+ case GIMP_DIVIDE_MODE: return(DivideDstCompositeOp);
/* these are the ones we don't support...yet */
- case GIMP_BEHIND_MODE: return( OverCompositeOp );
- case GIMP_VALUE_MODE: return( OverCompositeOp );
- default:
- return(OverCompositeOp);
+ case GIMP_BEHIND_MODE: return(OverCompositeOp);
+ case GIMP_VALUE_MODE: return(OverCompositeOp);
+ default: return(OverCompositeOp);
}
}
\f
%
*/
-static inline size_t MagickMin(const size_t x,const size_t y)
-{
- if (x < y)
- return(x);
- return(y);
-}
-
static char *ReadBlobStringWithLongSize(Image *image,char *string,size_t max,
ExceptionInfo *exception)
{
image->filename);
for (y=0; y < (ssize_t) tile_image->rows; y++)
{
- q=QueueAuthenticPixels(tile_image,0,y,tile_image->columns,1,exception);
+ q=GetAuthenticPixels(tile_image,0,y,tile_image->columns,1,exception);
if (q == (Quantum *) NULL)
break;
if (inDocInfo->image_type == GIMP_GRAY)
SetPixelRed(tile_image,ScaleCharToQuantum(xcfdata->red),q);
SetPixelGreen(tile_image,ScaleCharToQuantum(xcfdata->green),q);
SetPixelBlue(tile_image,ScaleCharToQuantum(xcfdata->blue),q);
- SetPixelAlpha(tile_image,xcfdata->alpha == 0U ? OpaqueAlpha :
+ SetPixelAlpha(tile_image,xcfdata->alpha == 255U ? TransparentAlpha :
ScaleCharToQuantum((unsigned char) inLayerInfo->alpha),q);
xcfdata++;
q+=GetPixelChannels(tile_image);
MagickOffsetType
size;
+ Quantum
+ alpha;
+
register Quantum
*q;
xcfodata=xcfdata;
count=ReadBlob(image, (size_t) data_length, xcfdata);
xcfdatalimit = xcfodata+count-1;
- exception=(exception);
+ alpha=ScaleCharToQuantum((unsigned char) inLayerInfo->alpha);
for (i=0; i < (ssize_t) bytes_per_pixel; i++)
{
q=GetAuthenticPixels(tile_image,0,0,tile_image->columns,tile_image->rows,
exception);
+ if (q == (Quantum *) NULL)
+ continue;
size=(MagickOffsetType) tile_image->rows*tile_image->columns;
while (size > 0)
{
length=(size_t) ((*xcfdata << 8) + xcfdata[1]);
xcfdata+=2;
}
- size-=length;
- if (size < 0)
- goto bogus_rle;
- if (&xcfdata[length-1] > xcfdatalimit)
- goto bogus_rle;
- while (length-- > 0)
+ size-=length;
+ if (size < 0)
+ goto bogus_rle;
+ if (&xcfdata[length-1] > xcfdatalimit)
+ goto bogus_rle;
+ while (length-- > 0)
+ {
+ data=(*xcfdata++);
+ switch (i)
{
- data=(*xcfdata++);
- switch (i)
+ case 0:
+ {
+ if (inDocInfo->image_type == GIMP_GRAY)
+ SetPixelGray(tile_image,ScaleCharToQuantum(data),q);
+ else
+ {
+ SetPixelRed(tile_image,ScaleCharToQuantum(data),q);
+ SetPixelGreen(tile_image,ScaleCharToQuantum(data),q);
+ SetPixelBlue(tile_image,ScaleCharToQuantum(data),q);
+ }
+ SetPixelAlpha(tile_image,alpha,q);
+ break;
+ }
+ case 1:
{
- case 0:
- {
- if (inDocInfo->image_type != GIMP_GRAY)
- {
- SetPixelRed(tile_image,ScaleCharToQuantum(data),q);
- SetPixelGreen(tile_image,ScaleCharToQuantum(data),q);
- SetPixelBlue(tile_image,ScaleCharToQuantum(data),q);
- SetPixelAlpha(tile_image,ScaleCharToQuantum(
- (unsigned char) inLayerInfo->alpha),q);
- }
- else
- {
- SetPixelGray(tile_image,ScaleCharToQuantum(data),q);
- SetPixelAlpha(tile_image,ScaleCharToQuantum(
- (unsigned char) inLayerInfo->alpha),q);
- }
- break;
- }
- case 1:
- {
+ if (inDocInfo->image_type == GIMP_GRAY)
+ SetPixelAlpha(tile_image,ScaleCharToQuantum(data),q);
+ else
SetPixelGreen(tile_image,ScaleCharToQuantum(data),q);
- break;
- }
- case 2:
- {
- SetPixelBlue(tile_image,ScaleCharToQuantum(data),q);
- break;
- }
- case 3:
- {
- SetPixelAlpha(tile_image,data == 0 ? OpaqueAlpha :
- ScaleCharToQuantum((unsigned char) inLayerInfo->alpha),q);
- break;
- }
+ break;
+ }
+ case 2:
+ {
+ SetPixelBlue(tile_image,ScaleCharToQuantum(data),q);
+ break;
+ }
+ case 3:
+ {
+ SetPixelAlpha(tile_image,ScaleCharToQuantum(data),q);
+ break;
}
- q+=GetPixelChannels(tile_image);
}
+ q+=GetPixelChannels(tile_image);
}
- else
+ }
+ else
+ {
+ length+=1;
+ if (length == 128)
+ {
+ if (xcfdata >= xcfdatalimit)
+ goto bogus_rle;
+ length=(size_t) ((*xcfdata << 8) + xcfdata[1]);
+ xcfdata+=2;
+ }
+ size-=length;
+ if (size < 0)
+ goto bogus_rle;
+ if (xcfdata > xcfdatalimit)
+ goto bogus_rle;
+ pixel=(*xcfdata++);
+ for (j=0; j < (ssize_t) length; j++)
{
- length+=1;
- if (length == 128)
+ data=pixel;
+ switch (i)
+ {
+ case 0:
{
- if (xcfdata >= xcfdatalimit)
- goto bogus_rle;
- length=(size_t) ((*xcfdata << 8) + xcfdata[1]);
- xcfdata+=2;
+ if (inDocInfo->image_type == GIMP_GRAY)
+ SetPixelGray(tile_image,ScaleCharToQuantum(data),q);
+ else
+ {
+ SetPixelRed(tile_image,ScaleCharToQuantum(data),q);
+ SetPixelGreen(tile_image,ScaleCharToQuantum(data),q);
+ SetPixelBlue(tile_image,ScaleCharToQuantum(data),q);
+ }
+ SetPixelAlpha(tile_image,alpha,q);
+ break;
}
- size-=length;
- if (size < 0)
- goto bogus_rle;
- if (xcfdata > xcfdatalimit)
- goto bogus_rle;
- pixel=(*xcfdata++);
- for (j= 0; j < (ssize_t) length; j++)
- {
- data=pixel;
- switch (i)
+ case 1:
{
- case 0:
- {
- if (inDocInfo->image_type != GIMP_GRAY)
- {
- SetPixelRed(tile_image,ScaleCharToQuantum(data),q);
- SetPixelGreen(tile_image,ScaleCharToQuantum(data),q);
- SetPixelBlue(tile_image,ScaleCharToQuantum(data),q);
- SetPixelAlpha(tile_image,ScaleCharToQuantum(
- (unsigned char) inLayerInfo->alpha),q);
- }
- else
- {
- SetPixelGray(tile_image,ScaleCharToQuantum(data),q);
- SetPixelAlpha(tile_image,ScaleCharToQuantum(
- (unsigned char) inLayerInfo->alpha),q);
- }
- break;
- }
- case 1:
- {
+ if (inDocInfo->image_type == GIMP_GRAY)
+ SetPixelAlpha(tile_image,ScaleCharToQuantum(data),q);
+ else
SetPixelGreen(tile_image,ScaleCharToQuantum(data),q);
- break;
- }
- case 2:
- {
- SetPixelBlue(tile_image,ScaleCharToQuantum(data),q);
- break;
- }
- case 3:
- {
- SetPixelAlpha(tile_image,data == 0 ? OpaqueAlpha :
- ScaleCharToQuantum((unsigned char) inLayerInfo->alpha),q);
- break;
- }
+ break;
+ }
+ case 2:
+ {
+ SetPixelBlue(tile_image,ScaleCharToQuantum(data),q);
+ break;
+ }
+ case 3:
+ {
+ SetPixelAlpha(tile_image,ScaleCharToQuantum(data),q);
+ break;
}
- q+=GetPixelChannels(tile_image);
}
+ q+=GetPixelChannels(tile_image);
}
- }
- if (SyncAuthenticPixels(tile_image,exception) == MagickFalse)
- break;
+ }
}
+ if (SyncAuthenticPixels(tile_image,exception) == MagickFalse)
+ break;
+ }
xcfodata=(unsigned char *) RelinquishMagickMemory(xcfodata);
return(MagickTrue);
}
static MagickBooleanType load_level(Image *image,XCFDocInfo *inDocInfo,
- XCFLayerInfo *inLayerInfo)
+ XCFLayerInfo *inLayerInfo,ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
int
destLeft = 0,
destTop = 0;
tile_image_height;
/* start reading the data */
- exception=inDocInfo->exception;
width=ReadBlobMSBLong(image);
height=ReadBlobMSBLong(image);
/* composite the tile onto the layer's image, and then destroy it */
(void) CompositeImage(inLayerInfo->image,tile_image,CopyCompositeOp,
- MagickFalse,destLeft*TILE_WIDTH,destTop*TILE_HEIGHT,exception);
+ MagickTrue,destLeft * TILE_WIDTH,destTop*TILE_HEIGHT,exception);
tile_image=DestroyImage(tile_image);
/* adjust tile position */
}
static MagickBooleanType load_hierarchy(Image *image,XCFDocInfo *inDocInfo,
- XCFLayerInfo *inLayer)
+ XCFLayerInfo *inLayer, ExceptionInfo *exception)
{
MagickOffsetType
saved_pos,
offset=SeekBlob(image, offset, SEEK_SET);
/* read in the level */
- if (load_level (image, inDocInfo, inLayer) == 0)
+ if (load_level (image, inDocInfo, inLayer, exception) == 0)
return(MagickFalse);
/* restore the saved position so we'll be ready to
* read the next offset.
return(MagickTrue);
}
-static MagickBooleanType ReadOneLayer(Image* image,XCFDocInfo* inDocInfo,
- XCFLayerInfo *outLayer, ExceptionInfo *exception )
+static MagickBooleanType ReadOneLayer(const ImageInfo *image_info,Image* image,
+ XCFDocInfo* inDocInfo,XCFLayerInfo *outLayer,const ssize_t layer,
+ ExceptionInfo *exception )
{
MagickOffsetType
offset;
outLayer->type = ReadBlobMSBLong(image);
(void) ReadBlobStringWithLongSize(image, outLayer->name,
sizeof(outLayer->name),exception);
- /* allocate the image for this layer */
- outLayer->image=CloneImage(image,outLayer->width, outLayer->height,MagickTrue,
- exception);
- if (outLayer->image == (Image *) NULL)
- return MagickFalse;
/* read the layer properties! */
foundPropEnd = 0;
while ( (foundPropEnd == MagickFalse) && (EOFBlob(image) == MagickFalse) ) {
if (foundPropEnd == MagickFalse)
return(MagickFalse);
+ /* allocate the image for this layer */
+ if (image_info->number_scenes != 0)
+ {
+ ssize_t
+ scene;
+
+ scene=inDocInfo->number_layers-layer-1;
+ if (scene > (ssize_t) (image_info->scene+image_info->number_scenes-1))
+ {
+ outLayer->image=CloneImage(image,0,0,MagickTrue,exception);
+ if (outLayer->image == (Image *) NULL)
+ return(MagickFalse);
+ outLayer->image->page.x=outLayer->offset_x;
+ outLayer->image->page.y=outLayer->offset_y;
+ outLayer->image->page.width=outLayer->width;
+ outLayer->image->page.height=outLayer->height;
+ return(MagickTrue);
+ }
+ }
+ outLayer->image=CloneImage(image,outLayer->width, outLayer->height,MagickTrue,
+ exception);
+ if (outLayer->image == (Image *) NULL)
+ return(MagickFalse);
/* clear the image based on the layer opacity */
outLayer->image->background_color.alpha=
- ScaleCharToQuantum((unsigned char) (255-outLayer->alpha));
+ ScaleCharToQuantum((unsigned char) outLayer->alpha);
(void) SetImageBackgroundColor(outLayer->image,exception);
+ outLayer->image->page.x=outLayer->offset_x;
+ outLayer->image->page.y=outLayer->offset_y;
+ outLayer->image->page.width=outLayer->width;
+ outLayer->image->page.height=outLayer->height;
/* set the compositing mode */
outLayer->image->compose = GIMPBlendModeToCompositeOperator( outLayer->mode );
if ( outLayer->visible == MagickFalse )
if (offset < 0)
(void) ThrowMagickException(exception,GetMagickModule(),
CorruptImageError,"InvalidImageHeader","`%s'",image->filename);
- if (load_hierarchy (image, inDocInfo, outLayer) == 0)
+ if (load_hierarchy (image, inDocInfo, outLayer, exception) == 0)
return(MagickFalse);
/* read in the layer mask */
return MagickTrue;
}
-
+\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
%
% o exception: return any errors or warnings in this structure.
%
-%
*/
static Image *ReadXCFImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
return((Image *) NULL);
}
count=ReadBlob(image,14,(unsigned char *) magick);
- if ((count == 0) ||
+ if ((count != 14) ||
(LocaleNCompare((char *) magick,"gimp xcf",8) != 0))
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
(void) ResetMagickMemory(&doc_info,0,sizeof(XCFDocInfo));
- doc_info.exception=exception;
doc_info.width=ReadBlobMSBLong(image);
doc_info.height=ReadBlobMSBLong(image);
if ((doc_info.width > 262144) || (doc_info.height > 262144))
image->compression=NoCompression;
image->depth=8;
if (image_type == GIMP_RGB)
- image->colorspace=RGBColorspace;
+ SetImageColorspace(image,sRGBColorspace,exception);
else
if (image_type == GIMP_GRAY)
- image->colorspace=GRAYColorspace;
+ SetImageColorspace(image,GRAYColorspace,exception);
else
if (image_type == GIMP_INDEXED)
ThrowReaderException(CoderError,"ColormapTypeNotSupported");
(void) SetImageBackgroundColor(image,exception);
- image->matte=MagickTrue;
+ (void) SetImageAlpha(image,OpaqueAlpha,exception);
/*
Read properties.
*/
XCFLayerInfo
*layer_info;
+ status=SetImageExtent(image,image->columns,image->rows,exception);
+ if (status == MagickFalse)
+ return(DestroyImageList(image));
/*
the read pointer
*/
break;
}
} while (foundAllLayers == MagickFalse);
+ doc_info.number_layers=number_layers;
offset=SeekBlob(image,oldPos,SEEK_SET); /* restore the position! */
if (offset < 0)
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
/* seek to the layer offset */
offset=SeekBlob(image,offset,SEEK_SET);
/* read in the layer */
- layer_ok=ReadOneLayer(image,&doc_info,&layer_info[current_layer],
- exception);
+ layer_ok=ReadOneLayer(image_info,image,&doc_info,
+ &layer_info[current_layer],current_layer,exception);
if (layer_ok == MagickFalse)
{
int j;
for (j=0; j < current_layer; j++)
layer_info[j].image=DestroyImage(layer_info[j].image);
- ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
- }
+ layer_info=(XCFLayerInfo *) RelinquishMagickMemory(layer_info);
+ ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+ }
/* restore the saved position so we'll be ready to
* read the next offset.
*/
/*
Composite the layer data onto the main image, dispose the layer.
*/
- (void) CompositeImage(image,layer_info[0].image,OverCompositeOp,
- MagickFalse,layer_info[0].offset_x,layer_info[0].offset_y,exception);
+ (void) CompositeImage(image,layer_info[0].image,CopyCompositeOp,
+ MagickTrue,layer_info[0].offset_x,layer_info[0].offset_y,exception);
layer_info[0].image =DestroyImage( layer_info[0].image);
}
else
layer_info[j].offset_x, layer_info[j].offset_y );
layer_info[j].image =DestroyImage( layer_info[j].image );
- /* Bob says that if we do this, we'll get REAL gray images! */
+ /* If we do this, we'll get REAL gray images! */
if ( image_type == GIMP_GRAY ) {
QuantizeInfo qi;
GetQuantizeInfo(&qi);
#else
{
/* NOTE: XCF layers are REVERSED from composite order! */
- signed int j;
+ ssize_t j;
/* first we copy the last layer on top of the main image */
(void) CompositeImage(image,layer_info[number_layers-1].image,
- CopyCompositeOp,MagickFalse,layer_info[number_layers-1].offset_x,
+ CopyCompositeOp,MagickTrue,layer_info[number_layers-1].offset_x,
layer_info[number_layers-1].offset_y,exception);
- layer_info[number_layers-1].image=DestroyImage(
- layer_info[number_layers-1].image);
+ layer_info[number_layers-1].image=DestroyImage(
+ layer_info[number_layers-1].image);
/* now reverse the order of the layers as they are put
into subimages
*/
- j=number_layers-2;
- image->next=layer_info[j].image;
- layer_info[j].image->previous=image;
- layer_info[j].image->page.x=layer_info[j].offset_x;
- layer_info[j].image->page.y=layer_info[j].offset_y;
- layer_info[j].image->page.width=layer_info[j].width;
- layer_info[j].image->page.height=layer_info[j].height;
- for (j=number_layers-3; j>=0; j--)
- {
- if (j > 0)
- layer_info[j].image->next=layer_info[j-1].image;
- if (j < (number_layers-1))
- layer_info[j].image->previous=layer_info[j+1].image;
- layer_info[j].image->page.x=layer_info[j].offset_x;
- layer_info[j].image->page.y=layer_info[j].offset_y;
- layer_info[j].image->page.width=layer_info[j].width;
- layer_info[j].image->page.height=layer_info[j].height;
- }
+ for (j=(ssize_t) number_layers-2; j >= 0; j--)
+ AppendImageToList(&image,layer_info[j].image);
}
#endif
}
entry->magick=(IsImageFormatHandler *) IsXCF;
entry->description=ConstantString("GIMP image");
entry->module=ConstantString("XCF");
- entry->seekable_stream=MagickTrue;
+ entry->flags|=CoderSeekableStreamFlag;
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
projects / imagemagick / blobdiff