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/avs.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 avs.c:

Include dependency graph

Go to the source code of this file.

Functions

MagickBooleanType WriteAVSImage (const ImageInfo *, Image *)
Image * ReadAVSImage (const ImageInfo *image_info, ExceptionInfo *exception)
ModuleExport void RegisterAVSImage (void)
ModuleExport void UnregisterAVSImage (void)

Function Documentation

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

Definition at line 90 of file avs.c.

References AcquireMagickMemory(), AllocateImage(), AllocateNextImage(), assert, _PixelPacket::blue, _Image::client_data, CloseBlob(), _Image::columns, CorruptImageError, _ImageInfo::debug, _Image::depth, DestroyImageList(), EOFBlob(), _Image::filename, _ImageInfo::filename, GetBlobSize(), GetFirstImageInList(), GetMagickModule, _PixelPacket::green, LoadImagesTag, LoadImageTag, LogMagickEvent(), MagickBooleanType, MagickFalse, MagickProgressMonitor, MagickSignature, MagickTrue, _Image::matte, MaxRGB, _Image::next, _ImageInfo::number_scenes, _PixelPacket::opacity, OpaqueOpacity, OpenBlob(), _ImageInfo::ping, _Image::previous, _Image::progress_monitor, Quantum, QuantumTick, ReadBinaryBlobMode, ReadBlob(), ReadBlobMSBLong(), _PixelPacket::red, RelinquishMagickMemory(), ResourceLimitError, _Image::rows, ScaleCharToQuantum, _ImageInfo::scene, _Image::scene, SetImagePixels(), _ExceptionInfo::signature, _ImageInfo::signature, ssize_t, SyncImagePixels(), SyncNextImageInList(), TellBlob(), ThrowFileException, ThrowReaderException, and TraceEvent.

Referenced by RegisterAVSImage(). 

00091 {
00092   Image
00093     *image;
00094 
00095   long
00096     y;
00097 
00098   MagickBooleanType
00099     status;
00100 
00101   register long
00102     x;
00103 
00104   register PixelPacket
00105     *q;
00106 
00107   register unsigned char
00108     *p;
00109 
00110   ssize_t
00111     count;
00112 
00113   unsigned char
00114     *pixels;
00115 
00116   unsigned long
00117     height,
00118     width;
00119 
00120   /*
00121     Open image file.
00122   */
00123   assert(image_info != (const ImageInfo *) NULL);
00124   assert(image_info->signature == MagickSignature);
00125   if (image_info->debug != MagickFalse)
00126     (void) LogMagickEvent(TraceEvent,GetMagickModule(),image_info->filename);
00127   assert(exception != (ExceptionInfo *) NULL);
00128   assert(exception->signature == MagickSignature);
00129   image=AllocateImage(image_info);
00130   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
00131   if (status == MagickFalse)
00132     {
00133       DestroyImageList(image);
00134       return((Image *) NULL);
00135     }
00136   /*
00137     Read AVS X image.
00138   */
00139   width=ReadBlobMSBLong(image);
00140   height=ReadBlobMSBLong(image);
00141   if ((width == (unsigned long) ~0) || (height == (unsigned long) ~0))
00142     ThrowReaderException(CorruptImageError,"ImproperImageHeader");
00143   do
00144   {
00145     /*
00146       Convert AVS raster image to pixel packets.
00147     */
00148     image->columns=width;
00149     image->rows=height;
00150     image->depth=8;
00151     if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))
00152       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
00153         break;
00154     pixels=(unsigned char *) AcquireMagickMemory((size_t) (4*image->columns));
00155     if (pixels == (unsigned char *) NULL)
00156       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
00157     for (y=0; y < (long) image->rows; y++)
00158     {
00159       count=ReadBlob(image,(size_t) (4*image->columns),pixels);
00160       if (count == 0)
00161         ThrowReaderException(CorruptImageError,"UnableToReadImageData");
00162       p=pixels;
00163       q=SetImagePixels(image,0,y,image->columns,1);
00164       if (q == (PixelPacket *) NULL)
00165         break;
00166       for (x=0; x < (long) image->columns; x++)
00167       {
00168         q->opacity=(Quantum) (MaxRGB-ScaleCharToQuantum((unsigned long) *p++));
00169         q->red=ScaleCharToQuantum((unsigned long) *p++);
00170         q->green=ScaleCharToQuantum((unsigned long) *p++);
00171         q->blue=ScaleCharToQuantum((unsigned long) *p++);
00172         if (q->opacity != OpaqueOpacity)
00173           image->matte=MagickTrue;
00174         q++;
00175       }
00176       if (SyncImagePixels(image) == MagickFalse)
00177         break;
00178       if (image->previous == (Image *) NULL)
00179         if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
00180             (QuantumTick(y,image->rows) != MagickFalse))
00181           {
00182             status=image->progress_monitor(LoadImageTag,y,image->rows,
00183               image->client_data);
00184             if (status == MagickFalse)
00185               break;
00186           }
00187     }
00188     pixels=(unsigned char *) RelinquishMagickMemory(pixels);
00189     if (EOFBlob(image) != MagickFalse)
00190       {
00191         ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
00192           image->filename);
00193         break;
00194       }
00195     /*
00196       Proceed to next image.
00197     */
00198     if (image_info->number_scenes != 0)
00199       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
00200         break;
00201     width=ReadBlobMSBLong(image);
00202     height=ReadBlobMSBLong(image);
00203     if ((width != (unsigned long) ~0) && (height != (unsigned long) ~0))
00204       {
00205         /*
00206           Allocate next image structure.
00207         */
00208         AllocateNextImage(image_info,image);
00209         if (image->next == (Image *) NULL)
00210           {
00211             DestroyImageList(image);
00212             return((Image *) NULL);
00213           }
00214         image=SyncNextImageInList(image);
00215         if (image->progress_monitor != (MagickProgressMonitor) NULL)
00216           {
00217             status=image->progress_monitor(LoadImagesTag,TellBlob(image),
00218               GetBlobSize(image),image->client_data);
00219             if (status == MagickFalse)
00220               break;
00221           }
00222       }
00223   } while ((width != (unsigned long) ~0) && (height != (unsigned long) ~0));
00224   CloseBlob(image);
00225   return(GetFirstImageInList(image));
00226 }

Here is the call graph for this function:

ModuleExport void RegisterAVSImage (  void   ) 
 

Definition at line 250 of file avs.c.

References AcquireString(), _MagickInfo::decoder, DecoderHandler, _MagickInfo::description, _MagickInfo::encoder, EncoderHandler, _MagickInfo::module, ModuleExport, ReadAVSImage(), RegisterMagickInfo(), SetMagickInfo(), and WriteAVSImage().

Referenced by RegisterStaticModules(). 

00251 {
00252   MagickInfo
00253     *entry;
00254 
00255   entry=SetMagickInfo("AVS");
00256   entry->decoder=(DecoderHandler *) ReadAVSImage;
00257   entry->encoder=(EncoderHandler *) WriteAVSImage;
00258   entry->description=AcquireString("AVS X image");
00259   entry->module=AcquireString("AVS");
00260   (void) RegisterMagickInfo(entry);
00261 }

Here is the call graph for this function:

ModuleExport void UnregisterAVSImage (  void   ) 
 

Definition at line 282 of file avs.c.

References ModuleExport, and UnregisterMagickInfo().

Referenced by UnregisterStaticModules(). 

00283 {
00284   (void) UnregisterMagickInfo("AVS");
00285 }

Here is the call graph for this function:

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

Definition at line 312 of file avs.c.

References AcquireImagePixels(), AcquireMagickMemory(), _ImageInfo::adjoin, assert, _PixelPacket::blue, _Image::client_data, CloseBlob(), _Image::columns, _Image::debug, _Image::exception, _Image::filename, GetImageListLength(), GetMagickModule, _PixelPacket::green, Image, LogMagickEvent(), MagickBooleanType, MagickFalse, MagickOffsetType, MagickProgressMonitor, MagickSignature, MagickTrue, _Image::matte, MaxRGB, _Image::next, _PixelPacket::opacity, OpaqueOpacity, OpenBlob(), PixelPacket, _Image::previous, _Image::progress_monitor, QuantumTick, _PixelPacket::red, RelinquishMagickMemory(), ResourceLimitError, RGBColorspace, _Image::rows, SaveImagesTag, SaveImageTag, ScaleQuantumToChar, SetImageColorspace(), _Image::signature, _ImageInfo::signature, SyncNextImageInList(), ThrowWriterException, TraceEvent, WriteBinaryBlobMode, WriteBlob(), and WriteBlobMSBLong().

Referenced by RegisterAVSImage(). 

00313 {
00314   MagickBooleanType
00315     status;
00316 
00317   MagickOffsetType
00318     scene;
00319 
00320   register const PixelPacket
00321     *p;
00322 
00323   register long
00324     x,
00325     y;
00326 
00327   register unsigned char
00328     *q;
00329 
00330   unsigned char
00331     *pixels;
00332 
00333   /*
00334     Open output image file.
00335   */
00336   assert(image_info != (const ImageInfo *) NULL);
00337   assert(image_info->signature == MagickSignature);
00338   assert(image != (Image *) NULL);
00339   assert(image->signature == MagickSignature);
00340   if (image->debug != MagickFalse)
00341     (void) LogMagickEvent(TraceEvent,GetMagickModule(),image->filename);
00342   status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
00343   if (status == MagickFalse)
00344     return(status);
00345   scene=0;
00346   do
00347   {
00348     /*
00349       Write AVS header.
00350     */
00351     (void) SetImageColorspace(image,RGBColorspace);
00352     (void) WriteBlobMSBLong(image,image->columns);
00353     (void) WriteBlobMSBLong(image,image->rows);
00354     /*
00355       Allocate memory for pixels.
00356     */
00357     pixels=(unsigned char *)
00358       AcquireMagickMemory((size_t) image->columns*sizeof(PixelPacket));
00359     if (pixels == (unsigned char *) NULL)
00360       ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
00361     /*
00362       Convert MIFF to AVS raster pixels.
00363     */
00364     for (y=0; y < (long) image->rows; y++)
00365     {
00366       p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
00367       if (p == (PixelPacket *) NULL)
00368         break;
00369       q=pixels;
00370       for (x=0; x < (long) image->columns; x++)
00371       {
00372         *q++=ScaleQuantumToChar(MaxRGB-(image->matte != MagickFalse ?
00373           p->opacity : OpaqueOpacity));
00374         *q++=ScaleQuantumToChar(p->red);
00375         *q++=ScaleQuantumToChar(p->green);
00376         *q++=ScaleQuantumToChar(p->blue);
00377         p++;
00378       }
00379       (void) WriteBlob(image,(size_t) (q-pixels),pixels);
00380       if (image->previous == (Image *) NULL)
00381         if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
00382             (QuantumTick(y,image->rows) != MagickFalse))
00383           {
00384             status=image->progress_monitor(SaveImageTag,y,image->rows,
00385               image->client_data);
00386             if (status == MagickFalse)
00387               break;
00388           }
00389     }
00390     pixels=(unsigned char *) RelinquishMagickMemory(pixels);
00391     if (image->next == (Image *) NULL)
00392       break;
00393     image=SyncNextImageInList(image);
00394     if (image->progress_monitor != (MagickProgressMonitor) NULL)
00395       {
00396         status=image->progress_monitor(SaveImagesTag,scene,
00397           GetImageListLength(image),image->client_data);
00398         if (status == MagickFalse)
00399           break;
00400       }
00401     scene++;
00402   } while (image_info->adjoin != MagickFalse);
00403   CloseBlob(image);
00404   return(MagickTrue);
00405 }

Here is the call graph for this function:

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