% July 1992 %
% %
% %
-% Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2012 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 %
/*
Include declarations.
*/
-#include "magick/studio.h"
-#include "magick/property.h"
-#include "magick/blob.h"
-#include "magick/blob-private.h"
-#include "magick/cache.h"
-#include "magick/color.h"
-#include "magick/color-private.h"
-#include "magick/colormap.h"
-#include "magick/colormap-private.h"
-#include "magick/constitute.h"
-#include "magick/enhance.h"
-#include "magick/exception.h"
-#include "magick/exception-private.h"
-#include "magick/image.h"
-#include "magick/image-private.h"
-#include "magick/list.h"
-#include "magick/magick.h"
-#include "magick/memory_.h"
-#include "magick/monitor.h"
-#include "magick/monitor-private.h"
-#include "magick/option.h"
-#include "magick/resource_.h"
-#include "magick/quantum-private.h"
-#include "magick/static.h"
-#include "magick/string_.h"
-#include "magick/string-private.h"
-#include "magick/module.h"
+#include "MagickCore/studio.h"
+#include "MagickCore/property.h"
+#include "MagickCore/blob.h"
+#include "MagickCore/blob-private.h"
+#include "MagickCore/cache.h"
+#include "MagickCore/color.h"
+#include "MagickCore/color-private.h"
+#include "MagickCore/colormap.h"
+#include "MagickCore/colormap-private.h"
+#include "MagickCore/constitute.h"
+#include "MagickCore/enhance.h"
+#include "MagickCore/exception.h"
+#include "MagickCore/exception-private.h"
+#include "MagickCore/image.h"
+#include "MagickCore/image-private.h"
+#include "MagickCore/list.h"
+#include "MagickCore/magick.h"
+#include "MagickCore/memory_.h"
+#include "MagickCore/monitor.h"
+#include "MagickCore/monitor-private.h"
+#include "MagickCore/option.h"
+#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/resource_.h"
+#include "MagickCore/quantum-private.h"
+#include "MagickCore/static.h"
+#include "MagickCore/string_.h"
+#include "MagickCore/string-private.h"
+#include "MagickCore/module.h"
\f
/*
Dicom medical image declarations.
static unsigned short ReadDCMLSBShort(DCMStreamInfo *stream_info,Image *image)
{
+ int
+ shift;
+
unsigned short
value;
if (image->compression != RLECompression)
return(ReadBlobLSBShort(image));
+ shift=image->depth < 16 ? 4 : 8;
value=ReadDCMByte(stream_info,image) | (unsigned short)
- (ReadDCMByte(stream_info,image) << 4);
+ (ReadDCMByte(stream_info,image) << shift);
return(value);
}
static unsigned short ReadDCMMSBShort(DCMStreamInfo *stream_info,Image *image)
{
+ int
+ shift;
unsigned short
value;
if (image->compression != RLECompression)
return(ReadBlobMSBShort(image));
- value=(ReadDCMByte(stream_info,image) << 4) | (unsigned short)
+ shift=image->depth < 16 ? 4 : 8;
+ value=(ReadDCMByte(stream_info,image) << shift) | (unsigned short)
ReadDCMByte(stream_info,image);
return(value);
}
index,
*redmap;
- ssize_t
- element,
- group,
- scene,
- window_center,
- y;
-
MagickBooleanType
explicit_file,
use_explicit,
Quantum
*scale;
- register IndexPacket
- *indexes;
-
register ssize_t
i,
x;
- register PixelPacket
+ register Quantum
*q;
register unsigned char
*p;
- ssize_t
- count;
-
- size_t
- length;
-
- unsigned char
- *data;
-
size_t
bits_allocated,
bytes_per_pixel,
colors,
+ depth,
height,
- high_bit,
+ length,
mask,
max_value,
number_scenes,
width,
window_width;
+ ssize_t
+ count,
+ element,
+ group,
+ scene,
+ window_center,
+ y;
+
+
+ unsigned char
+ *data;
+
/*
Open image file.
*/
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- image=AcquireImage(image_info);
+ image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
/*
Read DCM preamble.
*/
- stream_info=(DCMStreamInfo *) AcquireAlignedMemory(1,sizeof(*stream_info));
+ stream_info=(DCMStreamInfo *) AcquireMagickMemory(sizeof(*stream_info));
if (stream_info == (DCMStreamInfo *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
(void) ResetMagickMemory(stream_info,0,sizeof(*stream_info));
(void) CopyMagickString(photometric,"MONOCHROME1 ",MaxTextExtent);
bits_allocated=8;
bytes_per_pixel=1;
- high_bit=0;
polarity=MagickFalse;
data=(unsigned char *) NULL;
+ depth=8;
element=0;
explicit_vr[2]='\0';
explicit_file=MagickFalse;
if ((group == (ssize_t) dicom_info[i].group) &&
(element == (ssize_t) dicom_info[i].element))
break;
- (void) fprintf(stdout,"0x%04lX %4ld %s-%s (0x%04lx,0x%04lx)",
- (size_t) image->offset,(ssize_t) length,implicit_vr,
- explicit_vr,(size_t) group,(size_t) element);
+ (void) FormatLocaleFile(stdout,"0x%04lX %4ld %s-%s (0x%04lx,0x%04lx)",
+ (unsigned long) image->offset,(long) length,implicit_vr,
+ explicit_vr,(unsigned long) group,(unsigned long) element);
if (dicom_info[i].description != (char *) NULL)
- (void) fprintf(stdout," %s",dicom_info[i].description);
- (void) fprintf(stdout,": ");
+ (void) FormatLocaleFile(stdout," %s",dicom_info[i].description);
+ (void) FormatLocaleFile(stdout,": ");
}
if ((group == 0x7FE0) && (element == 0x0010))
{
if (image_info->verbose != MagickFalse)
- (void) fprintf(stdout,"\n");
+ (void) FormatLocaleFile(stdout,"\n");
break;
}
/*
count=ReadBlob(image,(size_t) quantum*length,data);
if (count != (ssize_t) (quantum*length))
{
- (void) fprintf(stdout,"count=%d quantum=%d length=%d "
- "group=%d\n",(int) count,(int) quantum,(int) length,(int)
- group);
+ (void) FormatLocaleFile(stdout,"count=%d quantum=%d "
+ "length=%d group=%d\n",(int) count,(int) quantum,(int)
+ length,(int) group);
ThrowReaderException(CorruptImageError,
"InsufficientImageDataInFile");
}
group=0;
element=0;
if (image_info->verbose != MagickFalse)
- (void) fprintf(stdout,
+ (void) FormatLocaleFile(stdout,
"Corrupted image - trying explicit format\n");
break;
}
(void) CopyMagickString(transfer_syntax,(char *) data,
MaxTextExtent);
if (image_info->verbose != MagickFalse)
- (void) fprintf(stdout,"transfer_syntax=%s\n",(const char*)
- transfer_syntax);
+ (void) FormatLocaleFile(stdout,"transfer_syntax=%s\n",
+ (const char*) transfer_syntax);
if (strncmp(transfer_syntax,"1.2.840.10008.1.2",17) == 0)
{
int
bytes_per_pixel=1;
if (datum > 8)
bytes_per_pixel=2;
- image->depth=bits_allocated;
- if (image->depth > 32)
+ depth=bits_allocated;
+ if (depth > 32)
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
max_value=(1UL << bits_allocated)-1;
break;
bytes_per_pixel=1;
if (significant_bits > 8)
bytes_per_pixel=2;
- image->depth=significant_bits;
- if (image->depth > 32)
+ depth=significant_bits;
+ if (depth > 32)
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
max_value=(1UL << significant_bits)-1;
mask=(size_t) GetQuantumRange(significant_bits);
/*
Visible pixel range: center.
*/
- window_center=StringToLong((char *) data);
+ if (data != (unsigned char *) NULL)
+ window_center=StringToLong((char *) data);
break;
}
case 0x1051:
/*
Visible pixel range: width.
*/
- window_width=StringToUnsignedLong((char *) data);
+ if (data != (unsigned char *) NULL)
+ window_width=StringToUnsignedLong((char *) data);
break;
}
case 0x1200:
if (data == (unsigned char *) NULL)
break;
colors=(size_t) (length/bytes_per_pixel);
- datum=colors;
+ datum=(int) colors;
graymap=(int *) AcquireQuantumMemory((size_t) colors,
sizeof(*graymap));
if (graymap == (int *) NULL)
if (data == (unsigned char *) NULL)
break;
colors=(size_t) (length/2);
- datum=colors;
+ datum=(int) colors;
redmap=(int *) AcquireQuantumMemory((size_t) colors,
sizeof(*redmap));
if (redmap == (int *) NULL)
if (data == (unsigned char *) NULL)
break;
colors=(size_t) (length/2);
- datum=colors;
+ datum=(int) colors;
greenmap=(int *) AcquireQuantumMemory((size_t) colors,
sizeof(*greenmap));
if (greenmap == (int *) NULL)
if (data == (unsigned char *) NULL)
break;
colors=(size_t) (length/2);
- datum=colors;
+ datum=(int) colors;
bluemap=(int *) AcquireQuantumMemory((size_t) colors,
sizeof(*bluemap));
if (bluemap == (int *) NULL)
if ((i == (ssize_t) length) || (length > 4))
{
(void) SubstituteString(&attribute," ","");
- (void) SetImageProperty(image,attribute,(char *) data);
+ (void) SetImageProperty(image,attribute,(char *) data,exception);
}
attribute=DestroyString(attribute);
}
if (image_info->verbose != MagickFalse)
{
if (data == (unsigned char *) NULL)
- (void) fprintf(stdout,"%d\n",datum);
+ (void) FormatLocaleFile(stdout,"%d\n",datum);
else
{
/*
datum=0;
for (j=(ssize_t) length-1; j >= 0; j--)
datum=(256*datum+data[j]);
- (void) fprintf(stdout,"%d",datum);
+ (void) FormatLocaleFile(stdout,"%d",datum);
}
else
for (i=0; i < (ssize_t) length; i++)
if (isprint((int) data[i]) != MagickFalse)
- (void) fprintf(stdout,"%c",data[i]);
+ (void) FormatLocaleFile(stdout,"%c",data[i]);
else
- (void) fprintf(stdout,"%c",'.');
- (void) fprintf(stdout,"\n");
+ (void) FormatLocaleFile(stdout,"%c",'.');
+ (void) FormatLocaleFile(stdout,"\n");
}
}
if (data != (unsigned char *) NULL)
for (i=0; i < (ssize_t) stream_info->remaining; i++)
(void) ReadBlobByte(image);
tag=(ReadBlobLSBShort(image) << 16) | ReadBlobLSBShort(image);
+ (void) tag;
length=(size_t) ReadBlobLSBLong(image);
stream_info->offset_count=length >> 2;
if (stream_info->offset_count != 0)
if (stream_info->offsets == (ssize_t *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
for (i=0; i < (ssize_t) stream_info->offset_count; i++)
- stream_info->offsets[i]=(ssize_t) ReadBlobLSBLong(image);
+ stream_info->offsets[i]=(int) ReadBlobLSBLong(image);
offset=TellBlob(image);
for (i=0; i < (ssize_t) stream_info->offset_count; i++)
stream_info->offsets[i]+=offset;
(void) fputc(c,file);
}
(void) fclose(file);
- (void) FormatMagickString(read_info->filename,MaxTextExtent,
+ (void) FormatLocaleString(read_info->filename,MaxTextExtent,
"jpeg:%s",filename);
if (image->compression == JPEG2000Compression)
- (void) FormatMagickString(read_info->filename,MaxTextExtent,
+ (void) FormatLocaleString(read_info->filename,MaxTextExtent,
"jp2:%s",filename);
jpeg_image=ReadImage(read_info,exception);
if (jpeg_image != (Image *) NULL)
while (property != (const char *) NULL)
{
(void) SetImageProperty(jpeg_image,property,
- GetImageProperty(image,property));
+ GetImageProperty(image,property,exception),exception);
property=GetNextImageProperty(image);
}
AppendImageToList(&images,jpeg_image);
image=DestroyImage(image);
return(GetFirstImageInList(images));
}
- if (image->depth != (1UL*MAGICKCORE_QUANTUM_DEPTH))
+ if (depth != (1UL*MAGICKCORE_QUANTUM_DEPTH))
{
QuantumAny
range;
/*
Compute pixel scaling table.
*/
- length=(size_t) (GetQuantumRange(image->depth)+1);
+ length=(size_t) (GetQuantumRange(depth)+1);
scale=(Quantum *) AcquireQuantumMemory(length,sizeof(*scale));
if (scale == (Quantum *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
- range=GetQuantumRange(image->depth);
- for (i=0; i < (ssize_t) (GetQuantumRange(image->depth)+1); i++)
+ range=GetQuantumRange(depth);
+ for (i=0; i < (ssize_t) (GetQuantumRange(depth)+1); i++)
scale[i]=ScaleAnyToQuantum((size_t) i,range);
}
if (image->compression == RLECompression)
{
- unsigned int
- tag;
-
size_t
length;
+ unsigned int
+ tag;
+
/*
Read RLE offset table.
*/
for (i=0; i < (ssize_t) stream_info->remaining; i++)
(void) ReadBlobByte(image);
tag=(ReadBlobLSBShort(image) << 16) | ReadBlobLSBShort(image);
+ (void) tag;
length=(size_t) ReadBlobLSBLong(image);
stream_info->offset_count=length >> 2;
if (stream_info->offset_count != 0)
if (stream_info->offsets == (ssize_t *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
for (i=0; i < (ssize_t) stream_info->offset_count; i++)
- stream_info->offsets[i]=(ssize_t) ReadBlobLSBLong(image);
+ stream_info->offsets[i]=(int) ReadBlobLSBLong(image);
offset=TellBlob(image);
for (i=0; i < (ssize_t) stream_info->offset_count; i++)
stream_info->offsets[i]+=offset;
{
if (image_info->ping != MagickFalse)
break;
- if (image->compression == RLECompression)
- {
- unsigned int
- tag;
-
- /*
- Read RLE segment table.
- */
- for (i=0; i < (ssize_t) stream_info->remaining; i++)
- (void) ReadBlobByte(image);
- tag=(ReadBlobLSBShort(image) << 16) | ReadBlobLSBShort(image);
- stream_info->remaining=(size_t) ReadBlobLSBLong(image);
- if ((tag != 0xFFFEE000) || (stream_info->remaining <= 64) ||
- (EOFBlob(image) == MagickTrue))
- ThrowReaderException(CorruptImageError,"ImproperImageHeader");
- stream_info->count=0;
- stream_info->segment_count=ReadBlobLSBLong(image);
- for (i=0; i < 15; i++)
- stream_info->segments[i]=(ssize_t) ReadBlobLSBLong(image);
- stream_info->remaining-=64;
- }
image->columns=(size_t) width;
image->rows=(size_t) height;
- if ((image->colormap == (PixelPacket *) NULL) && (samples_per_pixel == 1))
+ image->depth=depth;
+ if ((image->colormap == (PixelInfo *) NULL) && (samples_per_pixel == 1))
{
+ size_t
+ one;
+
+ one=1;
if (colors == 0)
- colors=1UL << image->depth;
- if (AcquireImageColormap(image,colors) == MagickFalse)
+ colors=one << depth;
+ if (AcquireImageColormap(image,one << depth,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if (redmap != (int *) NULL)
for (i=0; i < (ssize_t) colors; i++)
image->colormap[i].blue=index;
}
}
+ if (image->compression == RLECompression)
+ {
+ unsigned int
+ tag;
+
+ /*
+ Read RLE segment table.
+ */
+ for (i=0; i < (ssize_t) stream_info->remaining; i++)
+ (void) ReadBlobByte(image);
+ tag=(ReadBlobLSBShort(image) << 16) | ReadBlobLSBShort(image);
+ stream_info->remaining=(size_t) ReadBlobLSBLong(image);
+ if ((tag != 0xFFFEE000) || (stream_info->remaining <= 64) ||
+ (EOFBlob(image) == MagickTrue))
+ ThrowReaderException(CorruptImageError,"ImproperImageHeader");
+ stream_info->count=0;
+ stream_info->segment_count=ReadBlobLSBLong(image);
+ if (stream_info->segment_count > 1)
+ {
+ bytes_per_pixel=1;
+ depth=8;
+ }
+ for (i=0; i < 15; i++)
+ stream_info->segments[i]=(int) ReadBlobLSBLong(image);
+ stream_info->remaining-=64;
+ }
if ((samples_per_pixel > 1) && (image->interlace == PlaneInterlace))
{
/*
for (y=0; y < (ssize_t) image->rows; y++)
{
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
{
case 0:
{
- q->red=ScaleCharToQuantum((unsigned char)
- ReadDCMByte(stream_info,image));
+ SetPixelRed(image,ScaleCharToQuantum((unsigned char)
+ ReadDCMByte(stream_info,image)),q);
break;
}
case 1:
{
- q->green=ScaleCharToQuantum((unsigned char)
- ReadDCMByte(stream_info,image));
+ SetPixelGreen(image,ScaleCharToQuantum((unsigned char)
+ ReadDCMByte(stream_info,image)),q);
break;
}
case 2:
{
- q->blue=ScaleCharToQuantum((unsigned char)
- ReadDCMByte(stream_info,image));
+ SetPixelBlue(image,ScaleCharToQuantum((unsigned char)
+ ReadDCMByte(stream_info,image)),q);
break;
}
case 3:
{
- q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(
- (unsigned char) ReadDCMByte(stream_info,image)));
+ SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
+ ReadDCMByte(stream_info,image)),q);
break;
}
default:
break;
}
- q++;
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
- image->rows);
+ image->rows);
if (status == MagickFalse)
break;
}
int
byte;
- LongPixelPacket
+ PixelPacket
pixel;
/*
for (y=0; y < (ssize_t) image->rows; y++)
{
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
break;
- indexes=GetAuthenticIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
{
if (samples_per_pixel == 1)
pixel_value=(int) (polarity != MagickFalse ? (max_value-
ReadDCMLSBShort(stream_info,image)) :
ReadDCMLSBShort(stream_info,image));
- if (signed_data == 1)
- pixel_value=((signed short) pixel_value);
}
else
{
window_max,
window_min;
- window_min=(ssize_t) ceil(window_center-(window_width-1)/2.0-
- 0.5);
- window_max=(ssize_t) floor(window_center+(window_width-1)/2.0+
- 0.5);
+ window_min=(ssize_t) ceil(window_center-(window_width-1)/
+ 2.0-0.5);
+ window_max=(ssize_t) floor(window_center+(window_width-1)/
+ 2.0+0.5);
if ((ssize_t) pixel_value <= window_min)
index=0;
else
0.5)/(window_width-1))+0.5));
}
index&=mask;
- index=(int) ConstrainColormapIndex(image,(size_t) index);
- indexes[x]=(IndexPacket) index;
+ index=(int) ConstrainColormapIndex(image,(size_t) index,
+ exception);
+ SetPixelIndex(image,index,q);
pixel.red=1UL*image->colormap[index].red;
pixel.green=1UL*image->colormap[index].green;
pixel.blue=1UL*image->colormap[index].blue;
pixel.blue=scale[pixel.blue];
}
}
- q->red=(Quantum) pixel.red;
- q->green=(Quantum) pixel.green;
- q->blue=(Quantum) pixel.blue;
- q++;
+ SetPixelRed(image,pixel.red,q);
+ SetPixelGreen(image,pixel.green,q);
+ SetPixelBlue(image,pixel.blue,q);
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
break;
}
}
+ if (stream_info->segment_count > 1)
+ for (y=0; y < (ssize_t) image->rows; y++)
+ {
+ q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ if (samples_per_pixel == 1)
+ {
+ int
+ pixel_value;
+
+ if (bytes_per_pixel == 1)
+ pixel_value=polarity != MagickFalse ?
+ ((int) max_value-ReadDCMByte(stream_info,image)) :
+ ReadDCMByte(stream_info,image);
+ else
+ if ((bits_allocated != 12) || (significant_bits != 12))
+ {
+ if (image->endian == MSBEndian)
+ pixel_value=(int) (polarity != MagickFalse ?
+ (max_value-ReadDCMMSBShort(stream_info,image)) :
+ ReadDCMMSBShort(stream_info,image));
+ else
+ pixel_value=(int) (polarity != MagickFalse ?
+ (max_value-ReadDCMLSBShort(stream_info,image)) :
+ ReadDCMLSBShort(stream_info,image));
+ if (signed_data == 1)
+ pixel_value=((signed short) pixel_value);
+ }
+ else
+ {
+ if ((i & 0x01) != 0)
+ pixel_value=(ReadDCMByte(stream_info,image) << 8) |
+ byte;
+ else
+ {
+ if (image->endian == MSBEndian)
+ pixel_value=(int) ReadDCMMSBShort(stream_info,
+ image);
+ else
+ pixel_value=(int) ReadDCMLSBShort(stream_info,
+ image);
+ byte=(int) (pixel_value & 0x0f);
+ pixel_value>>=4;
+ }
+ i++;
+ }
+ index=pixel_value;
+ if (window_width == 0)
+ {
+ if (signed_data == 1)
+ index=pixel_value-32767;
+ }
+ else
+ {
+ ssize_t
+ window_max,
+ window_min;
+
+ window_min=(ssize_t) ceil(window_center-(window_width-1)/
+ 2.0-0.5);
+ window_max=(ssize_t) floor(window_center+(window_width-1)/
+ 2.0+0.5);
+ if ((ssize_t) pixel_value <= window_min)
+ index=0;
+ else
+ if ((ssize_t) pixel_value > window_max)
+ index=(int) max_value;
+ else
+ index=(int) (max_value*(((pixel_value-window_center-
+ 0.5)/(window_width-1))+0.5));
+ }
+ index&=mask;
+ index=(int) ConstrainColormapIndex(image,(size_t) index,
+ exception);
+ SetPixelIndex(image,(((size_t) GetPixelIndex(image,q)) |
+ (((size_t) index) << 8)),q);
+ pixel.red=1UL*image->colormap[index].red;
+ pixel.green=1UL*image->colormap[index].green;
+ pixel.blue=1UL*image->colormap[index].blue;
+ }
+ else
+ {
+ if (bytes_per_pixel == 1)
+ {
+ pixel.red=(size_t) ReadDCMByte(stream_info,image);
+ pixel.green=(size_t) ReadDCMByte(stream_info,image);
+ pixel.blue=(size_t) ReadDCMByte(stream_info,image);
+ }
+ else
+ {
+ if (image->endian == MSBEndian)
+ {
+ pixel.red=ReadDCMMSBShort(stream_info,image);
+ pixel.green=ReadDCMMSBShort(stream_info,image);
+ pixel.blue=ReadDCMMSBShort(stream_info,image);
+ }
+ else
+ {
+ pixel.red=ReadDCMLSBShort(stream_info,image);
+ pixel.green=ReadDCMLSBShort(stream_info,image);
+ pixel.blue=ReadDCMLSBShort(stream_info,image);
+ }
+ }
+ pixel.red&=mask;
+ pixel.green&=mask;
+ pixel.blue&=mask;
+ if (scale != (Quantum *) NULL)
+ {
+ pixel.red=scale[pixel.red];
+ pixel.green=scale[pixel.green];
+ pixel.blue=scale[pixel.blue];
+ }
+ }
+ SetPixelRed(image,(((size_t) GetPixelRed(image,q)) |
+ (((size_t) pixel.red) << 8)),q);
+ SetPixelGreen(image,(((size_t) GetPixelGreen(image,q)) |
+ (((size_t) pixel.green) << 8)),q);
+ SetPixelBlue(image,(((size_t) GetPixelBlue(image,q)) |
+ (((size_t) pixel.blue) << 8)),q);
+ q+=GetPixelChannels(image);
+ }
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
+ break;
+ if (image->previous == (Image *) NULL)
+ {
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
+ if (status == MagickFalse)
+ break;
+ }
+ }
}
if (EOFBlob(image) != MagickFalse)
{
/*
Allocate next image structure.
*/
- AcquireNextImage(image_info,image);
+ AcquireNextImage(image_info,image,exception);
if (GetNextImageInList(image) == (Image *) NULL)
{
image=DestroyImageList(image);
projects / imagemagick / blobdiff