Powered by Pair ImageMagick logo
Image Magick
Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages

ImageMagick-6.1.1/coders/cut.c File Reference

#include "magick/studio.h"
#include "magick/blob.h"
#include "magick/blob_private.h"
#include "magick/color.h"
#include "magick/color_private.h"
#include "magick/error.h"
#include "magick/error_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/static.h"
#include "magick/string_.h"

Include dependency graph for cut.c:

Include dependency graph

Go to the source code of this file.

Data Structures

struct  CUTHeader
struct  CUTPalHeader

Functions

void InsertRow (long depth, unsigned char *p, long y, Image *image)
int GetCutColors (Image *image)
Image * ReadCUTImage (const ImageInfo *image_info, ExceptionInfo *exception)
ModuleExport void RegisterCUTImage (void)
ModuleExport void UnregisterCUTImage (void)

Function Documentation

int GetCutColors (  Image *  image  )  [static]
 

Definition at line 241 of file cut.c.

References _Image::columns, GetImagePixels(), Quantum, _PixelPacket::red, _Image::rows, and ScaleCharToQuantum.

Referenced by ReadCUTImage(). 

00242 {
00243   long
00244     x,
00245     y;
00246 
00247   PixelPacket
00248     *q;
00249 
00250   Quantum
00251     intensity,
00252     scale_intensity;
00253 
00254   intensity=0;
00255   scale_intensity=ScaleCharToQuantum(16);
00256   for (y=0; y < (long) image->rows; y++)
00257   {
00258     q=GetImagePixels(image,0,y,image->columns,1);
00259     for (x=(long) image->columns-1; x >= 0; x--)
00260     {
00261       if (intensity < q->red)
00262         intensity=q->red;
00263       if (intensity >= scale_intensity)
00264         return(255);
00265       q++;
00266     }
00267   }
00268   if (intensity < ScaleCharToQuantum(2))
00269     return(2);
00270   if (intensity < ScaleCharToQuantum(16))
00271     return(16);
00272   return(intensity);
00273 }

Here is the call graph for this function:

void InsertRow (  long  depth,
unsigned char *  p,
long  y,
Image *  image
)  [static]
 

Definition at line 89 of file cut.c.

References _Image::colormap, _Image::columns, ConstrainColormapIndex(), GetIndexes(), IndexPacket, MagickFalse, SetImagePixels(), and SyncImagePixels(). 

00090 {
00091   unsigned long bit; long x;
00092   register PixelPacket *q;
00093   IndexPacket index;
00094   register IndexPacket *indexes;
00095 
00096 
00097   index=0;
00098   switch (depth)
00099     {
00100     case 1:  /* Convert bitmap scanline. */
00101       {
00102         q=SetImagePixels(image,0,y,image->columns,1);
00103         if (q == (PixelPacket *) NULL)
00104           break;
00105         indexes=GetIndexes(image);
00106         for (x=0; x < ((long) image->columns-7); x+=8)
00107           {
00108             for (bit=0; bit < 8; bit++)
00109               {
00110                 index=(IndexPacket) ((((*p) & (0x80 >> bit)) != 0) ? 0x01 : 0x00);
00111                 indexes[x+bit]=index;
00112                 *q++=image->colormap[index];
00113               }
00114             p++;
00115           }
00116         if ((image->columns % 8) != 0)
00117           {
00118             for (bit=0; bit < (image->columns % 8); bit++)
00119               {
00120                 index=(IndexPacket) ((((*p) & (0x80 >> bit)) != 0) ? 0x01 : 0x00);
00121                 indexes[x+bit]=index;
00122                 *q++=image->colormap[index];
00123               }
00124             p++;
00125           }
00126         if (SyncImagePixels(image) == MagickFalse)
00127           break;
00128         /*            if (image->previous == (Image *) NULL)
00129                       if (QuantumTick(y,image->rows) != MagickFalse)
00130                       ProgressMonitor(LoadImageText,image->rows-y-1,image->rows);*/
00131         break;
00132       }
00133     case 2:  /* Convert PseudoColor scanline. */
00134       {
00135         q=SetImagePixels(image,0,y,image->columns,1);
00136         if (q == (PixelPacket *) NULL)
00137           break;
00138         indexes=GetIndexes(image);
00139         for (x=0; x < ((long) image->columns-1); x+=2)
00140           {
00141             index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
00142             indexes[x]=index;
00143             *q++=image->colormap[index];
00144             index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
00145             indexes[x]=index;
00146             *q++=image->colormap[index];
00147             index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
00148             indexes[x]=index;
00149             *q++=image->colormap[index];
00150             index=ConstrainColormapIndex(image,(*p) & 0x3);
00151             indexes[x+1]=index;
00152             *q++=image->colormap[index];
00153             p++;
00154           }
00155         if ((image->columns % 4) != 0)
00156           {
00157             index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
00158             indexes[x]=index;
00159             *q++=image->colormap[index];
00160             if ((image->columns % 4) >= 1)
00161 
00162               {
00163                 index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
00164                 indexes[x]=index;
00165                 *q++=image->colormap[index];
00166                 if ((image->columns % 4) >= 2)
00167 
00168                   {
00169                     index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
00170                     indexes[x]=index;
00171                     *q++=image->colormap[index];
00172                   }
00173               }
00174             p++;
00175           }
00176         if (SyncImagePixels(image) == MagickFalse)
00177           break;
00178         /*         if (image->previous == (Image *) NULL)
00179                    if (QuantumTick(y,image->rows) != MagickFalse)
00180                    ProgressMonitor(LoadImageText,image->rows-y-1,image->rows);*/
00181         break;
00182       }
00183 
00184     case 4:  /* Convert PseudoColor scanline. */
00185       {
00186         q=SetImagePixels(image,0,y,image->columns,1);
00187         if (q == (PixelPacket *) NULL)
00188           break;
00189         indexes=GetIndexes(image);
00190         for (x=0; x < ((long) image->columns-1); x+=2)
00191           {
00192             index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
00193             indexes[x]=index;
00194             *q++=image->colormap[index];
00195             index=ConstrainColormapIndex(image,(*p) & 0xf);
00196             indexes[x+1]=index;
00197             *q++=image->colormap[index];
00198             p++;
00199           }
00200         if ((image->columns % 2) != 0)
00201           {
00202             index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
00203             indexes[x]=index;
00204             *q++=image->colormap[index];
00205             p++;
00206           }
00207         if (SyncImagePixels(image) == MagickFalse)
00208           break;
00209         /*         if (image->previous == (Image *) NULL)
00210                    if (QuantumTick(y,image->rows) != MagickFalse)
00211                    ProgressMonitor(LoadImageText,image->rows-y-1,image->rows);*/
00212         break;
00213       }
00214     case 8: /* Convert PseudoColor scanline. */
00215       {
00216         q=SetImagePixels(image,0,y,image->columns,1);
00217         if (q == (PixelPacket *) NULL) break;
00218         indexes=GetIndexes(image);
00219 
00220         for (x=0; x < (long) image->columns; x++)
00221           {
00222             index=ConstrainColormapIndex(image,*p);
00223             indexes[x]=index;
00224             *q++=image->colormap[index];
00225             p++;
00226           }
00227         if (SyncImagePixels(image) == MagickFalse)
00228           break;
00229         /*           if (image->previous == (Image *) NULL)
00230                      if (QuantumTick(y,image->rows) != MagickFalse)
00231                      ProgressMonitor(LoadImageText,image->rows-y-1,image->rows);*/
00232       }
00233       break;
00234 
00235     }
00236 }

Here is the call graph for this function:

Image* ReadCUTImage (  const ImageInfo *  image_info,
ExceptionInfo *  exception
)  [static]
 

Definition at line 302 of file cut.c.

References AcquireMagickMemory(), AllocateImage(), AllocateImageColormap(), assert, _PixelPacket::blue, CUTPalHeader::BoardID, CloneImageInfo(), CloseBlob(), _Image::colormap, _Image::colors, _Image::columns, CorruptImageError, _ImageInfo::debug, _Image::depth, DestroyImage(), DestroyImageInfo(), DestroyImageList(), EOFBlob(), _Image::exception, _ImageInfo::file, CUTPalHeader::FileId, _Image::filename, _ImageInfo::filename, CUTPalHeader::FileType, GetCutColors(), GetFirstImageInList(), GetMagickModule, CUTPalHeader::GraphicsMode, _PixelPacket::green, CUTHeader::Height, InsertRow(), IsGrayImage(), LogMagickEvent(), MagickBooleanType, MagickFalse, MagickSignature, CUTPalHeader::MaxBlue, CUTPalHeader::MaxGreen, CUTPalHeader::MaxIndex, CUTPalHeader::MaxRed, MaxRGB, OpenBlob(), CUTPalHeader::PaletteId, PseudoClass, Quantum, ReadBinaryBlobMode, ReadBlob(), ReadBlobByte(), ReadBlobLSBShort(), _PixelPacket::red, RelinquishMagickMemory(), CUTHeader::Reserved, ResetMagickMemory(), ResourceLimitError, _Image::rows, ScaleCharToQuantum, SeekBlob(), SetImagePixels(), _ExceptionInfo::signature, _ImageInfo::signature, CUTPalHeader::Size, _Image::storage_class, CUTPalHeader::SubType, SyncImagePixels(), TellBlob(), ThrowFileException, ThrowReaderException, TraceEvent, CUTPalHeader::Version, and CUTHeader::Width.

Referenced by RegisterCUTImage(). 

00303 {
00304   Image *image,*palette;
00305   ImageInfo *clone_info;
00306   MagickBooleanType status;
00307   unsigned long EncodedByte;
00308   unsigned char RunCount,RunValue,RunCountMasked;
00309   CUTHeader  Header;
00310   CUTPalHeader PalHeader;
00311   long depth;
00312   long i,j;
00313   long ldblk;
00314   unsigned char *BImgBuff=NULL,*ptrB;
00315   PixelPacket *q;
00316 
00317   /*
00318     Open image file.
00319   */
00320   assert(image_info != (const ImageInfo *) NULL);
00321   assert(image_info->signature == MagickSignature);
00322   if (image_info->debug != MagickFalse)
00323     (void) LogMagickEvent(TraceEvent,GetMagickModule(),image_info->filename);
00324   assert(exception != (ExceptionInfo *) NULL);
00325   assert(exception->signature == MagickSignature);
00326   image=AllocateImage(image_info);
00327   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
00328   if (status == MagickFalse)
00329     {
00330       DestroyImageList(image);
00331       return((Image *) NULL);
00332     }
00333   /*
00334     Read CUT image.
00335   */
00336   palette=NULL;
00337   clone_info=NULL;
00338   Header.Width=ReadBlobLSBShort(image);
00339   Header.Height=ReadBlobLSBShort(image);
00340   Header.Reserved=ReadBlobLSBShort(image);
00341 
00342   if (Header.Width==0 || Header.Height==0 || Header.Reserved!=0)
00343     CUT_KO:  ThrowReaderException(CorruptImageError,"ImproperImageHeader");
00344 
00345   /*---This code checks first line of image---*/
00346   EncodedByte=ReadBlobLSBShort(image);
00347   RunCount=(unsigned char) ReadBlobByte(image);
00348   RunCountMasked=RunCount & 0x7F;
00349   ldblk=0;
00350   while((int) RunCountMasked!=0)  /*end of line?*/
00351     {
00352       i=1;
00353       if((int) RunCount<0x80) i=(long) RunCountMasked;
00354       (void) SeekBlob(image,TellBlob(image)+i,SEEK_SET);
00355       if(EOFBlob(image) != MagickFalse) goto CUT_KO;  /*wrong data*/
00356       EncodedByte-=i+1;
00357       ldblk+=(long) RunCountMasked;
00358 
00359       RunCount=(unsigned char) ReadBlobByte(image);
00360       if(EOFBlob(image) != MagickFalse)  goto CUT_KO;  /*wrong data: unexpected eof in line*/
00361       RunCountMasked=RunCount & 0x7F;
00362     }
00363   if(EncodedByte!=1) goto CUT_KO;  /*wrong data: size incorrect*/
00364   i=0;        /*guess a number of bit planes*/
00365   if(ldblk==(int) Header.Width)   i=8;
00366   if(2*ldblk==(int) Header.Width) i=4;
00367   if(8*ldblk==(int) Header.Width) i=1;
00368   if(i==0) goto CUT_KO;    /*wrong data: incorrect bit planes*/
00369   depth=i;
00370 
00371   image->columns=Header.Width;
00372   image->rows=Header.Height;
00373   image->depth=8;
00374   image->colors=1UL << (unsigned long) i;
00375 
00376 
00377   /* ----- Do something with palette ----- */
00378   if ((clone_info=CloneImageInfo(image_info)) == NULL) goto NoPalette;
00379 
00380 
00381   i=(long) strlen(clone_info->filename);
00382   j=i;
00383   while(--i>0)
00384     {
00385       if(clone_info->filename[i]=='.')
00386         {
00387           break;
00388         }
00389       if(clone_info->filename[i]=='/' || clone_info->filename[i]=='\\' ||
00390          clone_info->filename[i]==':' )
00391         {
00392           i=j;
00393           break;
00394         }
00395     }
00396 
00397   (void) strcpy(clone_info->filename+i,".PAL");
00398   if((clone_info->file=fopen(clone_info->filename,"rb"))==NULL)
00399     {
00400       (void) strcpy(clone_info->filename+i,".pal");
00401       if((clone_info->file=fopen(clone_info->filename,"rb"))==NULL)
00402         {
00403           clone_info->filename[i]='\0';
00404           if((clone_info->file=fopen(clone_info->filename,"rb"))==NULL)
00405             {
00406               clone_info=DestroyImageInfo(clone_info);
00407               clone_info=NULL;
00408               goto NoPalette;
00409             }
00410         }
00411     }
00412 
00413   if( (palette=AllocateImage(clone_info))==NULL ) goto NoPalette;
00414   status=OpenBlob(clone_info,palette,ReadBinaryBlobMode,exception);
00415   if (status == MagickFalse)
00416     {
00417     ErasePalette:
00418       palette=DestroyImage(palette);
00419       palette=NULL;
00420       goto NoPalette;
00421     }
00422 
00423 
00424   if(palette!=NULL)
00425     {
00426       (void) ReadBlob(palette,2,(unsigned char *) PalHeader.FileId);
00427       if(strncmp(PalHeader.FileId,"AH",2) != 0) goto ErasePalette;
00428       PalHeader.Version=ReadBlobLSBShort(palette);
00429       PalHeader.Size=ReadBlobLSBShort(palette);
00430       PalHeader.FileType=(char) ReadBlobByte(palette);
00431       PalHeader.SubType=(char) ReadBlobByte(palette);
00432       PalHeader.BoardID=ReadBlobLSBShort(palette);
00433       PalHeader.GraphicsMode=ReadBlobLSBShort(palette);
00434       PalHeader.MaxIndex=ReadBlobLSBShort(palette);
00435       PalHeader.MaxRed=ReadBlobLSBShort(palette);
00436       PalHeader.MaxGreen=ReadBlobLSBShort(palette);
00437       PalHeader.MaxBlue=ReadBlobLSBShort(palette);
00438       (void) ReadBlob(palette,20,(unsigned char *) PalHeader.PaletteId);
00439 
00440       if(PalHeader.MaxIndex<1) goto ErasePalette;
00441       image->colors=PalHeader.MaxIndex+1;
00442       if (AllocateImageColormap(image,image->colors) == MagickFalse) goto NoMemory;
00443 
00444       if(PalHeader.MaxRed==0) PalHeader.MaxRed=MaxRGB;  /*avoid division by 0*/
00445       if(PalHeader.MaxGreen==0) PalHeader.MaxGreen=MaxRGB;
00446       if(PalHeader.MaxBlue==0) PalHeader.MaxBlue=MaxRGB;
00447 
00448       for(i=0;i<=(int) PalHeader.MaxIndex;i++)
00449         {      /*this may be wrong- I don't know why is palette such strange*/
00450           j=(long) TellBlob(palette);
00451           if((j % 512)>512-6)
00452             {
00453               j=((j / 512)+1)*512;
00454               (void) SeekBlob(palette,j,SEEK_SET);
00455             }
00456           image->colormap[i].red=ReadBlobLSBShort(palette);
00457           if(MaxRGB!=(Quantum) PalHeader.MaxRed)
00458             {
00459               image->colormap[i].red=(Quantum)
00460                 (((double)image->colormap[i].red*MaxRGB+(PalHeader.MaxRed>>1))/PalHeader.MaxRed+0.5);
00461             }
00462           image->colormap[i].green=ReadBlobLSBShort(palette);
00463           if(MaxRGB!=(Quantum) PalHeader.MaxGreen)
00464             {
00465               image->colormap[i].green=(Quantum)
00466                 (((double)image->colormap[i].green*MaxRGB+(PalHeader.MaxGreen>>1))/PalHeader.MaxGreen+0.5);
00467             }
00468           image->colormap[i].blue=ReadBlobLSBShort(palette);
00469           if(MaxRGB!=(Quantum) PalHeader.MaxBlue)
00470             {
00471               image->colormap[i].blue=(Quantum)
00472                 (((double)image->colormap[i].blue*MaxRGB+(PalHeader.MaxBlue>>1))/PalHeader.MaxBlue+0.5);
00473             }
00474 
00475         }
00476     }
00477 
00478 
00479 
00480  NoPalette:
00481   if(palette==NULL)
00482     {
00483 
00484       image->colors=256;
00485       if (AllocateImageColormap(image,image->colors) == MagickFalse)
00486         {
00487         NoMemory:
00488           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
00489             }
00490 
00491       for (i=0; i < (long)image->colors; i++)
00492         {
00493           image->colormap[i].red=ScaleCharToQuantum(i);
00494           image->colormap[i].green=ScaleCharToQuantum(i);
00495           image->colormap[i].blue=ScaleCharToQuantum(i);
00496         }
00497     }
00498 
00499 
00500   /* ----- Load RLE compressed raster ----- */
00501   BImgBuff=(unsigned char *) AcquireMagickMemory((size_t) ldblk);  /*Ldblk was set in the check phase*/
00502   if(BImgBuff==NULL) goto NoMemory;
00503 
00504   (void) SeekBlob(image,6 /*sizeof(Header)*/,SEEK_SET);
00505   for(i=0;i<(int) Header.Height;i++)
00506     {
00507       EncodedByte=ReadBlobLSBShort(image);
00508 
00509       ptrB=BImgBuff;
00510       j=ldblk;
00511 
00512       RunCount=(unsigned char) ReadBlobByte(image);
00513       RunCountMasked=RunCount & 0x7F;
00514 
00515       while((int) RunCountMasked!=0)
00516         {
00517           if((long) RunCountMasked>j)
00518             {    /*Wrong Data*/
00519               RunCountMasked=(unsigned char) j;
00520               if(j==0)
00521                 {
00522                   break;
00523                 }
00524             }
00525 
00526           if((int) RunCount>0x80)
00527             {
00528               RunValue=(unsigned char) ReadBlobByte(image);
00529               (void) ResetMagickMemory(ptrB,(int) RunValue,(size_t) RunCountMasked);
00530             }
00531           else {
00532             (void) ReadBlob(image,(size_t) RunCountMasked,ptrB);
00533           }
00534 
00535           ptrB+=(int) RunCountMasked;
00536           j-=(int) RunCountMasked;
00537 
00538           if (EOFBlob(image) != MagickFalse) goto Finish;  /* wrong data: unexpected eof in line */
00539           RunCount=(unsigned char) ReadBlobByte(image);
00540           RunCountMasked=RunCount & 0x7F;
00541         }
00542 
00543       InsertRow(depth,BImgBuff,i,image);
00544     }
00545 
00546 
00547   /*detect monochrome image*/
00548 
00549   if(palette==NULL)
00550     {    /*attempt to detect binary (black&white) images*/
00551       if ((image->storage_class == PseudoClass) &&
00552           (IsGrayImage(image,&image->exception) != MagickFalse))
00553         {
00554           if(GetCutColors(image)==2)
00555             {
00556               for (i=0; i < (long)image->colors; i++)
00557                 {
00558                   register Quantum
00559                     sample;
00560                   sample=ScaleCharToQuantum(i);
00561                   if(image->colormap[i].red!=sample) goto Finish;
00562                   if(image->colormap[i].green!=sample) goto Finish;
00563                   if(image->colormap[i].blue!=sample) goto Finish;
00564                 }
00565 
00566               image->colormap[1].red=image->colormap[1].green=image->colormap[1].blue=MaxRGB;
00567               for (i=0; i < (long)image->rows; i++)
00568                 {
00569                   q=SetImagePixels(image,0,i,image->columns,1);
00570                   for (j=0; j < (long)image->columns; j++)
00571                     {
00572                       if(q->red==ScaleCharToQuantum(1))
00573                         {
00574                           q->red=q->green=q->blue=MaxRGB;
00575                         }
00576                       q++;
00577                     }
00578                   if (SyncImagePixels(image) == MagickFalse) goto Finish;
00579                 }
00580             }
00581         }
00582     }
00583 
00584  Finish:
00585   if (BImgBuff != NULL)
00586     BImgBuff=(unsigned char *) RelinquishMagickMemory(BImgBuff);
00587   if (palette != NULL)
00588     palette=DestroyImage(palette);
00589   if (clone_info != NULL)
00590     clone_info=DestroyImageInfo(clone_info);
00591   if (EOFBlob(image) != MagickFalse)
00592     ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
00593       image->filename);
00594   CloseBlob(image);
00595   return(GetFirstImageInList(image));
00596 }

Here is the call graph for this function:

ModuleExport void RegisterCUTImage (  void   ) 
 

Definition at line 621 of file cut.c.

References AcquireString(), _MagickInfo::decoder, DecoderHandler, _MagickInfo::description, MagickTrue, _MagickInfo::module, ModuleExport, ReadCUTImage(), RegisterMagickInfo(), _MagickInfo::seekable_stream, and SetMagickInfo().

Referenced by RegisterStaticModules(). 

00622 {
00623   MagickInfo
00624     *entry;
00625 
00626   entry=SetMagickInfo("CUT");
00627   entry->decoder=(DecoderHandler *) ReadCUTImage;
00628   entry->seekable_stream=MagickTrue;
00629   entry->description=AcquireString("DR Halo");
00630   entry->module=AcquireString("CUT");
00631   (void) RegisterMagickInfo(entry);
00632 }

Here is the call graph for this function:

ModuleExport void UnregisterCUTImage (  void   ) 
 

Definition at line 653 of file cut.c.

References ModuleExport, and UnregisterMagickInfo().

Referenced by UnregisterStaticModules(). 

00654 {
00655   (void) UnregisterMagickInfo("CUT");
00656 }

Here is the call graph for this function:

Generated on Mon Oct 25 13:42:30 2004 for ImageMagick by doxygen 1.3.7
ImageMagick Copyright © 2004, ImageMagick Studio LLC