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/mono.c File Reference

#include "magick/studio.h"
#include "magick/blob.h"
#include "magick/blob_private.h"
#include "magick/colorspace.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/monitor.h"
#include "magick/static.h"
#include "magick/string_.h"

Include dependency graph for mono.c:

Include dependency graph

Go to the source code of this file.

Functions

MagickBooleanType WriteMONOImage (const ImageInfo *, Image *)
Image * ReadMONOImage (const ImageInfo *image_info, ExceptionInfo *exception)
ModuleExport void RegisterMONOImage (void)
ModuleExport void UnregisterMONOImage (void)

Function Documentation

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

Definition at line 91 of file mono.c.

References AllocateImage(), AllocateImageColormap(), assert, _Image::client_data, CloseBlob(), _Image::columns, CorruptImageError, _ImageInfo::debug, DestroyImageList(), EOFBlob(), _Image::filename, _ImageInfo::filename, GetFirstImageInList(), GetIndexes(), GetMagickModule, IndexPacket, LoadImageTag, LogMagickEvent(), MagickBooleanType, MagickFalse, MagickProgressMonitor, MagickSignature, _Image::offset, OpenBlob(), OptionError, _ImageInfo::ping, _Image::progress_monitor, QuantumTick, ReadBinaryBlobMode, ReadBlobByte(), ResourceLimitError, _Image::rows, SetImagePixels(), _ExceptionInfo::signature, _ImageInfo::signature, SyncImage(), SyncImagePixels(), ThrowFileException, ThrowReaderException, and TraceEvent.

Referenced by RegisterMONOImage(). 

00093 {
00094   Image
00095     *image;
00096 
00097   long
00098     y;
00099 
00100   MagickBooleanType
00101     status;
00102 
00103   register IndexPacket
00104     *indexes;
00105 
00106   register long
00107     x;
00108 
00109   register PixelPacket
00110     *q;
00111 
00112   register long
00113     i;
00114 
00115   unsigned long
00116     bit,
00117     byte;
00118 
00119   /*
00120     Open image file.
00121   */
00122   assert(image_info != (const ImageInfo *) NULL);
00123   assert(image_info->signature == MagickSignature);
00124   if (image_info->debug != MagickFalse)
00125     (void) LogMagickEvent(TraceEvent,GetMagickModule(),image_info->filename);
00126   assert(exception != (ExceptionInfo *) NULL);
00127   assert(exception->signature == MagickSignature);
00128   image=AllocateImage(image_info);
00129   if ((image->columns == 0) || (image->rows == 0))
00130     ThrowReaderException(OptionError,"MustSpecifyImageSize");
00131   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
00132   if (status == MagickFalse)
00133     {
00134       DestroyImageList(image);
00135       return((Image *) NULL);
00136     }
00137   for (i=0; i < image->offset; i++)
00138     (void) ReadBlobByte(image);
00139   /*
00140     Initialize image colormap.
00141   */
00142   if (AllocateImageColormap(image,2) == MagickFalse)
00143     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
00144   if (image_info->ping != MagickFalse)
00145     {
00146       CloseBlob(image);
00147       return(GetFirstImageInList(image));
00148     }
00149   /*
00150     Convert bi-level image to pixel packets.
00151   */
00152   for (y=0; y < (long) image->rows; y++)
00153   {
00154     q=SetImagePixels(image,0,y,image->columns,1);
00155     if (q == (PixelPacket *) NULL)
00156       break;
00157     indexes=GetIndexes(image);
00158     bit=0;
00159     byte=0;
00160     for (x=0; x < (long) image->columns; x++)
00161     {
00162       if (bit == 0)
00163         byte=(unsigned long) ReadBlobByte(image);
00164       indexes[x]=(IndexPacket) (((byte & 0x01) != 0) ? 0x01 : 0x00);
00165       bit++;
00166       if (bit == 8)
00167         bit=0;
00168       byte>>=1;
00169     }
00170     if (SyncImagePixels(image) == MagickFalse)
00171       break;
00172     if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
00173         (QuantumTick(y,image->rows) != MagickFalse))
00174       {
00175         status=image->progress_monitor(LoadImageTag,y,image->rows,
00176           image->client_data);
00177         if (status == MagickFalse)
00178           break;
00179       }
00180   }
00181   SyncImage(image);
00182   if (EOFBlob(image) != MagickFalse)
00183     ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
00184       image->filename);
00185   CloseBlob(image);
00186   return(GetFirstImageInList(image));
00187 }

Here is the call graph for this function:

ModuleExport void RegisterMONOImage (  void   ) 
 

Definition at line 212 of file mono.c.

References AcquireString(), _MagickInfo::adjoin, _MagickInfo::decoder, DecoderHandler, _MagickInfo::description, _MagickInfo::encoder, EncoderHandler, _MagickInfo::endian_support, MagickFalse, MagickTrue, _MagickInfo::module, ModuleExport, _MagickInfo::raw, ReadMONOImage(), RegisterMagickInfo(), SetMagickInfo(), and WriteMONOImage().

Referenced by RegisterStaticModules(). 

00213 {
00214   MagickInfo
00215     *entry;
00216 
00217   entry=SetMagickInfo("MONO");
00218   entry->decoder=(DecoderHandler *) ReadMONOImage;
00219   entry->encoder=(EncoderHandler *) WriteMONOImage;
00220   entry->raw=MagickTrue;
00221   entry->endian_support=MagickTrue;
00222   entry->adjoin=MagickFalse;
00223   entry->description=
00224     AcquireString("Bi-level bitmap in least-significant-byte first order");
00225   entry->module=AcquireString("MONO");
00226   (void) RegisterMagickInfo(entry);
00227 }

Here is the call graph for this function:

ModuleExport void UnregisterMONOImage (  void   ) 
 

Definition at line 248 of file mono.c.

References ModuleExport, and UnregisterMagickInfo().

Referenced by UnregisterStaticModules(). 

00249 {
00250   (void) UnregisterMagickInfo("MONO");
00251 }

Here is the call graph for this function:

MagickBooleanType WriteMONOImage (  const ImageInfo *  ,
Image * 
)  [static]
 

Definition at line 278 of file mono.c.

References AcquireImagePixels(), assert, BilevelType, _Image::client_data, CloseBlob(), _Image::colormap, _Image::colors, _Image::columns, _Image::debug, _Image::exception, _Image::filename, GetIndexes(), GetMagickModule, IndexPacket, LogMagickEvent(), MagickBooleanType, MagickFalse, MagickProgressMonitor, MagickSignature, MagickTrue, MaxRGB, OpenBlob(), PixelIntensityToQuantum, _Image::progress_monitor, QuantumTick, RGBColorspace, _Image::rows, SaveImageTag, SetImageColorspace(), SetImageType(), _Image::signature, _ImageInfo::signature, TraceEvent, WriteBinaryBlobMode, and WriteBlobByte().

Referenced by RegisterMONOImage(). 

00280 {
00281   IndexPacket
00282     polarity;
00283 
00284   long
00285     y;
00286 
00287   MagickBooleanType
00288     status;
00289 
00290   register IndexPacket
00291     *indexes;
00292 
00293   register const PixelPacket
00294     *p;
00295 
00296   register long
00297     x;
00298 
00299   unsigned long
00300     bit,
00301     byte;
00302 
00303   /*
00304     Open output image file.
00305   */
00306   assert(image_info != (const ImageInfo *) NULL);
00307   assert(image_info->signature == MagickSignature);
00308   assert(image != (Image *) NULL);
00309   assert(image->signature == MagickSignature);
00310   if (image->debug != MagickFalse)
00311     (void) LogMagickEvent(TraceEvent,GetMagickModule(),image->filename);
00312   status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
00313   if (status == MagickFalse)
00314     return(status);
00315   (void) SetImageColorspace(image,RGBColorspace);
00316   /*
00317     Convert image to a bi-level image.
00318   */
00319   (void) SetImageType(image,BilevelType);
00320   polarity=(IndexPacket)
00321     (PixelIntensityToQuantum(&image->colormap[0]) < (MaxRGB/2));
00322   if (image->colors == 2)
00323     polarity=(IndexPacket) (PixelIntensityToQuantum(&image->colormap[0]) <
00324       PixelIntensityToQuantum(&image->colormap[1]));
00325   for (y=0; y < (long) image->rows; y++)
00326   {
00327     p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
00328     if (p == (const PixelPacket *) NULL)
00329       break;
00330     indexes=GetIndexes(image);
00331     bit=0;
00332     byte=0;
00333     for (x=0; x < (long) image->columns; x++)
00334     {
00335       byte>>=1;
00336       if (indexes[x] == polarity)
00337         byte|=0x80;
00338       bit++;
00339       if (bit == 8)
00340         {
00341           (void) WriteBlobByte(image,(unsigned char) byte);
00342           bit=0;
00343           byte=0;
00344         }
00345     }
00346     if (bit != 0)
00347       (void) WriteBlobByte(image,(unsigned char) (byte >> (8-bit)));
00348     if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
00349         (QuantumTick(y,image->rows) != MagickFalse))
00350       {
00351         status=image->progress_monitor(SaveImageTag,y,image->rows,
00352           image->client_data);
00353         if (status == MagickFalse)
00354           break;
00355       }
00356   }
00357   CloseBlob(image);
00358   return(MagickTrue);
00359 }

Here is the call graph for this function:

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