% July 1992 %
% %
% %
-% Copyright 1999-2009 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/colormap-private.h"
-#include "magick/color-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/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.
return(y);
}
+typedef struct _DCMStreamInfo
+{
+ size_t
+ remaining,
+ segment_count;
+
+ ssize_t
+ segments[15];
+
+ size_t
+ offset_count;
+
+ ssize_t
+ *offsets;
+
+ ssize_t
+ count;
+
+ int
+ byte;
+} DCMStreamInfo;
+
+static int ReadDCMByte(DCMStreamInfo *stream_info,Image *image)
+{
+ if (image->compression != RLECompression)
+ return(ReadBlobByte(image));
+ if (stream_info->count == 0)
+ {
+ int
+ byte;
+
+ ssize_t
+ count;
+
+ if (stream_info->remaining <= 2)
+ stream_info->remaining=0;
+ else
+ stream_info->remaining-=2;
+ count=(ssize_t) ReadBlobByte(image);
+ byte=ReadBlobByte(image);
+ if (count == 128)
+ return(0);
+ else
+ if (count < 128)
+ {
+ /*
+ Literal bytes.
+ */
+ stream_info->count=count;
+ stream_info->byte=(-1);
+ return(byte);
+ }
+ else
+ {
+ /*
+ Repeated bytes.
+ */
+ stream_info->count=256-count;
+ stream_info->byte=byte;
+ return(byte);
+ }
+ }
+ stream_info->count--;
+ if (stream_info->byte >= 0)
+ return(stream_info->byte);
+ if (stream_info->remaining > 0)
+ stream_info->remaining--;
+ return(ReadBlobByte(image));
+}
+
+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) << shift);
+ return(value);
+}
+
+static unsigned short ReadDCMMSBShort(DCMStreamInfo *stream_info,Image *image)
+{
+ int
+ shift;
+ unsigned short
+ value;
+
+ if (image->compression != RLECompression)
+ return(ReadBlobMSBShort(image));
+ shift=image->depth < 16 ? 4 : 8;
+ value=(ReadDCMByte(stream_info,image) << shift) | (unsigned short)
+ ReadDCMByte(stream_info,image);
+ return(value);
+}
+
static Image *ReadDCMImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
char
explicit_vr[MaxTextExtent],
implicit_vr[MaxTextExtent],
magick[MaxTextExtent],
- photometric[MaxTextExtent],
- transfer_syntax[MaxTextExtent];
+ photometric[MaxTextExtent];
+
+ DCMStreamInfo
+ *stream_info;
Image
*image;
- long
- element,
- group,
- scene,
- window_center,
- y;
+ int
+ *bluemap,
+ datum,
+ *greenmap,
+ *graymap,
+ index,
+ *redmap;
MagickBooleanType
explicit_file,
Quantum
*scale;
- register IndexPacket
- *indexes;
-
- register long
+ register ssize_t
i,
x;
- register PixelPacket
+ register Quantum
*q;
register unsigned char
*p;
- ssize_t
- count;
-
size_t
- length;
-
- unsigned char
- *data;
-
- unsigned long
bits_allocated,
bytes_per_pixel,
- datum,
+ colors,
+ depth,
height,
- high_bit,
- index,
+ length,
mask,
max_value,
- msb_first,
number_scenes,
quantum,
samples_per_pixel,
width,
window_width;
- unsigned short
- *graymap;
+ 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 *) AcquireMagickMemory(sizeof(*stream_info));
+ if (stream_info == (DCMStreamInfo *) NULL)
+ ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+ (void) ResetMagickMemory(stream_info,0,sizeof(*stream_info));
count=ReadBlob(image,128,(unsigned char *) magick);
if (count != 128)
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
(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;
- graymap=(unsigned short *) NULL;
- group=0;
+ colors=0;
+ redmap=(int *) NULL;
+ greenmap=(int *) NULL;
+ bluemap=(int *) NULL;
+ graymap=(int *) NULL;
height=0;
max_value=255UL;
mask=0xffff;
scale=(Quantum *) NULL;
signed_data=(~0UL);
significant_bits=0;
- *transfer_syntax='\0';
use_explicit=MagickFalse;
explicit_retry = MagickFalse;
width=0;
window_center=0;
window_width=0;
- while ((group != 0x7FE0) || (element != 0x0010))
+ for (group=0; (group != 0x7FE0) || (element != 0x0010); )
{
/*
Read a group.
*/
- image->offset=(long) TellBlob(image);
- group=(long) ReadBlobLSBShort(image);
- element=(long) ReadBlobLSBShort(image);
+ image->offset=(ssize_t) TellBlob(image);
+ group=(ssize_t) ReadBlobLSBShort(image);
+ element=(ssize_t) ReadBlobLSBShort(image);
quantum=0;
/*
Find corresponding VR for this group and element.
*/
for (i=0; dicom_info[i].group < 0xffff; i++)
- if ((group == (long) dicom_info[i].group) &&
- (element == (long) dicom_info[i].element))
+ if ((group == (ssize_t) dicom_info[i].group) &&
+ (element == (ssize_t) dicom_info[i].element))
break;
(void) CopyMagickString(implicit_vr,dicom_info[i].vr,MaxTextExtent);
count=ReadBlob(image,2,(unsigned char *) explicit_vr);
}
datum=0;
if (quantum == 4)
- datum=(unsigned long) ReadBlobLSBLong(image);
+ datum=(int) ReadBlobLSBLong(image);
else
if (quantum == 2)
- datum=(unsigned long) ReadBlobLSBShort(image);
+ datum=(int) ReadBlobLSBShort(image);
quantum=0;
length=1;
if (datum != 0)
quantum=1;
else
quantum=8;
- if (datum != ~0U)
+ if (datum != ~0)
length=(size_t) datum/quantum;
else
{
if (use_explicit == MagickFalse)
explicit_vr[0]='\0';
for (i=0; dicom_info[i].description != (char *) NULL; i++)
- if ((group == (long) dicom_info[i].group) &&
- (element == (long) dicom_info[i].element))
+ 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)",
+ (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;
}
/*
*/
data=(unsigned char *) NULL;
if ((length == 1) && (quantum == 1))
- datum=(unsigned long) ReadBlobByte(image);
+ datum=(int) ReadBlobByte(image);
else
if ((length == 1) && (quantum == 2))
- datum=(unsigned long) ReadBlobLSBShort(image);
+ datum=(int) ReadBlobLSBShort(image);
else
if ((length == 1) && (quantum == 4))
- datum=(unsigned long) ReadBlobLSBLong(image);
+ datum=(int) ReadBlobLSBLong(image);
else
if ((quantum != 0) && (length != 0))
{
count=ReadBlob(image,(size_t) quantum*length,data);
if (count != (ssize_t) (quantum*length))
{
- (void) fprintf(stderr,"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");
}
{
case 0x0010:
{
+ char
+ transfer_syntax[MaxTextExtent];
+
/*
Transfer Syntax.
*/
- if (image_info->verbose != MagickFalse)
- (void) fprintf(stderr,"transfer_syntax=%s\n",(const char*)
- transfer_syntax);
if ((datum == 0) && (explicit_retry == MagickFalse))
{
explicit_retry=MagickTrue;
group=0;
element=0;
if (image_info->verbose != MagickFalse)
- (void) fprintf(stderr,
+ (void) FormatLocaleFile(stdout,
"Corrupted image - trying explicit format\n");
break;
}
+ *transfer_syntax='\0';
if (data != (unsigned char *) NULL)
(void) CopyMagickString(transfer_syntax,(char *) data,
MaxTextExtent);
- if (strcmp(transfer_syntax,"1.2.840.10008.1.2.5") == 0)
- ThrowReaderException(CoderError,"RLECompressionNotSupported");
+ if (image_info->verbose != MagickFalse)
+ (void) FormatLocaleFile(stdout,"transfer_syntax=%s\n",
+ (const char*) transfer_syntax);
+ if (strncmp(transfer_syntax,"1.2.840.10008.1.2",17) == 0)
+ {
+ int
+ subtype,
+ type;
+
+ type=0;
+ subtype=0;
+ (void) sscanf(transfer_syntax+17,".%d.%d",&type,&subtype);
+ switch (type)
+ {
+ case 1:
+ {
+ image->endian=LSBEndian;
+ break;
+ }
+ case 2:
+ {
+ image->endian=MSBEndian;
+ break;
+ }
+ case 4:
+ {
+ if ((subtype >= 80) && (subtype <= 81))
+ image->compression=JPEGCompression;
+ else
+ if ((subtype >= 90) && (subtype <= 93))
+ image->compression=JPEG2000Compression;
+ else
+ image->compression=JPEGCompression;
+ break;
+ }
+ case 5:
+ {
+ image->compression=RLECompression;
+ break;
+ }
+ }
+ }
break;
}
default:
/*
Photometric interpretation.
*/
- for (i=0; i < (long) MagickMin(length,MaxTextExtent-1); i++)
+ for (i=0; i < (ssize_t) MagickMin(length,MaxTextExtent-1); i++)
photometric[i]=(char) data[i];
photometric[i]='\0';
polarity=LocaleCompare(photometric,"MONOCHROME1 ") == 0 ?
/*
Number of frames.
*/
- number_scenes=(unsigned long) atol((char *) data);
+ number_scenes=StringToUnsignedLong((char *) data);
break;
}
case 0x0010:
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=(unsigned long) GetQuantumRange(significant_bits);
+ mask=(size_t) GetQuantumRange(significant_bits);
break;
}
case 0x0102:
/*
Visible pixel range: center.
*/
- window_center=(unsigned long) atol((char *) data);
+ if (data != (unsigned char *) NULL)
+ window_center=StringToLong((char *) data);
break;
}
case 0x1051:
/*
Visible pixel range: width.
*/
- window_width=(unsigned long) atol((char *) data);
+ if (data != (unsigned char *) NULL)
+ window_width=StringToUnsignedLong((char *) data);
break;
}
case 0x1200:
case 0x3006:
{
- unsigned long
- colors;
-
/*
- Populate image colormap.
+ Populate graymap.
*/
if (data == (unsigned char *) NULL)
break;
- colors=(unsigned long) (length/bytes_per_pixel);
- datum=colors;
- graymap=(unsigned short *) AcquireQuantumMemory((size_t) colors,
+ colors=(size_t) (length/bytes_per_pixel);
+ datum=(int) colors;
+ graymap=(int *) AcquireQuantumMemory((size_t) colors,
sizeof(*graymap));
- if (graymap == (unsigned short *) NULL)
- ThrowReaderException(ResourceLimitError,
- "MemoryAllocationFailed");
- for (i=0; i < (long) colors; i++)
+ if (graymap == (int *) NULL)
+ ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+ for (i=0; i < (ssize_t) colors; i++)
if (bytes_per_pixel == 1)
- graymap[i]=(unsigned short) data[i];
+ graymap[i]=(int) data[i];
else
- graymap[i]=(unsigned short) ((short *) data)[i];
+ graymap[i]=(int) ((short *) data)[i];
break;
}
case 0x1201:
+ {
+ unsigned short
+ index;
+
+ /*
+ Populate redmap.
+ */
+ if (data == (unsigned char *) NULL)
+ break;
+ colors=(size_t) (length/2);
+ datum=(int) colors;
+ redmap=(int *) AcquireQuantumMemory((size_t) colors,
+ sizeof(*redmap));
+ if (redmap == (int *) NULL)
+ ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+ p=data;
+ for (i=0; i < (ssize_t) colors; i++)
+ {
+ if (image->endian != LSBEndian)
+ index=(unsigned short) ((*p << 8) | *(p+1));
+ else
+ index=(unsigned short) (*p | (*(p+1) << 8));
+ redmap[i]=(int) index;
+ p+=2;
+ }
+ break;
+ }
case 0x1202:
- case 0x1203:
{
- MagickBooleanType
- status;
+ unsigned short
+ index;
+ /*
+ Populate greenmap.
+ */
+ if (data == (unsigned char *) NULL)
+ break;
+ colors=(size_t) (length/2);
+ datum=(int) colors;
+ greenmap=(int *) AcquireQuantumMemory((size_t) colors,
+ sizeof(*greenmap));
+ if (greenmap == (int *) NULL)
+ ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+ p=data;
+ for (i=0; i < (ssize_t) colors; i++)
+ {
+ if (image->endian != LSBEndian)
+ index=(unsigned short) ((*p << 8) | *(p+1));
+ else
+ index=(unsigned short) (*p | (*(p+1) << 8));
+ greenmap[i]=(int) index;
+ p+=2;
+ }
+ break;
+ }
+ case 0x1203:
+ {
unsigned short
index;
/*
- Initialize colormap.
+ Populate bluemap.
*/
- if (image->columns == 0)
+ if (data == (unsigned char *) NULL)
break;
- status=AcquireImageColormap(image,(unsigned long) (length+1)/2);
- if (status == MagickFalse)
- ThrowReaderException(ResourceLimitError,"UnableToCreateColormap");
+ colors=(size_t) (length/2);
+ datum=(int) colors;
+ bluemap=(int *) AcquireQuantumMemory((size_t) colors,
+ sizeof(*bluemap));
+ if (bluemap == (int *) NULL)
+ ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
p=data;
- for (i=0; i < (long) image->colors; i++)
+ for (i=0; i < (ssize_t) colors; i++)
{
- index=(unsigned short) ((*p) | (*(p+1)) << 8);
- if (element == 0x1201)
- image->colormap[i].red=ScaleShortToQuantum(index);
- if (element == 0x1202)
- image->colormap[i].green=ScaleShortToQuantum(index);
- if (element == 0x1203)
- image->colormap[i].blue=ScaleShortToQuantum(index);
+ if (image->endian != LSBEndian)
+ index=(unsigned short) ((*p << 8) | *(p+1));
+ else
+ index=(unsigned short) (*p | (*(p+1) << 8));
+ bluemap[i]=(int) index;
p+=2;
}
break;
*attribute;
for (i=0; dicom_info[i].description != (char *) NULL; i++)
- if ((group == (long) dicom_info[i].group) &&
- (element == (long) dicom_info[i].element))
+ if ((group == (ssize_t) dicom_info[i].group) &&
+ (element == (ssize_t) dicom_info[i].element))
break;
attribute=AcquireString("dcm:");
(void) ConcatenateString(&attribute,dicom_info[i].description);
- for (i=0; i < (long) MagickMax(length,4); i++)
+ for (i=0; i < (ssize_t) MagickMax(length,4); i++)
if (isprint((int) data[i]) == MagickFalse)
break;
- if ((i == (long) length) || (length > 4))
+ 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);
- data=(unsigned char *) RelinquishMagickMemory(data);
}
if (image_info->verbose != MagickFalse)
{
if (data == (unsigned char *) NULL)
- (void) fprintf(stdout,"%lu\n",datum);
+ (void) FormatLocaleFile(stdout,"%d\n",datum);
else
{
/*
Display group data.
*/
- for (i=0; i < (long) MagickMax(length,4); i++)
+ for (i=0; i < (ssize_t) MagickMax(length,4); i++)
if (isprint((int) data[i]) == MagickFalse)
break;
- if ((i != (long) length) && (length <= 4))
+ if ((i != (ssize_t) length) && (length <= 4))
{
- long
+ ssize_t
j;
datum=0;
- for (j=(long) length-1; j >= 0; j--)
+ for (j=(ssize_t) length-1; j >= 0; j--)
datum=(256*datum+data[j]);
- (void) fprintf(stdout,"%lu",datum);
+ (void) FormatLocaleFile(stdout,"%d",datum);
}
else
- for (i=0; i < (long) length; i++)
+ 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)
+ data=(unsigned char *) RelinquishMagickMemory(data);
if (EOFBlob(image) != MagickFalse)
{
ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
}
if ((width == 0) || (height == 0))
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
- image->columns=(unsigned long) width;
- image->rows=(unsigned long) height;
+ image->columns=(size_t) width;
+ image->rows=(size_t) height;
if (signed_data == 0xffff)
- signed_data=(unsigned long) (significant_bits == 16 ? 1 : 0);
- if ((strcmp(transfer_syntax,"1.2.840.10008.1.2.4.50") == 0) ||
- (strcmp(transfer_syntax,"1.2.840.10008.1.2.4.70") == 0))
+ signed_data=(size_t) (significant_bits == 16 ? 1 : 0);
+ if ((image->compression == JPEGCompression) ||
+ (image->compression == JPEG2000Compression))
{
Image
*images;
int
c;
- unsigned char
- magick[MaxTextExtent];
+ size_t
+ length;
+
+ unsigned int
+ tag;
+
+ /*
+ Read 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)
+ {
+ MagickOffsetType
+ offset;
+ stream_info->offsets=(ssize_t *) AcquireQuantumMemory(
+ stream_info->offset_count,sizeof(*stream_info->offsets));
+ 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]=(int) ReadBlobLSBLong(image);
+ offset=TellBlob(image);
+ for (i=0; i < (ssize_t) stream_info->offset_count; i++)
+ stream_info->offsets[i]+=offset;
+ }
/*
- Handle 2.4.50 lossy JPEG and 2.4.70 lossless JPEG.
+ Handle non-native image formats.
*/
read_info=CloneImageInfo(image_info);
SetImageInfoBlob(read_info,(void *) NULL,0);
- (void) ResetMagickMemory(magick,0,sizeof(magick));
- while ((c=ReadBlobByte(image)) != EOF)
- {
- magick[0]=magick[1];
- magick[1]=magick[2];
- magick[2]=(unsigned char) c;
- if (memcmp(magick,"\377\330\377",3) == 0) /* JPEG sentinel */
- break;
- }
- for (scene=0; scene < (long) number_scenes; scene++)
+ images=NewImageList();
+ for (scene=0; scene < (ssize_t) number_scenes; scene++)
{
char
filename[MaxTextExtent];
FILE
*file;
+ Image
+ *jpeg_image;
+
int
unique_file;
- Image
- *jpeg_image;
+ unsigned int
+ tag;
file=(FILE *) NULL;
unique_file=AcquireUniqueFileResource(filename);
"UnableToCreateTemporaryFile",filename);
break;
}
- (void) fwrite(magick,1,3,file);
- while ((c=ReadBlobByte(image)) != EOF)
+ tag=(ReadBlobLSBShort(image) << 16) | ReadBlobLSBShort(image);
+ length=(size_t) ReadBlobLSBLong(image);
+ if (tag == 0xFFFEE0DD)
+ break; /* sequence delimiter tag */
+ if (tag != 0xFFFEE000)
+ ThrowReaderException(CorruptImageError,"ImproperImageHeader");
+ for ( ; length != 0; length--)
{
+ c=ReadBlobByte(image);
+ if (c == EOF)
+ ThrowFileException(exception,CorruptImageError,
+ "UnexpectedEndOfFile",image->filename);
(void) fputc(c,file);
- magick[0]=magick[1];
- magick[1]=magick[2];
- magick[2]=(unsigned char) c;
- if (memcmp(magick,"\377\330\377",3) == 0) /* JPEG sentinel */
- break;
}
(void) fclose(file);
- (void) FormatMagickString(read_info->filename,MaxTextExtent,
+ (void) FormatLocaleString(read_info->filename,MaxTextExtent,
"jpeg:%s",filename);
+ if (image->compression == JPEG2000Compression)
+ (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 < (long) (GetQuantumRange(image->depth)+1); i++)
- scale[i]=ScaleAnyToQuantum((unsigned long) i,range);
+ range=GetQuantumRange(depth);
+ for (i=0; i < (ssize_t) (GetQuantumRange(depth)+1); i++)
+ scale[i]=ScaleAnyToQuantum((size_t) i,range);
}
- msb_first=strcmp(transfer_syntax,"1.2.840.10008.1.2.2") == 0 ? MagickTrue :
- MagickFalse;
- for (scene=0; scene < (long) number_scenes; scene++)
+ if (image->compression == RLECompression)
+ {
+ 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)
+ {
+ MagickOffsetType
+ offset;
+
+ stream_info->offsets=(ssize_t *) AcquireQuantumMemory(
+ stream_info->offset_count,sizeof(*stream_info->offsets));
+ 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]=(int) ReadBlobLSBLong(image);
+ offset=TellBlob(image);
+ for (i=0; i < (ssize_t) stream_info->offset_count; i++)
+ stream_info->offsets[i]+=offset;
+ }
+ }
+ for (scene=0; scene < (ssize_t) number_scenes; scene++)
{
if (image_info->ping != MagickFalse)
break;
- image->columns=(unsigned long) width;
- image->rows=(unsigned long) height;
- if ((image->colormap == (PixelPacket *) NULL) && (samples_per_pixel == 1))
- if (AcquireImageColormap(image,MaxColormapSize) == MagickFalse)
- ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+ image->columns=(size_t) width;
+ image->rows=(size_t) height;
+ image->depth=depth;
+ if ((image->colormap == (PixelInfo *) NULL) && (samples_per_pixel == 1))
+ {
+ size_t
+ one;
+
+ one=1;
+ if (colors == 0)
+ 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++)
+ {
+ index=redmap[i];
+ if ((scale != (Quantum *) NULL) && (index <= (int) max_value))
+ index=(int) scale[index];
+ image->colormap[i].red=index;
+ }
+ if (greenmap != (int *) NULL)
+ for (i=0; i < (ssize_t) colors; i++)
+ {
+ index=greenmap[i];
+ if ((scale != (Quantum *) NULL) && (index <= (int) max_value))
+ index=(int) scale[index];
+ image->colormap[i].green=index;
+ }
+ if (bluemap != (int *) NULL)
+ for (i=0; i < (ssize_t) colors; i++)
+ {
+ index=bluemap[i];
+ if ((scale != (Quantum *) NULL) && (index <= (int) max_value))
+ index=(int) scale[index];
+ image->colormap[i].blue=index;
+ }
+ if (graymap != (int *) NULL)
+ for (i=0; i < (ssize_t) colors; i++)
+ {
+ index=graymap[i];
+ if ((scale != (Quantum *) NULL) && (index <= (int) max_value))
+ index=(int) scale[index];
+ image->colormap[i].red=index;
+ image->colormap[i].green=index;
+ 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))
{
/*
Convert Planar RGB DCM Medical image to pixel packets.
*/
- for (i=0; i < (long) samples_per_pixel; i++)
+ for (i=0; i < (ssize_t) samples_per_pixel; i++)
{
- for (y=0; y < (long) image->rows; y++)
+ 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 < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
switch ((int) i)
{
case 0:
{
- q->red=ScaleCharToQuantum((unsigned char)
- ReadBlobByte(image));
+ SetPixelRed(image,ScaleCharToQuantum((unsigned char)
+ ReadDCMByte(stream_info,image)),q);
break;
}
case 1:
{
- q->green=ScaleCharToQuantum((unsigned char)
- ReadBlobByte(image));
+ SetPixelGreen(image,ScaleCharToQuantum((unsigned char)
+ ReadDCMByte(stream_info,image)),q);
break;
}
case 2:
{
- q->blue=ScaleCharToQuantum((unsigned char)
- ReadBlobByte(image));
+ SetPixelBlue(image,ScaleCharToQuantum((unsigned char)
+ ReadDCMByte(stream_info,image)),q);
break;
}
case 3:
{
- q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(
- (unsigned char) ReadBlobByte(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,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
const char
*option;
- LongPixelPacket
- pixel;
-
- unsigned long
+ int
byte;
+ PixelPacket
+ pixel;
+
/*
Convert DCM Medical image to pixel packets.
*/
byte=0;
i=0;
if ((window_center != 0) && (window_width == 0))
- window_width=2*window_center;
+ window_width=(size_t) window_center;
option=GetImageOption(image_info,"dcm:display-range");
if (option != (const char *) NULL)
{
window_width=0;
}
(void) ResetMagickMemory(&pixel,0,sizeof(pixel));
- for (y=0; y < (long) image->rows; y++)
+ 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 < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
if (samples_per_pixel == 1)
{
- long
+ int
pixel_value;
if (bytes_per_pixel == 1)
- pixel_value=polarity != MagickFalse ? (long) (max_value-
- ReadBlobByte(image)) : ReadBlobByte(image);
+ pixel_value=polarity != MagickFalse ?
+ ((int) max_value-ReadDCMByte(stream_info,image)) :
+ ReadDCMByte(stream_info,image);
else
if ((bits_allocated != 12) || (significant_bits != 12))
{
- if (msb_first != MagickFalse)
- pixel_value=polarity != MagickFalse ? max_value-
- ReadBlobMSBShort(image) : ReadBlobMSBShort(image);
+ if (image->endian == MSBEndian)
+ pixel_value=(int) (polarity != MagickFalse ? (max_value-
+ ReadDCMMSBShort(stream_info,image)) :
+ ReadDCMMSBShort(stream_info,image));
else
- pixel_value=polarity != MagickFalse ? max_value-
- ReadBlobLSBShort(image) : ReadBlobLSBShort(image);
- if (signed_data == 1)
- pixel_value=(signed short) pixel_value;
+ pixel_value=(int) (polarity != MagickFalse ? (max_value-
+ ReadDCMLSBShort(stream_info,image)) :
+ ReadDCMLSBShort(stream_info,image));
}
else
{
if ((i & 0x01) != 0)
- pixel_value=(ReadBlobByte(image) << 8) | byte;
+ pixel_value=(ReadDCMByte(stream_info,image) << 8) |
+ byte;
else
{
- if (msb_first != MagickFalse)
- pixel_value=ReadBlobMSBShort(image);
+ if (image->endian == MSBEndian)
+ pixel_value=(int) ReadDCMMSBShort(stream_info,
+ image);
else
- pixel_value=ReadBlobLSBShort(image);
- byte=pixel_value & 0x0f;
+ pixel_value=(int) ReadDCMLSBShort(stream_info,
+ image);
+ byte=(int) (pixel_value & 0x0f);
pixel_value>>=4;
}
i++;
}
- index=pixel_value;
+ index=pixel_value;
if (window_width == 0)
{
if (signed_data == 1)
index=pixel_value-32767;
}
- else
+ else
{
- long
+ ssize_t
window_max,
window_min;
- window_min=(long) (window_center-(window_width-1)/2.0-0.5);
- window_max=(long) (window_center+(window_width-1)/2.0-0.5);
- if (pixel_value <= 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 (pixel_value > window_max)
- index=max_value;
+ if ((ssize_t) pixel_value > window_max)
+ index=(int) max_value;
else
- index=max_value*(((pixel_value-window_center-0.5)/
- (window_width-1))+0.5);
+ index=(int) (max_value*(((pixel_value-window_center-
+ 0.5)/(window_width-1))+0.5));
}
index&=mask;
- if (graymap != (unsigned short *) NULL)
- index=graymap[index];
- if ((scale != (Quantum *) NULL) && (index <= max_value))
- index=1UL*scale[index];
- index=1UL*ConstrainColormapIndex(image,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;
{
if (bytes_per_pixel == 1)
{
- pixel.red=(unsigned long) ReadBlobByte(image);
- pixel.green=(unsigned long) ReadBlobByte(image);
- pixel.blue=(unsigned long) ReadBlobByte(image);
+ 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 (msb_first != MagickFalse)
+ if (image->endian == MSBEndian)
{
- pixel.red=ReadBlobMSBShort(image);
- pixel.green=ReadBlobMSBShort(image);
- pixel.blue=ReadBlobMSBShort(image);
+ pixel.red=ReadDCMMSBShort(stream_info,image);
+ pixel.green=ReadDCMMSBShort(stream_info,image);
+ pixel.blue=ReadDCMMSBShort(stream_info,image);
}
else
{
- pixel.red=ReadBlobLSBShort(image);
- pixel.green=ReadBlobLSBShort(image);
- pixel.blue=ReadBlobLSBShort(image);
+ pixel.red=ReadDCMLSBShort(stream_info,image);
+ pixel.green=ReadDCMLSBShort(stream_info,image);
+ pixel.blue=ReadDCMLSBShort(stream_info,image);
}
}
pixel.red&=mask;
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;
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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)
+ {
+ ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
+ image->filename);
+ break;
}
/*
Proceed to next image.
if (image_info->number_scenes != 0)
if (image->scene >= (image_info->scene+image_info->number_scenes-1))
break;
- if (scene < (long) (number_scenes-1))
+ if (scene < (ssize_t) (number_scenes-1))
{
/*
Allocate next image structure.
*/
- AcquireNextImage(image_info,image);
+ AcquireNextImage(image_info,image,exception);
if (GetNextImageInList(image) == (Image *) NULL)
{
image=DestroyImageList(image);
}
}
/*
- Free scale resource.
+ Free resources.
*/
+ if (stream_info->offsets != (ssize_t *) NULL)
+ stream_info->offsets=(ssize_t *)
+ RelinquishMagickMemory(stream_info->offsets);
+ stream_info=(DCMStreamInfo *) RelinquishMagickMemory(stream_info);
if (scale != (Quantum *) NULL)
scale=(Quantum *) RelinquishMagickMemory(scale);
+ if (graymap != (int *) NULL)
+ graymap=(int *) RelinquishMagickMemory(graymap);
+ if (bluemap != (int *) NULL)
+ bluemap=(int *) RelinquishMagickMemory(bluemap);
+ if (greenmap != (int *) NULL)
+ greenmap=(int *) RelinquishMagickMemory(greenmap);
+ if (redmap != (int *) NULL)
+ redmap=(int *) RelinquishMagickMemory(redmap);
(void) CloseBlob(image);
return(GetFirstImageInList(image));
}
%
% The format of the RegisterDCMImage method is:
%
-% unsigned long RegisterDCMImage(void)
+% size_t RegisterDCMImage(void)
%
*/
-ModuleExport unsigned long RegisterDCMImage(void)
+ModuleExport size_t RegisterDCMImage(void)
{
MagickInfo
*entry;