自学教程：C++ AcquireQuantumMemory函数代码示例

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   D e l e t e I m a g e s                                                   %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  DeleteImages() deletes one or more images from an image sequence, using a%  comma separated list of image numbers or ranges.%%  The numbers start at 0 for the first image, while negative numbers refer to%  images starting counting from the end of the range. Images may be refered to%  multiple times without problems. Image refered beyond the available number%  of images in list are ignored.%%  If the referenced images are in the reverse order, that range will be%  completely ignored.  Unlike CloneImages().%%  The format of the DeleteImages method is:%%      DeleteImages(Image **images,const char *scenes,ExceptionInfo *exception)%%  A description of each parameter follows:%%    o images: the image sequence.%%    o scenes: This character string specifies which scenes to delete%      (e.g. 1,3-5,-2-6,2).%%    o exception: return any errors or warnings in this structure.%*/MagickExport void DeleteImages(Image **images,const char *scenes,  ExceptionInfo *exception){  char    *p;  Image    *image;  long    first,    last;  MagickBooleanType    *delete_list;  register long    i;  size_t    length;  assert(images != (Image **) NULL);  assert((*images)->signature == MagickSignature);  assert(scenes != (char *) NULL);  if ((*images)->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",      (*images)->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  *images=GetFirstImageInList(*images);  length=GetImageListLength(*images);  delete_list=(MagickBooleanType *) AcquireQuantumMemory(length,    sizeof(*delete_list));  if (delete_list == (MagickBooleanType *) NULL)    {      (void) ThrowMagickException(exception,GetMagickModule(),        ResourceLimitError,"MemoryAllocationFailed","`%s'",(*images)->filename);      return;    }  image=(*images);  for (i=0; i < (long) length; i++)    delete_list[i]=MagickFalse;  /*    Note which images will be deleted, avoid duplicate deleted  */  for (p=(char *) scenes; *p != '/0';)  {    while ((isspace((int)*p) != 0) || (*p == ','))      p++;    first=strtol(p,&p,10);    if (first < 0)      first+=(long) length;    last=first;    while (isspace((int) ((unsigned char) *p)) != 0)      p++;    if (*p == '-')      {        last=strtol(p+1,&p,10);        if (last < 0)          last+=(long) length;      }    if (first > last)      continue;//.........这里部分代码省略.........

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   R e a d W E B P I m a g e                                                 %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ReadWEBPImage() reads an image in the WebP image format.%%  The format of the ReadWEBPImage method is:%%      Image *ReadWEBPImage(const ImageInfo *image_info,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image_info: the image info.%%    o exception: return any errors or warnings in this structure.%*/static Image *ReadWEBPImage(const ImageInfo *image_info,                            ExceptionInfo *exception){    int    height,    width;    Image    *image;    MagickBooleanType    status;    register PixelPacket    *q;    register ssize_t    x;    register unsigned char    *p;    size_t    length;    ssize_t    count,    y;    unsigned char    *stream,    *pixels;    /*      Open image file.    */    assert(image_info != (const ImageInfo *) NULL);    assert(image_info->signature == MagickSignature);    if (image_info->debug != MagickFalse)        (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",                              image_info->filename);    assert(exception != (ExceptionInfo *) NULL);    assert(exception->signature == MagickSignature);    image=AcquireImage(image_info);    status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);    if (status == MagickFalse)    {        image=DestroyImageList(image);        return((Image *) NULL);    }    length=(size_t) GetBlobSize(image);    stream=(unsigned char *) AcquireQuantumMemory(length,sizeof(*stream));    if (stream == (unsigned char *) NULL)        ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");    count=ReadBlob(image,length,stream);    if (count != (ssize_t) length)        ThrowReaderException(CorruptImageError,"InsufficientImageDataInFile");    pixels=(unsigned char *) WebPDecodeRGBA(stream,length,&width,&height);    if (pixels == (unsigned char *) NULL)        ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");    image->columns=(size_t) width;    image->rows=(size_t) height;    p=pixels;    for (y=0; y < (ssize_t) image->rows; y++)    {        q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);        if (q == (PixelPacket *) NULL)            break;        for (x=0; x < (ssize_t) image->columns; x++)        {            SetRedPixelComponent(q,ScaleCharToQuantum(*p++));            SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));            SetBluePixelComponent(q,ScaleCharToQuantum(*p++));            SetOpacityPixelComponent(q,(QuantumRange-ScaleCharToQuantum(*p++)));            if (q->opacity != OpaqueOpacity)//.........这里部分代码省略.........

//.........这里部分代码省略.........  page.x=0;  page.y=0;  if (image_info->page != (char *) NULL)    (void) ParseAbsoluteGeometry(image_info->page,&page);  if (image->columns == 0)    {      pango_layout_get_pixel_extents(layout,NULL,&extent);      image->columns=extent.x+extent.width;    }  else    {      image->columns-=2*page.x;      pango_layout_set_width(layout,(PANGO_SCALE*image->columns*        image->x_resolution+36.0)/72.0);    }  if (image->rows == 0)    {      pango_layout_get_pixel_extents(layout,NULL,&extent);      image->rows=extent.y+extent.height;    }  else    {      image->rows-=2*page.y;      pango_layout_set_height(layout,(PANGO_SCALE*image->rows*        image->y_resolution+36.0)/72.0);    }  /*    Create canvas.  */  canvas=(FT_Bitmap *) AcquireMagickMemory(sizeof(*canvas));  if (canvas == (FT_Bitmap *) NULL)    {      draw_info=DestroyDrawInfo(draw_info);      ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");    }  canvas->width=image->columns;  canvas->pitch=(canvas->width+3) & ~3;  canvas->rows=image->rows;  canvas->buffer=(unsigned char *) AcquireQuantumMemory(canvas->pitch,    canvas->rows*sizeof(*canvas->buffer));  if (canvas->buffer == (unsigned char *) NULL)    {      draw_info=DestroyDrawInfo(draw_info);      canvas=(FT_Bitmap *) RelinquishMagickMemory(canvas);      ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");    }  canvas->num_grays=256;  canvas->pixel_mode=ft_pixel_mode_grays;  ResetMagickMemory(canvas->buffer,0x00,canvas->pitch*canvas->rows);  pango_ft2_render_layout(canvas,layout,0,0);  /*    Convert caption to image.  */  image->columns+=2*page.x;  image->rows+=2*page.y;  if (SetImageBackgroundColor(image) == MagickFalse)    {      draw_info=DestroyDrawInfo(draw_info);      canvas->buffer=(unsigned char *) RelinquishMagickMemory(canvas->buffer);      canvas=(FT_Bitmap *) RelinquishMagickMemory(canvas);      caption=DestroyString(caption);      image=DestroyImageList(image);      return((Image *) NULL);    }  p=canvas->buffer;  for (y=page.y; y < (ssize_t) (image->rows-page.y); y++)  {    register ssize_t      x;    q=GetAuthenticPixels(image,0,y,image->columns,1,exception);    if (q == (PixelPacket *) NULL)      break;    q+=page.x;    for (x=page.x; x < (ssize_t) (image->columns-page.x); x++)    {      MagickRealType        fill_opacity;      (void) GetFillColor(draw_info,x,y,&fill_color);      fill_opacity=QuantumRange-(*p)/canvas->num_grays*(QuantumRange-        fill_color.opacity);      if (draw_info->text_antialias == MagickFalse)        fill_opacity=fill_opacity >= 0.5 ? 1.0 : 0.0;      MagickCompositeOver(&fill_color,fill_opacity,q,q->opacity,q);      p++;      q++;    }    for ( ; x < (ssize_t) ((canvas->width+3) & ~3); x++)      p++;  }  /*    Relinquish resources.  */  draw_info=DestroyDrawInfo(draw_info);  canvas->buffer=(unsigned char *) RelinquishMagickMemory(canvas->buffer);  canvas=(FT_Bitmap *) RelinquishMagickMemory(canvas);  caption=DestroyString(caption);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........          if ((size_t) (p-keyword) < MaxTextExtent)            *p++=c;          c=ReadBlobByte(image);          count++;        } while (isalnum(c) || (c == '_'));        *p='/0';        value_expected=MagickFalse;        while ((isspace((int) ((unsigned char) c)) != 0) || (c == '='))        {          if (c == '=')            value_expected=MagickTrue;          c=ReadBlobByte(image);          count++;        }        if (value_expected == MagickFalse)          continue;        p=value;        while (isalnum(c))        {          if ((size_t) (p-value) < MaxTextExtent)            *p++=c;          c=ReadBlobByte(image);          count++;        }        *p='/0';        /*          Assign a value to the specified keyword.        */        if (LocaleCompare(keyword,"Label_RECORDS") == 0)          length=(ssize_t) atol(value);        if (LocaleCompare(keyword,"LBLSIZE") == 0)          length=(ssize_t) atol(value);        if (LocaleCompare(keyword,"RECORD_BYTES") == 0)          image->columns=1UL*atol(value);        if (LocaleCompare(keyword,"NS") == 0)          image->columns=1UL*atol(value);        if (LocaleCompare(keyword,"LINES") == 0)          image->rows=1UL*atol(value);        if (LocaleCompare(keyword,"NL") == 0)          image->rows=1UL*atol(value);      }    while (isspace((int) ((unsigned char) c)) != 0)    {      c=ReadBlobByte(image);      count++;    }  }  while (count < (ssize_t) length)  {    c=ReadBlobByte(image);    count++;  }  if ((image->columns == 0) || (image->rows == 0))    ThrowReaderException(CorruptImageError,"NegativeOrZeroImageSize");  image->depth=8;  if (AllocateImageColormap(image,256) == MagickFalse)    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  if (image_info->ping != MagickFalse)    {      (void) CloseBlob(image);      return(GetFirstImageInList(image));    }  /*    Read VICAR pixels.  */  if (SetImageExtent(image,0,0) == MagickFalse)    {      InheritException(exception,&image->exception);      return(DestroyImageList(image));    }  GetQuantumInfo(image_info,&quantum_info);  scanline=(unsigned char *) AcquireQuantumMemory(image->columns,    sizeof(*scanline));  if (scanline == (unsigned char *) NULL)    ThrowReaderException(CorruptImageError,"UnableToReadImageData");  for (y=0; y < (long) image->rows; y++)  {    q=SetImagePixels(image,0,y,image->columns,1);    if (q == (PixelPacket *) NULL)      break;    count=ReadBlob(image,image->columns,scanline);    (void) ExportQuantumPixels(image,&quantum_info,GrayQuantum,scanline);    if (SyncImagePixels(image) == MagickFalse)      break;    if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&        (QuantumTick(y,image->rows) != MagickFalse))      {        status=image->progress_monitor(LoadImageTag,y,image->rows,          image->client_data);        if (status == MagickFalse)          break;      }  }  scanline=(unsigned char *) RelinquishMagickMemory(scanline);  if (EOFBlob(image) != MagickFalse)    ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",      image->filename);  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   G e t I m a g e D e p t h                                                 %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  GetImageDepth() returns the depth of a particular image channel.%%  The format of the GetImageDepth method is:%%      size_t GetImageDepth(const Image *image,ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: the image.%%    o exception: return any errors or warnings in this structure.%*/MagickExport size_t GetImageDepth(const Image *image,  ExceptionInfo *exception){  CacheView    *image_view;  MagickBooleanType    status;  register ssize_t    id;  size_t    *current_depth,    depth,    number_threads;  ssize_t    y;  /*    Compute image depth.  */  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  number_threads=GetOpenMPMaximumThreads();  current_depth=(size_t *) AcquireQuantumMemory(number_threads,    sizeof(*current_depth));  if (current_depth == (size_t *) NULL)    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");  status=MagickTrue;  for (id=0; id < (ssize_t) number_threads; id++)    current_depth[id]=1;  if ((image->storage_class == PseudoClass) && (image->matte == MagickFalse))    {      register const PixelInfo        *restrict p;      register ssize_t        i;      p=image->colormap;#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,4) shared(status)#endif      for (i=0; i < (ssize_t) image->colors; i++)      {        const int          id = GetOpenMPThreadId();        if (status == MagickFalse)          continue;        while (current_depth[id] < MAGICKCORE_QUANTUM_DEPTH)        {          MagickStatusType            status;          QuantumAny            range;          status=0;          range=GetQuantumRange(current_depth[id]);          if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)            status|=p->red != ScaleAnyToQuantum(ScaleQuantumToAny(p->red,              range),range);          if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)            status|=p->green != ScaleAnyToQuantum(ScaleQuantumToAny(p->green,              range),range);          if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)            status|=p->blue != ScaleAnyToQuantum(ScaleQuantumToAny(p->blue,              range),range);          if (status == 0)            break;          current_depth[id]++;//.........这里部分代码省略.........

MagickExport MagickBooleanType AccelerateConvolveImage(const Image *image,  const KernelInfo *kernel,Image *convolve_image,ExceptionInfo *exception){  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(kernel != (KernelInfo *) NULL);  assert(kernel->signature == MagickSignature);  assert(convolve_image != (Image *) NULL);  assert(convolve_image->signature == MagickSignature);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  if ((image->storage_class != DirectClass) ||      (image->colorspace == CMYKColorspace))    return(MagickFalse);  if ((GetImageVirtualPixelMethod(image) != UndefinedVirtualPixelMethod) &&      (GetImageVirtualPixelMethod(image) != EdgeVirtualPixelMethod))    return(MagickFalse);  if (GetPixelChannels(image) != 4)    return(MagickFalse);#if !defined(MAGICKCORE_OPENCL_SUPPORT)  return(MagickFalse);#else  {    const void      *pixels;    float      *filter;    ConvolveInfo      *convolve_info;    MagickBooleanType      status;    MagickSizeType      length;    register ssize_t      i;    void      *convolve_pixels;    convolve_info=GetConvolveInfo(image,"Convolve",ConvolveKernel,exception);    if (convolve_info == (ConvolveInfo *) NULL)      return(MagickFalse);    pixels=AcquirePixelCachePixels(image,&length,exception);    if (pixels == (const void *) NULL)      {        convolve_info=DestroyConvolveInfo(convolve_info);        (void) ThrowMagickException(exception,GetMagickModule(),CacheError,          "UnableToReadPixelCache","'%s'",image->filename);        return(MagickFalse);      }    convolve_pixels=GetPixelCachePixels(convolve_image,&length,exception);    if (convolve_pixels == (void *) NULL)      {        convolve_info=DestroyConvolveInfo(convolve_info);        (void) ThrowMagickException(exception,GetMagickModule(),CacheError,          "UnableToReadPixelCache","'%s'",image->filename);        return(MagickFalse);      }    filter=(float *) AcquireQuantumMemory(kernel->width,kernel->height*      sizeof(*filter));    if (filter == (float *) NULL)      {        DestroyConvolveBuffers(convolve_info);        convolve_info=DestroyConvolveInfo(convolve_info);        (void) ThrowMagickException(exception,GetMagickModule(),          ResourceLimitError,"MemoryAllocationFailed","'%s'",image->filename);        return(MagickFalse);      }    for (i=0; i < (ssize_t) (kernel->width*kernel->height); i++)      filter[i]=(float) kernel->values[i];    status=BindConvolveParameters(convolve_info,image,pixels,filter,      kernel->width,kernel->height,convolve_pixels);    if (status == MagickFalse)      {        filter=(float *) RelinquishMagickMemory(filter);        DestroyConvolveBuffers(convolve_info);        convolve_info=DestroyConvolveInfo(convolve_info);        return(MagickFalse);      }    status=EnqueueConvolveKernel(convolve_info,image,pixels,filter,      kernel->width,kernel->height,convolve_pixels);    filter=(float *) RelinquishMagickMemory(filter);    if (status == MagickFalse)      {        DestroyConvolveBuffers(convolve_info);        convolve_info=DestroyConvolveInfo(convolve_info);        return(MagickFalse);      }    DestroyConvolveBuffers(convolve_info);    convolve_info=DestroyConvolveInfo(convolve_info);    return(MagickTrue);  }#endif//.........这里部分代码省略.........

//.........这里部分代码省略.........      ThrowReaderException(CorruptImageError,"ImproperImageHeader");    if (flags & 0x02)      {        /*          No background color-- initialize to black.        */        for (i=0; i < (ssize_t) number_planes; i++)          background_color[i]=0;        (void) ReadBlobByte(image);      }    else      {        /*          Initialize background color.        */        p=background_color;        for (i=0; i < (ssize_t) number_planes; i++)          *p++=(unsigned char) ReadBlobByte(image);      }    if ((number_planes & 0x01) == 0)      (void) ReadBlobByte(image);    if (EOFBlob(image) != MagickFalse)      {        ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",          image->filename);        break;      }    colormap=(unsigned char *) NULL;    if (number_colormaps != 0)      {        /*          Read image colormaps.        */        colormap=(unsigned char *) AcquireQuantumMemory(number_colormaps,          3*map_length*sizeof(*colormap));        if (colormap == (unsigned char *) NULL)          ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");        p=colormap;        for (i=0; i < (ssize_t) number_colormaps; i++)          for (x=0; x < (ssize_t) map_length; x++)            *p++=(unsigned char) ScaleShortToQuantum(ReadBlobLSBShort(image));      }    if ((flags & 0x08) != 0)      {        char          *comment;        size_t          length;        /*          Read image comment.        */        length=ReadBlobLSBShort(image);        if (length != 0)          {            comment=(char *) AcquireQuantumMemory(length,sizeof(*comment));            if (comment == (char *) NULL)              ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");            count=ReadBlob(image,length-1,(unsigned char *) comment);            comment[length-1]='/0';            (void) SetImageProperty(image,"comment",comment,exception);            comment=DestroyString(comment);            if ((length & 0x01) == 0)              (void) ReadBlobByte(image);          }

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   R e a d J B I G I m a g e                                                 %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ReadJBIGImage() reads a JBIG image file and returns it.  It%  allocates the memory necessary for the new Image structure and returns a%  pointer to the new image.%%  The format of the ReadJBIGImage method is:%%      Image *ReadJBIGImage(const ImageInfo *image_info,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image_info: the image info.%%    o exception: return any errors or warnings in this structure.%*/static Image *ReadJBIGImage(const ImageInfo *image_info,  ExceptionInfo *exception){  Image    *image;  MagickStatusType    status;  Quantum    index;  register ssize_t    x;  register Quantum    *q;  register unsigned char    *p;  ssize_t    length,    y;  struct jbg_dec_state    jbig_info;  unsigned char    bit,    *buffer,    byte;  /*    Open image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  if (image_info->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",      image_info->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  image=AcquireImage(image_info,exception);  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);  if (status == MagickFalse)    {      image=DestroyImageList(image);      return((Image *) NULL);    }  /*    Initialize JBIG toolkit.  */  jbg_dec_init(&jbig_info);  jbg_dec_maxsize(&jbig_info,(unsigned long) image->columns,(unsigned long)    image->rows);  image->columns=jbg_dec_getwidth(&jbig_info);  image->rows=jbg_dec_getheight(&jbig_info);  image->depth=8;  image->storage_class=PseudoClass;  image->colors=2;  /*    Read JBIG file.  */  buffer=(unsigned char *) AcquireQuantumMemory(MagickMaxBufferExtent,    sizeof(*buffer));  if (buffer == (unsigned char *) NULL)    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  status=JBG_EAGAIN;  do  {    length=(ssize_t) ReadBlob(image,MagickMaxBufferExtent,buffer);    if (length == 0)//.........这里部分代码省略.........

static MagickBooleanType WriteJBIGImage(const ImageInfo *image_info,  Image *image,ExceptionInfo *exception){  double    version;  MagickBooleanType    status;  MagickOffsetType    scene;  register const Quantum    *p;  register ssize_t    x;  register unsigned char    *q;  size_t    number_packets;  ssize_t    y;  struct jbg_enc_state    jbig_info;  unsigned char    bit,    byte,    *pixels;  /*    Open image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);  if (status == MagickFalse)    return(status);  version=StringToDouble(JBG_VERSION,(char **) NULL);  scene=0;  do  {    /*      Allocate pixel data.    */    if (IsRGBColorspace(image->colorspace) == MagickFalse)      (void) TransformImageColorspace(image,RGBColorspace,exception);    number_packets=(image->columns+7)/8;    pixels=(unsigned char *) AcquireQuantumMemory(number_packets,      image->rows*sizeof(*pixels));    if (pixels == (unsigned char *) NULL)      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");    /*      Convert pixels to a bitmap.    */    (void) SetImageType(image,BilevelType,exception);    q=pixels;    for (y=0; y < (ssize_t) image->rows; y++)    {      p=GetVirtualPixels(image,0,y,image->columns,1,exception);      if (p == (const Quantum *) NULL)        break;      bit=0;      byte=0;      for (x=0; x < (ssize_t) image->columns; x++)      {        byte<<=1;        if (GetPixelIntensity(image,p) < (QuantumRange/2.0))          byte|=0x01;        bit++;        if (bit == 8)          {            *q++=byte;            bit=0;            byte=0;          }        p+=GetPixelChannels(image);      }      if (bit != 0)        *q++=byte << (8-bit);      if (image->previous == (Image *) NULL)        {          status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,            image->rows);          if (status == MagickFalse)            break;        }    }    /*//.........这里部分代码省略.........

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   R e a d E P T I m a g e                                                   %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ReadEPTImage() reads a binary Postscript image file and returns it.  It%  allocates the memory necessary for the new Image structure and returns a%  pointer to the new image.%%  The format of the ReadEPTImage method is:%%      Image *ReadEPTImage(const ImageInfo *image_info,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image_info: the image info.%%    o exception: return any errors or warnings in this structure.%*/static Image *ReadEPTImage(const ImageInfo *image_info,ExceptionInfo *exception){  EPTInfo    ept_info;  Image    *image;  ImageInfo    *read_info;  MagickBooleanType    status;  MagickOffsetType    offset;  ssize_t    count;  /*    Open image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickCoreSignature);  if (image_info->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",      image_info->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickCoreSignature);  image=AcquireImage(image_info,exception);  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);  if (status == MagickFalse)    {      image=DestroyImageList(image);      return((Image *) NULL);    }  ept_info.magick=ReadBlobLSBLong(image);  if (ept_info.magick != 0xc6d3d0c5ul)    ThrowReaderException(CorruptImageError,"ImproperImageHeader");  ept_info.postscript_offset=(MagickOffsetType) ReadBlobLSBLong(image);  ept_info.postscript_length=ReadBlobLSBLong(image);  (void) ReadBlobLSBLong(image);  (void) ReadBlobLSBLong(image);  ept_info.tiff_offset=(MagickOffsetType) ReadBlobLSBLong(image);  ept_info.tiff_length=ReadBlobLSBLong(image);  (void) ReadBlobLSBShort(image);  ept_info.postscript=(unsigned char *) AcquireQuantumMemory(    ept_info.postscript_length+1,sizeof(*ept_info.postscript));  if (ept_info.postscript == (unsigned char *) NULL)    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  (void) ResetMagickMemory(ept_info.postscript,0,(ept_info.postscript_length+1)*    sizeof(*ept_info.postscript));  ept_info.tiff=(unsigned char *) AcquireQuantumMemory(ept_info.tiff_length+1,    sizeof(*ept_info.tiff));  if (ept_info.tiff == (unsigned char *) NULL)    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  (void) ResetMagickMemory(ept_info.tiff,0,(ept_info.tiff_length+1)*    sizeof(*ept_info.tiff));  offset=SeekBlob(image,ept_info.tiff_offset,SEEK_SET);  if (offset < 0)    ThrowReaderException(CorruptImageError,"ImproperImageHeader");  count=ReadBlob(image,ept_info.tiff_length,ept_info.tiff);  if (count != (ssize_t) (ept_info.tiff_length))    (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageWarning,      "InsufficientImageDataInFile","`%s'",image->filename);  offset=SeekBlob(image,ept_info.postscript_offset,SEEK_SET);  if (offset < 0)    ThrowReaderException(CorruptImageError,"ImproperImageHeader");  count=ReadBlob(image,ept_info.postscript_length,ept_info.postscript);  if (count != (ssize_t) (ept_info.postscript_length))    (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageWarning,      "InsufficientImageDataInFile","`%s'",image->filename);//.........这里部分代码省略.........

//.........这里部分代码省略.........          {            /*              Create linear color ramp.            */            image->colors=image->depth <= 8 ? 256UL : 65536UL;            if (viff_info.data_storage_type == VFF_TYP_BIT)              image->colors=2;            if (AllocateImageColormap(image,image->colors) == MagickFalse)              ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");          }        break;      }      case VFF_MS_ONEPERBAND:      case VFF_MS_SHARED:      {        unsigned char          *viff_colormap;        /*          Allocate VIFF colormap.        */        switch ((int) viff_info.map_storage_type)        {          case VFF_MAPTYP_1_BYTE: bytes_per_pixel=1; break;          case VFF_MAPTYP_2_BYTE: bytes_per_pixel=2; break;          case VFF_MAPTYP_4_BYTE: bytes_per_pixel=4; break;          case VFF_MAPTYP_FLOAT: bytes_per_pixel=4; break;          case VFF_MAPTYP_DOUBLE: bytes_per_pixel=8; break;          default: bytes_per_pixel=1; break;        }        image->colors=viff_info.map_columns;        if (AllocateImageColormap(image,image->colors) == MagickFalse)          ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");        viff_colormap=(unsigned char *) AcquireQuantumMemory(image->colors,          viff_info.map_rows*bytes_per_pixel*sizeof(*viff_colormap));        if (viff_colormap == (unsigned char *) NULL)          ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");        /*          Read VIFF raster colormap.        */        count=ReadBlob(image,bytes_per_pixel*image->colors*viff_info.map_rows,          viff_colormap);        lsb_first=1;        if (*(char *) &lsb_first &&            ((viff_info.machine_dependency != VFF_DEP_DECORDER) &&             (viff_info.machine_dependency != VFF_DEP_NSORDER)))          switch ((int) viff_info.map_storage_type)          {            case VFF_MAPTYP_2_BYTE:            {              MSBOrderShort(viff_colormap,(bytes_per_pixel*image->colors*                viff_info.map_rows));              break;            }            case VFF_MAPTYP_4_BYTE:            case VFF_MAPTYP_FLOAT:            {              MSBOrderLong(viff_colormap,(bytes_per_pixel*image->colors*                viff_info.map_rows));              break;            }            default: break;          }        for (i=0; i < (long) (viff_info.map_rows*image->colors); i++)        {          switch ((int) viff_info.map_storage_type)

//.........这里部分代码省略.........          if (montage_info->tile != (char *) NULL)            GetMontageGeometry(montage_info->tile,number_images,&x_offset,&y,              &sans,&sans);          height=concatenate != MagickFalse ? max_height : extract_info.height;          y_offset+=(ssize_t) (height+(extract_info.y+(ssize_t) border_width)*2+            (metrics.ascent-metrics.descent+4)*number_lines+            (montage_info->shadow != MagickFalse ? 4 : 0));          if (y_offset > (ssize_t) bounds.height)            bounds.height=(size_t) y_offset;          max_height=0;        }    }    if (montage_info->shadow != MagickFalse)      bounds.width+=4;    /*      Initialize montage image.    */    (void) CopyMagickString(montage->filename,montage_info->filename,      MagickPathExtent);    montage->columns=(size_t) MagickMax((ssize_t) bounds.width,1);    montage->rows=(size_t) MagickMax((ssize_t) bounds.height,1);    (void) SetImageBackgroundColor(montage,exception);    /*      Set montage geometry.    */    montage->montage=AcquireString((char *) NULL);    tile=0;    extent=1;    while (tile < MagickMin((ssize_t) tiles_per_page,(ssize_t) number_images))    {      extent+=strlen(image_list[tile]->filename)+1;      tile++;    }    montage->directory=(char *) AcquireQuantumMemory(extent,      sizeof(*montage->directory));    if ((montage->montage == (char *) NULL) ||        (montage->directory == (char *) NULL))      {        if (montage->montage != (char *) NULL)          montage->montage=(char *) RelinquishMagickMemory(montage->montage);        if (montage->directory != (char *) NULL)          montage->directory=(char *) RelinquishMagickMemory(            montage->directory);        ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");      }    x_offset=0;    y_offset=0;    if (montage_info->tile != (char *) NULL)      GetMontageGeometry(montage_info->tile,number_images,&x_offset,&y_offset,        &sans,&sans);    y_offset+=(ssize_t) title_offset;    (void) FormatLocaleString(montage->montage,MagickPathExtent,      "%.20gx%.20g%+.20g%+.20g",(double) (extract_info.width+      (extract_info.x+border_width)*2),(double) (extract_info.height+      (extract_info.y+border_width)*2+(double) ((metrics.ascent-      metrics.descent+4)*number_lines+(montage_info->shadow != MagickFalse ? 4 :      0))),(double) x_offset,(double) y_offset);    *montage->directory='/0';    tile=0;    while (tile < MagickMin((ssize_t) tiles_per_page,(ssize_t) number_images))    {      (void) ConcatenateMagickString(montage->directory,        image_list[tile]->filename,extent);      (void) ConcatenateMagickString(montage->directory,"/n",extent);      tile++;    }

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   R e a d H R Z I m a g e                                                   %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ReadHRZImage() reads a Slow Scan TeleVision image file and returns it.  It%  allocates the memory necessary for the new Image structure and returns a%  pointer to the new image.%%  The format of the ReadHRZImage method is:%%      Image *ReadHRZImage(const ImageInfo *image_info,ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image_info: the image info.%%    o exception: return any errors or warnings in this structure.%*/static Image *ReadHRZImage(const ImageInfo *image_info,ExceptionInfo *exception){  Image    *image;  MagickBooleanType    status;  register ssize_t    x;  register Quantum    *q;  register unsigned char    *p;  ssize_t    count,    y;  size_t    length;  unsigned char    *pixels;  /*    Open image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickCoreSignature);  if (image_info->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",      image_info->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickCoreSignature);  image=AcquireImage(image_info,exception);  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);  if (status == MagickFalse)    {      image=DestroyImageList(image);      return((Image *) NULL);    }  /*    Convert HRZ raster image to pixel packets.  */  image->columns=256;  image->rows=240;  image->depth=8;  status=SetImageExtent(image,image->columns,image->rows,exception);  if (status == MagickFalse)    return(DestroyImageList(image));  pixels=(unsigned char *) AcquireQuantumMemory(image->columns,3*    sizeof(*pixels));  if (pixels == (unsigned char *) NULL)     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  length=(size_t) (3*image->columns);  for (y=0; y < (ssize_t) image->rows; y++)  {    count=ReadBlob(image,length,pixels);    if ((size_t) count != length)      ThrowReaderException(CorruptImageError,"UnableToReadImageData");    p=pixels;    q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);    if (q == (Quantum *) NULL)      break;    for (x=0; x < (ssize_t) image->columns; x++)    {      SetPixelRed(image,ScaleCharToQuantum(4**p++),q);      SetPixelGreen(image,ScaleCharToQuantum(4**p++),q);      SetPixelBlue(image,ScaleCharToQuantum(4**p++),q);      SetPixelAlpha(image,OpaqueAlpha,q);      q+=GetPixelChannels(image);//.........这里部分代码省略.........

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   W r i t e H R Z I m a g e                                                 %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  WriteHRZImage() writes an image to a file in HRZ X image format.%%  The format of the WriteHRZImage method is:%%      MagickBooleanType WriteHRZImage(const ImageInfo *image_info,%        Image *image,ExceptionInfo *exception)%%  A description of each parameter follows.%%    o image_info: the image info.%%    o image:  The image.%%    o exception: return any errors or warnings in this structure.%*/static MagickBooleanType WriteHRZImage(const ImageInfo *image_info,Image *image,  ExceptionInfo *exception){  Image    *hrz_image;  MagickBooleanType    status;  register const Quantum    *p;  register ssize_t    x,    y;  register unsigned char    *q;  ssize_t    count;  unsigned char    *pixels;  /*    Open output image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickCoreSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickCoreSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickCoreSignature);  status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);  if (status == MagickFalse)    return(status);  hrz_image=ResizeImage(image,256,240,image->filter,exception);  if (hrz_image == (Image *) NULL)    return(MagickFalse);  (void) TransformImageColorspace(hrz_image,sRGBColorspace,exception);  /*    Allocate memory for pixels.  */  pixels=(unsigned char *) AcquireQuantumMemory((size_t) hrz_image->columns,    3*sizeof(*pixels));  if (pixels == (unsigned char *) NULL)    {      hrz_image=DestroyImage(hrz_image);      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");    }  /*    Convert MIFF to HRZ raster pixels.  */  for (y=0; y < (ssize_t) hrz_image->rows; y++)  {    p=GetVirtualPixels(hrz_image,0,y,hrz_image->columns,1,exception);    if (p == (const Quantum *) NULL)      break;    q=pixels;    for (x=0; x < (ssize_t) hrz_image->columns; x++)    {      *q++=ScaleQuantumToChar(GetPixelRed(hrz_image,p)/4);      *q++=ScaleQuantumToChar(GetPixelGreen(hrz_image,p)/4);      *q++=ScaleQuantumToChar(GetPixelBlue(hrz_image,p)/4);      p+=GetPixelChannels(hrz_image);    }    count=WriteBlob(image,(size_t) (q-pixels),pixels);    if (count != (ssize_t) (q-pixels))      break;    status=SetImageProgress(image,SaveImageTag,y,hrz_image->rows);//.........这里部分代码省略.........

static Image *ReadSFWImage(const ImageInfo *image_info,ExceptionInfo *exception){  static unsigned char    HuffmanTable[] =    {      0xFF, 0xC4, 0x01, 0xA2, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01,      0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,      0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,      0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,      0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,      0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x10, 0x00, 0x02, 0x01,      0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00,      0x01, 0x7D, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21,      0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32,      0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1,      0xF0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18,      0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36,      0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,      0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64,      0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77,      0x78, 0x79, 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A,      0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3,      0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5,      0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,      0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9,      0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,      0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0x11,      0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04,      0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04,      0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13,      0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 0x09,      0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24,      0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27, 0x28,      0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45,      0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,      0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73,      0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85,      0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,      0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9,      0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2,      0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4,      0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6,      0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,      0xF9, 0xFA    };  FILE    *file;  Image    *flipped_image,    *image;  ImageInfo    *read_info;  int    unique_file;  MagickBooleanType    status;  register unsigned char    *header,    *data;  size_t    extent;  ssize_t    count;  unsigned char    *buffer,    *offset;  /*    Open image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  if (image_info->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",      image_info->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  image=AcquireImage(image_info);  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);  if (status == MagickFalse)    {      image=DestroyImageList(image);      return((Image *) NULL);    }  /*    Read image into a buffer.  */  buffer=(unsigned char *) AcquireQuantumMemory((size_t) GetBlobSize(image),    sizeof(*buffer));  if (buffer == (unsigned char *) NULL)    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");//.........这里部分代码省略.........

MagickExport MagickBooleanType SortColormapByIntensity(Image *image){  CacheView    *image_view;  ExceptionInfo    *exception;  long    y;  MagickBooleanType    status;  register long    i;  unsigned short    *pixels;  assert(image != (Image *) NULL);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");  assert(image->signature == MagickSignature);  if (image->storage_class != PseudoClass)    return(MagickTrue);  /*    Allocate memory for pixel indexes.  */  pixels=(unsigned short *) AcquireQuantumMemory((size_t) image->colors,    sizeof(*pixels));  if (pixels == (unsigned short *) NULL)    ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",      image->filename);  /*    Assign index values to colormap entries.  */#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(dynamic,4) shared(status)#endif  for (i=0; i < (long) image->colors; i++)    image->colormap[i].opacity=(IndexPacket) i;  /*    Sort image colormap by decreasing color popularity.  */  qsort((void *) image->colormap,(size_t) image->colors,    sizeof(*image->colormap),IntensityCompare);  /*    Update image colormap indexes to sorted colormap order.  */#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(dynamic,4) shared(status)#endif  for (i=0; i < (long) image->colors; i++)    pixels[(long) image->colormap[i].opacity]=(unsigned short) i;  status=MagickTrue;  exception=(&image->exception);  image_view=AcquireCacheView(image);  for (y=0; y < (long) image->rows; y++)  {    IndexPacket      index;    register long      x;    register IndexPacket      *restrict indexes;    register PixelPacket      *restrict q;    q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);    if (q == (PixelPacket *) NULL)      {        status=MagickFalse;        continue;      }    indexes=GetCacheViewAuthenticIndexQueue(image_view);    for (x=0; x < (long) image->columns; x++)    {      index=(IndexPacket) pixels[(long) indexes[x]];      indexes[x]=index;      *q++=image->colormap[(long) index];    }    if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)      status=MagickFalse;    if (status == MagickFalse)      break;  }  image_view=DestroyCacheView(image_view);  pixels=(unsigned short *) RelinquishMagickMemory(pixels);  return(status);}

//.........这里部分代码省略.........           (compression == Group4Compression) ? 1 : 8);        (void) WriteBlobString(image,buffer);        switch (compression)        {          case FaxCompression:          case Group4Compression:          {            if (LocaleCompare(CCITTParam,"0") == 0)              {                (void) HuffmanEncodeImage(image_info,image,image);                break;              }            (void) Huffman2DEncodeImage(image_info,image,image);            break;          }          case JPEGCompression:          {            status=InjectImageBlob(image_info,image,image,"jpeg",              &image->exception);            if (status == MagickFalse)              ThrowWriterException(CoderError,image->exception.reason);            break;          }          case RLECompression:          default:          {            register unsigned char              *q;            /*              Allocate pixel array.            */            length=(size_t) number_pixels;            pixels=(unsigned char *) AcquireQuantumMemory(length,              sizeof(*pixels));            if (pixels == (unsigned char *) NULL)              ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");            /*              Dump Runlength encoded pixels.            */            q=pixels;            for (y=0; y < (ssize_t) image->rows; y++)            {              p=GetVirtualPixels(image,0,y,image->columns,1,                &image->exception);              if (p == (const PixelPacket *) NULL)                break;              for (x=0; x < (ssize_t) image->columns; x++)              {                *q++=ScaleQuantumToChar(PixelIntensityToQuantum(p));                p++;              }              progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,                image->rows);              if (progress == MagickFalse)                break;            }            length=(size_t) (q-pixels);            if (compression == LZWCompression)              status=LZWEncodeImage(image,length,pixels);            else              status=PackbitsEncodeImage(image,length,pixels);            pixels=(unsigned char *) RelinquishMagickMemory(pixels);            if (status == MagickFalse)              {                (void) CloseBlob(image);

//.........这里部分代码省略.........    assert(image_info->signature == MagickCoreSignature);    assert(image != (Image *) NULL);    assert(image->signature == MagickCoreSignature);    if (image->debug != MagickFalse)        (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);    assert(exception != (ExceptionInfo *) NULL);    assert(exception->signature == MagickCoreSignature);    status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);    if (status == MagickFalse)        return(status);    (void) TransformImageColorspace(image,sRGBColorspace,exception);    transparent=MagickFalse;    i=0;    p=(const Quantum *) NULL;    if (image->storage_class == PseudoClass)        colors=image->colors;    else    {        unsigned char        *matte_image;        /*          Convert DirectClass to PseudoClass image.        */        matte_image=(unsigned char *) NULL;        if (image->alpha_trait != UndefinedPixelTrait)        {            /*              Map all the transparent pixels.            */            number_pixels=(MagickSizeType) image->columns*image->rows;            if (number_pixels != ((MagickSizeType) (size_t) number_pixels))                ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");            matte_image=(unsigned char *) AcquireQuantumMemory(image->columns,                        image->rows*sizeof(*matte_image));            if (matte_image == (unsigned char *) NULL)                ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");            for (y=0; y < (ssize_t) image->rows; y++)            {                p=GetVirtualPixels(image,0,y,image->columns,1,exception);                if (p == (const Quantum *) NULL)                    break;                for (x=0; x < (ssize_t) image->columns; x++)                {                    matte_image[i]=(unsigned char) (GetPixelAlpha(image,p) ==                                                    (Quantum) TransparentAlpha ? 1 : 0);                    if (matte_image[i] != 0)                        transparent=MagickTrue;                    i++;                    p+=GetPixelChannels(image);                }            }        }        (void) SetImageType(image,PaletteType,exception);        colors=image->colors;        if (transparent != MagickFalse)        {            register Quantum            *q;            colors++;            for (y=0; y < (ssize_t) image->rows; y++)            {                q=GetAuthenticPixels(image,0,y,image->columns,1,exception);                if (q == (Quantum *) NULL)                    break;

static HENHMETAFILE ReadEnhMetaFile(const char *path,long *width,  long *height){#pragma pack( push )#pragma pack( 2 )  typedef struct  {    DWORD dwKey;    WORD hmf;    SMALL_RECT bbox;    WORD wInch;    DWORD dwReserved;    WORD wCheckSum;  } APMHEADER, *PAPMHEADER;#pragma pack( pop )  DWORD    dwSize;  ENHMETAHEADER    emfh;  HANDLE    hFile;  HDC    hDC;  HENHMETAFILE    hTemp;  LPBYTE    pBits;  METAFILEPICT    mp;  HMETAFILE    hOld;  *width=512;  *height=512;  hTemp=GetEnhMetaFile(path);#if defined(MAGICKCORE_HAVE__WFOPEN)  if (hTemp == (HENHMETAFILE) NULL)    {      wchar_t        *unicode_path;      unicode_path=ConvertUTF8ToUTF16(path);      if (unicode_path != (wchar_t *) NULL)        {          hTemp=GetEnhMetaFileW(unicode_path);          unicode_path=(wchar_t *) RelinquishMagickMemory(unicode_path);        }    }#endif  if (hTemp != (HENHMETAFILE) NULL)    {      /*        Enhanced metafile.      */      GetEnhMetaFileHeader(hTemp,sizeof(ENHMETAHEADER),&emfh);      *width=emfh.rclFrame.right-emfh.rclFrame.left;      *height=emfh.rclFrame.bottom-emfh.rclFrame.top;      return(hTemp);    }  hOld=GetMetaFile(path);  if (hOld != (HMETAFILE) NULL)    {      /*        16bit windows metafile.      */      dwSize=GetMetaFileBitsEx(hOld,0,NULL);      if (dwSize == 0)        {          DeleteMetaFile(hOld);          return((HENHMETAFILE) NULL);        }      pBits=(LPBYTE) AcquireQuantumMemory(dwSize,sizeof(*pBits));      if (pBits == (LPBYTE) NULL)        {          DeleteMetaFile(hOld);          return((HENHMETAFILE) NULL);        }      if (GetMetaFileBitsEx(hOld,dwSize,pBits) == 0)        {          pBits=(BYTE *) DestroyString((char *) pBits);          DeleteMetaFile(hOld);          return((HENHMETAFILE) NULL);        }      /*        Make an enhanced metafile from the windows metafile.      */      mp.mm=MM_ANISOTROPIC;      mp.xExt=1000;      mp.yExt=1000;      mp.hMF=NULL;      hDC=GetDC(NULL);      hTemp=SetWinMetaFileBits(dwSize,pBits,hDC,&mp);//.........这里部分代码省略.........

//.........这里部分代码省略.........  ssize_t    y;  unsigned char    *data;  /*    Open image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  if (image_info->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",      image_info->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  image=AcquireImage(image_info,exception);  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);  if (status == MagickFalse)    {      image=DestroyImageList(image);      return((Image *) NULL);    }  /*    Read RGF header.  */  image->columns = (unsigned long) ReadBlobByte(image);  image->rows = (unsigned long) ReadBlobByte(image);  image->depth=8;  image->storage_class=PseudoClass;  image->colors=2;  /*    Initialize image structure.  */  if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  /*    Initialize colormap.  */  image->colormap[0].red=QuantumRange;  image->colormap[0].green=QuantumRange;  image->colormap[0].blue=QuantumRange;  image->colormap[1].red=(Quantum) 0;  image->colormap[1].green=(Quantum) 0;  image->colormap[1].blue=(Quantum) 0;  if (image_info->ping != MagickFalse)    {      (void) CloseBlob(image);      return(GetFirstImageInList(image));    }  /*    Read hex image data.  */  data=(unsigned char *) AcquireQuantumMemory(image->rows,image->columns*    sizeof(*data));  if (data == (unsigned char *) NULL)    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  p=data;  for (i=0; i < (ssize_t) (image->columns * image->rows); i++)     {      *p++=ReadBlobByte(image);    }  /*    Convert RGF image to pixel packets.  */  p=data;  for (y=0; y < (ssize_t) image->rows; y++)  {    q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);    if (q == (Quantum *) NULL)      break;    bit=0;    byte=0;    for (x=0; x < (ssize_t) image->columns; x++)    {      if (bit == 0)        byte=(size_t) (*p++);      SetPixelIndex(image,(Quantum) ((byte & 0x01) != 0 ? 0x01 : 0x00),q);      bit++;      byte>>=1;      if (bit == 8)        bit=0;      q+=GetPixelChannels(image);    }    if (SyncAuthenticPixels(image,exception) == MagickFalse)      break;    status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,      image->rows);    if (status == MagickFalse)      break;  }  data=(unsigned char *) RelinquishMagickMemory(data);  (void) SyncImage(image,exception);  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........  /*    Open image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickCoreSignature);  if (image_info->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",      image_info->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickCoreSignature);  image=AcquireImage(image_info,exception);  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);  if (status == MagickFalse)    {      image=DestroyImageList(image);      return((Image *) NULL);    }  /*    Determine if this a PCX file.  */  page_table=(MagickOffsetType *) NULL;  if (LocaleCompare(image_info->magick,"DCX") == 0)    {      size_t        magic;      /*        Read the DCX page table.      */      magic=ReadBlobLSBLong(image);      if (magic != 987654321)        ThrowReaderException(CorruptImageError,"ImproperImageHeader");      page_table=(MagickOffsetType *) AcquireQuantumMemory(1024UL,        sizeof(*page_table));      if (page_table == (MagickOffsetType *) NULL)        ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");      for (id=0; id < 1024; id++)      {        page_table[id]=(MagickOffsetType) ReadBlobLSBLong(image);        if (page_table[id] == 0)          break;      }    }  if (page_table != (MagickOffsetType *) NULL)    {      offset=SeekBlob(image,(MagickOffsetType) page_table[0],SEEK_SET);      if (offset < 0)        ThrowReaderException(CorruptImageError,"ImproperImageHeader");    }  count=ReadBlob(image,1,&pcx_info.identifier);  for (id=1; id < 1024; id++)  {    int      bits_per_pixel;    /*      Verify PCX identifier.    */    pcx_info.version=(unsigned char) ReadBlobByte(image);    if ((count != 1) || (pcx_info.identifier != 0x0a))      ThrowReaderException(CorruptImageError,"ImproperImageHeader");    pcx_info.encoding=(unsigned char) ReadBlobByte(image);    bits_per_pixel=ReadBlobByte(image);    if (bits_per_pixel == -1)      ThrowReaderException(CorruptImageError,"ImproperImageHeader");

MagickExport MagickBooleanType SortColormapByIntensity(Image *image,  ExceptionInfo *exception){  CacheView    *image_view;  MagickBooleanType    status;  register ssize_t    i;  ssize_t    y;  unsigned short    *pixels;  assert(image != (Image *) NULL);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");  assert(image->signature == MagickCoreSignature);  if (image->storage_class != PseudoClass)    return(MagickTrue);  /*    Allocate memory for pixel indexes.  */  pixels=(unsigned short *) AcquireQuantumMemory((size_t) image->colors,    sizeof(*pixels));  if (pixels == (unsigned short *) NULL)    ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",      image->filename);  /*    Assign index values to colormap entries.  */#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,4) shared(status) /    magick_threads(image,image,1,1)#endif  for (i=0; i < (ssize_t) image->colors; i++)    image->colormap[i].alpha=(double) i;  /*    Sort image colormap by decreasing color popularity.  */  qsort((void *) image->colormap,(size_t) image->colors,    sizeof(*image->colormap),IntensityCompare);  /*    Update image colormap indexes to sorted colormap order.  */#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,4) shared(status)#endif  for (i=0; i < (ssize_t) image->colors; i++)    pixels[(ssize_t) image->colormap[i].alpha]=(unsigned short) i;  status=MagickTrue;  image_view=AcquireAuthenticCacheView(image,exception);  for (y=0; y < (ssize_t) image->rows; y++)  {    Quantum      index;    register ssize_t      x;    register Quantum      *restrict q;    q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);    if (q == (Quantum *) NULL)      {        status=MagickFalse;        break;      }    for (x=0; x < (ssize_t) image->columns; x++)    {      index=(Quantum) pixels[(ssize_t) GetPixelIndex(image,q)];      SetPixelIndex(image,index,q);      SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);      q+=GetPixelChannels(image);    }    if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)      status=MagickFalse;    if (status == MagickFalse)      break;  }  image_view=DestroyCacheView(image_view);  pixels=(unsigned short *) RelinquishMagickMemory(pixels);  return(status);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   W r i t e V I C A R I m a g e                                             %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  WriteVICARImage() writes an image in the VICAR rasterfile format.%  Vicar files contain a text header, followed by one or more planes of binary%  grayscale image data.  Vicar files are designed to allow many planes to be%  stacked together to form image cubes.  This method only writes a single%  grayscale plane.%%  WriteVICARImage was written contributed by%  [email
C++ AcquireSRWLockExclusive函数代码示例
C++ AcquireQuantumInfo函数代码示例