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

static MagickBooleanType ReadVIPSPixelsNONE(Image *image,  const VIPSBandFormat format,const VIPSType type,const unsigned int channels,  ExceptionInfo *exception){  Quantum    pixel;  register IndexPacket    *indexes;  register PixelPacket    *q;  register ssize_t    x;  ssize_t    y;  for (y = 0; y < (ssize_t) image->rows; y++)  {    q=GetAuthenticPixels(image,0,y,image->columns,1,exception);    if (q == (PixelPacket *) NULL)      return MagickFalse;    indexes=GetAuthenticIndexQueue(image);    for (x=0; x < (ssize_t) image->columns; x++)    {      pixel=ReadVIPSPixelNONE(image,format,type);      SetPixelRed(q,pixel);      if (channels < 3)        {          SetPixelGreen(q,pixel);          SetPixelBlue(q,pixel);          if (channels == 2)            SetPixelAlpha(q,ReadVIPSPixelNONE(image,format,type));        }      else        {          SetPixelGreen(q,ReadVIPSPixelNONE(image,format,type));          SetPixelBlue(q,ReadVIPSPixelNONE(image,format,type));          if (channels == 4)            {              if (image->colorspace == CMYKColorspace)                SetPixelIndex(indexes+x,ReadVIPSPixelNONE(image,format,type));              else                SetPixelAlpha(q,ReadVIPSPixelNONE(image,format,type));            }          else if (channels == 5)            {              SetPixelIndex(indexes+x,ReadVIPSPixelNONE(image,format,type));              SetPixelAlpha(q,ReadVIPSPixelNONE(image,format,type));            }        }      q++;    }    if (SyncAuthenticPixels(image,exception) == MagickFalse)      return MagickFalse;  }  return(MagickTrue);}

static inline void PlasmaPixel(Image *image,RandomInfo *random_info,double x,  double y){  ExceptionInfo    *exception;  QuantumAny    range;  register PixelPacket    *q;  exception=(&image->exception);  q=GetAuthenticPixels(image,(ssize_t) ceil(x-0.5),(ssize_t) ceil(y-0.5),1,1,    exception);  if (q == (PixelPacket *) NULL)    return;  range=GetQuantumRange(16UL);  q->red=ScaleAnyToQuantum((size_t) (65535.0*    GetPseudoRandomValue(random_info)+0.5),range);  q->green=ScaleAnyToQuantum((size_t) (65535.0*    GetPseudoRandomValue(random_info)+0.5),range);  q->blue=ScaleAnyToQuantum((size_t) (65535.0*    GetPseudoRandomValue(random_info)+0.5),range);  (void) SyncAuthenticPixels(image,exception);}

static inline void PlasmaPixel(Image *image,RandomInfo *random_info,double x,  double y,ExceptionInfo *exception){  register Quantum    *q;  q=GetAuthenticPixels(image,(ssize_t) ceil(x-0.5),(ssize_t) ceil(y-0.5),1,1,    exception);  if (q == (Quantum *) NULL)    return;  SetPixelRed(image,ScaleShortToQuantum((unsigned short) (65535.0*    GetPseudoRandomValue(random_info)+0.5)),q);  SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (65535.0*    GetPseudoRandomValue(random_info)+0.5)),q);  SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (65535.0*    GetPseudoRandomValue(random_info)+0.5)),q);  (void) SyncAuthenticPixels(image,exception);}

TCAX_PyPix pixmagick_convert_py_image(PyObject *self, PyObject *args) {    PyObject *pyArg1;    Image *pImage;    TCAX_Pix pix;    PixelPacket *buf;    int i, index, count;    if (PyTuple_GET_SIZE(args) < 1) {        PyErr_SetString(PyExc_RuntimeError, "pmgToPix error, too less parameters - `(image)'/n");        return NULL;    }    pyArg1 = PyTuple_GET_ITEM(args, 0);    if (!PyLong_Check(pyArg1)) {        PyErr_SetString(PyExc_RuntimeError, "pmgToPix error, the 1st param should be an integer - `img'/n");        return NULL;    }    pImage = (Image *)PyLong_AsUnsignedLong(pyArg1);    if (!IsImageObject(pImage)) {        PyErr_SetString(PyExc_RuntimeError, "pmgToPix error, the parameter specified by `img' is not a valid image/n");        return NULL;    }    pix.initX = 0;    pix.initY = 0;    pix.width = pImage->columns;    pix.height = pImage->rows;    pix.size = pix.height * (pix.width << 2);    pix.buf = (unsigned char *)malloc(pix.size * sizeof(unsigned char));    buf = GetAuthenticPixels(pImage, 0, 0, pImage->columns, pImage->rows, NULL);    count = pImage->columns * pImage->rows;    index = 0;    for (i = 0; i < count; i++) {        pix.buf[index++] = buf[i].red;        pix.buf[index++] = buf[i].green;        pix.buf[index++] = buf[i].blue;        pix.buf[index++] = 255 - buf[i].opacity;    }    return tcaxlib_convert_pix(&pix, 1);}

//.........这里部分代码省略.........    status;  QuantumAny    range;  register long    i;  register PixelPacket    *q;  ssize_t    count;  unsigned long    depth,    max_value;  /*    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);    }  (void) ResetMagickMemory(text,0,sizeof(text));  (void) ReadBlobString(image,text);  if (LocaleNCompare((char *) text,MagickID,strlen(MagickID)) != 0)    return(ReadTEXTImage(image_info,image,text,exception));  *colorspace='/0';  count=(ssize_t) sscanf(text+32,"%lu,%lu,%lu,%s",&image->columns,    &image->rows,&max_value,colorspace);  if (count != 4)    ThrowReaderException(CorruptImageError,"ImproperImageHeader");  for (depth=1; (GetQuantumRange(depth)+1) < max_value; depth++) ;  image->depth=depth;  LocaleLower(colorspace);  i=(long) strlen(colorspace)-1;  image->matte=MagickFalse;  if ((i > 0) && (colorspace[i] == 'a'))    {      colorspace[i]='/0';      image->matte=MagickTrue;    }  type=ParseMagickOption(MagickColorspaceOptions,MagickFalse,colorspace);  if (type < 0)    ThrowReaderException(CorruptImageError,"ImproperImageHeader");  image->colorspace=(ColorspaceType) type;  (void) ResetMagickMemory(&pixel,0,sizeof(pixel));  (void) SetImageBackgroundColor(image);  range=GetQuantumRange(image->depth);  while (ReadBlobString(image,text) != (char *) NULL)  {    if (image->colorspace == CMYKColorspace)      {        if (image->matte != MagickFalse)          count=(ssize_t) sscanf(text,"%ld,%ld: (%lu,%lu,%lu,%lu,%lu",&x,&y,            &pixel.red,&pixel.green,&pixel.blue,&pixel.index,&pixel.opacity);        else          count=(ssize_t) sscanf(text,"%ld,%ld: (%lu,%lu,%lu,%lu",&x,&y,            &pixel.red,&pixel.green,&pixel.blue,&pixel.index);      }    else      if (image->matte != MagickFalse)        count=(ssize_t) sscanf(text,"%ld,%ld: (%lu,%lu,%lu,%lu",&x,&y,          &pixel.red,&pixel.green,&pixel.blue,&pixel.opacity);      else        count=(ssize_t) sscanf(text,"%ld,%ld: (%lu,%lu,%lu",&x,&y,          &pixel.red,&pixel.green,&pixel.blue);    if (count < 5)      continue;    q=GetAuthenticPixels(image,x,y,1,1,exception);    if (q == (PixelPacket *) NULL)      continue;    q->red=ScaleAnyToQuantum(pixel.red,range);    q->green=ScaleAnyToQuantum(pixel.green,range);    q->blue=ScaleAnyToQuantum(pixel.blue,range);    if (image->colorspace == CMYKColorspace)      {        indexes=GetAuthenticIndexQueue(image);        *indexes=ScaleAnyToQuantum(pixel.index,range);      }    if (image->matte != MagickFalse)      q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel.opacity,        range));    if (SyncAuthenticPixels(image,exception) == MagickFalse)      break;  }  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........            if (image->matte != MagickFalse)              {                count=(ssize_t) sscanf(text,"%ld,%ld: (%lf%*[%,]%lf%*[%,]",                  &x_offset,&y_offset,&red,&opacity);                green=red;                blue=red;                break;              }            count=(ssize_t) sscanf(text,"%ld,%ld: (%lf%*[%,]",&x_offset,              &y_offset,&red);            green=red;            blue=red;            break;          }          case CMYKColorspace:          {            if (image->matte != MagickFalse)              {                count=(ssize_t) sscanf(text,                  "%ld,%ld: (%lf%*[%,]%lf%*[%,]%lf%*[%,]%lf%*[%,]%lf%*[%,]",                  &x_offset,&y_offset,&red,&green,&blue,&index,&opacity);                break;              }            count=(ssize_t) sscanf(text,              "%ld,%ld: (%lf%*[%,]%lf%*[%,]%lf%*[%,]%lf%*[%,]",&x_offset,              &y_offset,&red,&green,&blue,&index);            break;          }          default:          {            if (image->matte != MagickFalse)              {                count=(ssize_t) sscanf(text,                  "%ld,%ld: (%lf%*[%,]%lf%*[%,]%lf%*[%,]%lf%*[%,]",                  &x_offset,&y_offset,&red,&green,&blue,&opacity);                break;              }            count=(ssize_t) sscanf(text,              "%ld,%ld: (%lf%*[%,]%lf%*[%,]%lf%*[%,]",&x_offset,&y_offset,               &red,&green,&blue);            break;          }        }        if (strchr(text,'%') != (char *) NULL)          {            red*=0.01*range;            green*=0.01*range;            blue*=0.01*range;            index*=0.01*range;            opacity*=0.01*range;          }        if (image->colorspace == LabColorspace)          {            green+=(range+1)/2.0;            blue+=(range+1)/2.0;          }        pixel.red=ScaleAnyToQuantum((QuantumAny) (red+0.5),range);        pixel.green=ScaleAnyToQuantum((QuantumAny) (green+0.5),range);        pixel.blue=ScaleAnyToQuantum((QuantumAny) (blue+0.5),range);        pixel.index=ScaleAnyToQuantum((QuantumAny) (index+0.5),range);        pixel.opacity=ScaleAnyToQuantum((QuantumAny) (opacity+0.5),range);        q=GetAuthenticPixels(image,x_offset,y_offset,1,1,exception);        if (q == (PixelPacket *) NULL)          continue;        SetPixelRed(q,pixel.red);        SetPixelGreen(q,pixel.green);        SetPixelBlue(q,pixel.blue);        if (image->colorspace == CMYKColorspace)          {            indexes=GetAuthenticIndexQueue(image);            SetPixelIndex(indexes,pixel.index);          }        if (image->matte != MagickFalse)          SetPixelAlpha(q,pixel.opacity);        if (SyncAuthenticPixels(image,exception) == MagickFalse)          break;      }    }    (void) ReadBlobString(image,text);    if (LocaleNCompare((char *) text,MagickID,strlen(MagickID)) == 0)      {        /*          Allocate next image structure.        */        AcquireNextImage(image_info,image);        if (GetNextImageInList(image) == (Image *) NULL)          {            image=DestroyImageList(image);            return((Image *) NULL);          }        image=SyncNextImageInList(image);        status=SetImageProgress(image,LoadImagesTag,TellBlob(image),          GetBlobSize(image));        if (status == MagickFalse)          break;      }  } while (LocaleNCompare((char *) text,MagickID,strlen(MagickID)) == 0);  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

static Image *ReadSTEGANOImage(const ImageInfo *image_info,  ExceptionInfo *exception){#define GetBit(alpha,i) MagickMin((((unsigned long) (alpha) >> (unsigned long) /  (i)) & 0x01),16)#define SetBit(alpha,i,set) (alpha)=(IndexPacket) ((set) != 0 ? /  (unsigned long) (alpha) | (1UL << (unsigned long) (i)) : (unsigned long) /  (alpha) & ~(1UL << (unsigned long) (i)))  Image    *image,    *watermark;  ImageInfo    *read_info;  long    c,    i,    j,    k,    y;  MagickBooleanType    status;  PixelPacket    pixel;  register IndexPacket    *indexes;  register long    x;  register PixelPacket    *q;  unsigned long    depth;  /*    Initialize Image structure.  */  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);  if ((image->columns == 0) || (image->rows == 0))    ThrowReaderException(OptionError,"MustSpecifyImageSize");  read_info=CloneImageInfo(image_info);  SetImageInfoBlob(read_info,(void *) NULL,0);  *read_info->magick='/0';  watermark=ReadImage(read_info,exception);  read_info=DestroyImageInfo(read_info);  if (watermark == (Image *) NULL)    return((Image *) NULL);  watermark->depth=MAGICKCORE_QUANTUM_DEPTH;  if (AcquireImageColormap(image,MaxColormapSize) == MagickFalse)    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  if (image_info->ping != MagickFalse)    {      (void) CloseBlob(image);      return(GetFirstImageInList(image));    }  /*    Get hidden watermark from low-order bits of image.  */  c=0;  i=0;  j=0;  i=MAGICKCORE_QUANTUM_DEPTH-1;  depth=MAGICKCORE_QUANTUM_DEPTH;  for (k=image->offset; (i >= 0) && (j < (long) depth); i--)  {    for (y=0; (y < (long) image->rows) && (j < (long) depth); y++)    {      x=0;      for (; (x < (long) image->columns) && (j < (long) depth); x++)      {        if ((k/(long) watermark->columns) >= (long) watermark->rows)          break;        (void) GetOneVirtualPixel(watermark,k % (long) watermark->columns,          k/(long) watermark->columns,&pixel,exception);        q=GetAuthenticPixels(image,x,y,1,1,exception);        if (q == (PixelPacket *) NULL)          break;        indexes=GetAuthenticIndexQueue(image);        switch (c)        {          case 0:          {            SetBit(*indexes,i,GetBit(pixel.red,j));            break;          }          case 1://.........这里部分代码省略.........

static MagickBooleanType load_tile_rle(Image *image,Image *tile_image,  XCFDocInfo *inDocInfo,XCFLayerInfo *inLayerInfo,size_t data_length){  ExceptionInfo    *exception;  ssize_t    i,    j;  MagickOffsetType    size;  register PixelPacket    *q;  ssize_t    bytes_per_pixel,    count;  size_t    length;  unsigned char    data,    pixel,    *xcfdata,    *xcfodata,    *xcfdatalimit;  bytes_per_pixel=(ssize_t) inDocInfo->bytes_per_pixel;  xcfdata=(unsigned char *) AcquireQuantumMemory(data_length,sizeof(*xcfdata));  if (xcfdata == (unsigned char *) NULL)    ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",      image->filename);  xcfodata=xcfdata;  count=ReadBlob(image, (size_t) data_length, xcfdata);  xcfdatalimit = xcfodata+count-1;  exception=(&image->exception);  for (i=0; i < (ssize_t) bytes_per_pixel; i++)  {    q=GetAuthenticPixels(tile_image,0,0,tile_image->columns,tile_image->rows,      exception);    size=(MagickOffsetType) tile_image->rows*tile_image->columns;    while (size > 0)    {      if (xcfdata > xcfdatalimit)        goto bogus_rle;      pixel=(*xcfdata++);      length=(size_t) pixel;      if (length >= 128)        {          length=255-(length-1);          if (length == 128)            {              if (xcfdata >= xcfdatalimit)                goto bogus_rle;              length=(size_t) ((*xcfdata << 8) + xcfdata[1]);              xcfdata+=2;            }            size-=length;            if (size < 0)              goto bogus_rle;            if (&xcfdata[length-1] > xcfdatalimit)              goto bogus_rle;            while (length-- > 0)            {              data=(*xcfdata++);              switch (i)              {                case 0:                {                  q->red=ScaleCharToQuantum(data);                  if (inDocInfo->image_type == GIMP_GRAY)                    {                      q->green=ScaleCharToQuantum(data);                      q->blue=ScaleCharToQuantum(data);                      q->opacity=ScaleCharToQuantum((unsigned char) (255-                        inLayerInfo->opacity));                    }                  else                    {                      q->green= q->red;                      q->blue= q->red;                      q->opacity=ScaleCharToQuantum((unsigned char) (255-                        inLayerInfo->opacity));                    }                  break;                }                case 1:                {                  q->green=ScaleCharToQuantum(data);                  break;                }                case 2:                {                  q->blue=ScaleCharToQuantum(data);                  break;                }                case 3://.........这里部分代码省略.........

static Image *ReadSTEGANOImage(const ImageInfo *image_info,  ExceptionInfo *exception){#define GetBit(alpha,i) MagickMin((((size_t) (alpha) >> (size_t) /  (i)) & 0x01),16)#define SetBit(i,set) SetPixelIndex(image,((set) != 0 ? /  (size_t) GetPixelIndex(image,q) | (one << (size_t) (i)) : /  (size_t) GetPixelIndex(image,q) & ~(one << (size_t) (i))),q)  Image    *image,    *watermark;  ImageInfo    *read_info;  int    c;  MagickBooleanType    status;  PixelInfo    pixel;  register Quantum    *q;  register ssize_t    x;  size_t    depth,    one;  ssize_t    i,    j,    k,    y;  /*    Initialize Image structure.  */  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);  one=1;  image=AcquireImage(image_info,exception);  if ((image->columns == 0) || (image->rows == 0))    ThrowReaderException(OptionError,"MustSpecifyImageSize");  read_info=CloneImageInfo(image_info);  SetImageInfoBlob(read_info,(void *) NULL,0);  *read_info->magick='/0';  watermark=ReadImage(read_info,exception);  read_info=DestroyImageInfo(read_info);  if (watermark == (Image *) NULL)    return((Image *) NULL);  watermark->depth=MAGICKCORE_QUANTUM_DEPTH;  if (AcquireImageColormap(image,MaxColormapSize,exception) == MagickFalse)    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  if (image_info->ping != MagickFalse)    {      (void) CloseBlob(image);      return(GetFirstImageInList(image));    }  /*    Get hidden watermark from low-order bits of image.  */  c=0;  i=0;  j=0;  i=(ssize_t) (watermark->depth-1);  depth=watermark->depth;  for (k=image->offset; (i >= 0) && (j < (ssize_t) depth); i--)  {    for (y=0; (y < (ssize_t) image->rows) && (j < (ssize_t) depth); y++)    {      x=0;      for ( ; (x < (ssize_t) image->columns) && (j < (ssize_t) depth); x++)      {        if ((k/(ssize_t) watermark->columns) >= (ssize_t) watermark->rows)          break;        (void) GetOneVirtualPixelInfo(watermark,UndefinedVirtualPixelMethod,          k % (ssize_t) watermark->columns,k/(ssize_t) watermark->columns,          &pixel,exception);        q=GetAuthenticPixels(image,x,y,1,1,exception);        if (q == (Quantum *) NULL)          break;        switch (c)        {          case 0:          {            SetBit(i,GetBit(pixel.red,j));            break;          }//.........这里部分代码省略.........

//.........这里部分代码省略.........  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));}

static MagickBooleanType load_tile(Image *image,Image *tile_image,  XCFDocInfo *inDocInfo,XCFLayerInfo *inLayerInfo,size_t data_length,  ExceptionInfo *exception){  ssize_t    y;  register ssize_t    x;  register Quantum    *q;  size_t    extent;  ssize_t    count;  unsigned char    *graydata;  XCFPixelInfo    *xcfdata,    *xcfodata;  extent=0;  if (inDocInfo->image_type == GIMP_GRAY)    extent=tile_image->columns*tile_image->rows*sizeof(*graydata);  else    if (inDocInfo->image_type == GIMP_RGB)      extent=tile_image->columns*tile_image->rows*sizeof(*xcfdata);  if (extent > data_length)    ThrowBinaryException(CorruptImageError,"NotEnoughPixelData",      image->filename);  xcfdata=(XCFPixelInfo *) AcquireQuantumMemory(MagickMax(data_length,    tile_image->columns*tile_image->rows),sizeof(*xcfdata));  if (xcfdata == (XCFPixelInfo *) NULL)    ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",      image->filename);  xcfodata=xcfdata;  graydata=(unsigned char *) xcfdata;  /* used by gray and indexed */  count=ReadBlob(image,data_length,(unsigned char *) xcfdata);  if (count != (ssize_t) data_length)    ThrowBinaryException(CorruptImageError,"NotEnoughPixelData",      image->filename);  for (y=0; y < (ssize_t) tile_image->rows; y++)  {    q=GetAuthenticPixels(tile_image,0,y,tile_image->columns,1,exception);    if (q == (Quantum *) NULL)      break;    if (inDocInfo->image_type == GIMP_GRAY)      {        for (x=0; x < (ssize_t) tile_image->columns; x++)        {          SetPixelGray(tile_image,ScaleCharToQuantum(*graydata),q);          SetPixelAlpha(tile_image,ScaleCharToQuantum((unsigned char)            inLayerInfo->alpha),q);          graydata++;          q+=GetPixelChannels(tile_image);        }      }    else      if (inDocInfo->image_type == GIMP_RGB)        {          for (x=0; x < (ssize_t) tile_image->columns; x++)          {            SetPixelRed(tile_image,ScaleCharToQuantum(xcfdata->red),q);            SetPixelGreen(tile_image,ScaleCharToQuantum(xcfdata->green),q);            SetPixelBlue(tile_image,ScaleCharToQuantum(xcfdata->blue),q);            SetPixelAlpha(tile_image,xcfdata->alpha == 255U ? TransparentAlpha :              ScaleCharToQuantum((unsigned char) inLayerInfo->alpha),q);            xcfdata++;            q+=GetPixelChannels(tile_image);          }        }     if (SyncAuthenticPixels(tile_image,exception) == MagickFalse)       break;  }  xcfodata=(XCFPixelInfo *) RelinquishMagickMemory(xcfodata);  return MagickTrue;}

//.........这里部分代码省略.........  else    {      image->columns-=2*page.x;      pango_layout_set_width(layout,(int) ((PANGO_SCALE*image->columns*        (image->resolution.x == 0.0 ? 90.0 : image->resolution.x)+45.0)/90.0+        0.5));    }  if (image->rows == 0)    {      pango_layout_get_extents(layout,NULL,&extent);      image->rows=(extent.y+extent.height+PANGO_SCALE/2)/PANGO_SCALE+2*page.y;    }  else    {      image->rows-=2*page.y;      pango_layout_set_height(layout,(int) ((PANGO_SCALE*image->rows*        (image->resolution.y == 0.0 ? 90.0 : image->resolution.y)+45.0)/90.0+        0.5));    }  /*    Render markup.  */  stride=(size_t) cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32,    image->columns);  pixels=(unsigned char *) AcquireQuantumMemory(image->rows,stride*    sizeof(*pixels));  if (pixels == (unsigned char *) NULL)    {      draw_info=DestroyDrawInfo(draw_info);      caption=DestroyString(caption);      ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");    }  surface=cairo_image_surface_create_for_data(pixels,CAIRO_FORMAT_ARGB32,    image->columns,image->rows,stride);  cairo_image=cairo_create(surface);  cairo_set_operator(cairo_image,CAIRO_OPERATOR_CLEAR);  cairo_paint(cairo_image);  cairo_set_operator(cairo_image,CAIRO_OPERATOR_OVER);  cairo_translate(cairo_image,page.x,page.y);  pango_cairo_show_layout(cairo_image,layout);  cairo_destroy(cairo_image);  cairo_surface_destroy(surface);  g_object_unref(layout);  g_object_unref(fontmap);  /*    Convert surface to image.  */  (void) SetImageBackgroundColor(image,exception);  p=pixels;  GetPixelInfo(image,&fill_color);  for (y=0; y < (ssize_t) image->rows; y++)  {    register Quantum      *q;    register ssize_t      x;    q=GetAuthenticPixels(image,0,y,image->columns,1,exception);    if (q == (Quantum *) NULL)      break;    for (x=0; x < (ssize_t) image->columns; x++)    {      double        gamma;      fill_color.blue=(double) ScaleCharToQuantum(*p++);      fill_color.green=(double) ScaleCharToQuantum(*p++);      fill_color.red=(double) ScaleCharToQuantum(*p++);      fill_color.alpha=(double) ScaleCharToQuantum(*p++);      /*        Disassociate alpha.      */      gamma=1.0-QuantumScale*fill_color.alpha;      gamma=PerceptibleReciprocal(gamma);      fill_color.blue*=gamma;      fill_color.green*=gamma;      fill_color.red*=gamma;      CompositePixelOver(image,&fill_color,fill_color.alpha,q,(double)        GetPixelAlpha(image,q),q);      q+=GetPixelChannels(image);    }    if (SyncAuthenticPixels(image,exception) == MagickFalse)      break;    if (image->previous == (Image *) NULL)      {        status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,        image->rows);        if (status == MagickFalse)          break;      }  }  /*    Relinquish resources.  */  pixels=(unsigned char *) RelinquishMagickMemory(pixels);  draw_info=DestroyDrawInfo(draw_info);  caption=DestroyString(caption);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........  count=0;  length=0;  scene=0;  do  {    /*      Read pixels to virtual canvas image then push to image.    */    if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))      if (image->scene >= (image_info->scene+image_info->number_scenes-1))        break;    SetImageColorspace(image,YCbCrColorspace);    switch (image_info->interlace)    {      case NoInterlace:      default:      {        /*          No interlacing:  YCbCrYCbCrYCbCrYCbCrYCbCrYCbCr...        */        if (scene == 0)          {            length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);            count=ReadBlob(image,length,pixels);          }        for (y=0; y < (ssize_t) image->extract_info.height; y++)        {          if (count != (ssize_t) length)            {              ThrowFileException(exception,CorruptImageError,                "UnexpectedEndOfFile",image->filename);              break;            }          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,            exception);          if (q == (PixelPacket *) NULL)            break;          length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,            quantum_info,quantum_type,pixels,exception);          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)            break;          if (((y-image->extract_info.y) >= 0) &&               ((y-image->extract_info.y) < (ssize_t) image->rows))            {              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,                canvas_image->columns,1,exception);              q=QueueAuthenticPixels(image,0,y-image->extract_info.y,                image->columns,1,exception);              if ((p == (const PixelPacket *) NULL) ||                  (q == (PixelPacket *) NULL))                break;              for (x=0; x < (ssize_t) image->columns; x++)              {                SetPixelRed(q,GetPixelRed(p));                SetPixelGreen(q,GetPixelGreen(p));                SetPixelBlue(q,GetPixelBlue(p));                if (image->matte != MagickFalse)                  SetPixelOpacity(q,GetPixelOpacity(p));                p++;                q++;              }              if (SyncAuthenticPixels(image,exception) == MagickFalse)                break;            }          if (image->previous == (Image *) NULL)            {

//.........这里部分代码省略.........  }  /*    Convert JPEG 2000 pixels.  */  image->alpha_trait=number_components > 3 ? BlendPixelTrait :    UndefinedPixelTrait;  maximum_component_depth=0;  for (i=0; i < (ssize_t) number_components; i++)  {    maximum_component_depth=(unsigned int) MagickMax((size_t)      jas_image_cmptprec(jp2_image,components[i]),(size_t)      maximum_component_depth);    pixels[i]=jas_matrix_create(1,(int) (image->columns/x_step[i]));    if (pixels[i] == (jas_matrix_t *) NULL)      {        for (--i; i >= 0; i--)          jas_matrix_destroy(pixels[i]);        jas_image_destroy(jp2_image);        ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");      }  }  image->depth=maximum_component_depth;  if (image_info->ping != MagickFalse)    {      (void) jas_stream_close(jp2_stream);      jas_image_destroy(jp2_image);      return(GetFirstImageInList(image));    }  for (i=0; i < (ssize_t) number_components; i++)    range[i]=GetQuantumRange((size_t) jas_image_cmptprec(jp2_image,      components[i]));  for (y=0; y < (ssize_t) image->rows; y++)  {    q=GetAuthenticPixels(image,0,y,image->columns,1,exception);    if (q == (Quantum *) NULL)      break;    for (i=0; i < (ssize_t) number_components; i++)      (void) jas_image_readcmpt(jp2_image,(short) components[i],0,        (jas_image_coord_t) (y/y_step[i]),(jas_image_coord_t) (image->columns/        x_step[i]),1,pixels[i]);    switch (number_components)    {      case 1:      {        /*          Grayscale.        */        for (x=0; x < (ssize_t) image->columns; x++)        {          pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);          SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) pixel,range[0]),q);          q+=GetPixelChannels(image);        }        break;      }      case 3:      {        /*          RGB.        */        for (x=0; x < (ssize_t) image->columns; x++)        {          pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);          SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) pixel,range[0]),q);          pixel=(QuantumAny) jas_matrix_getv(pixels[1],x/x_step[1]);          SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) pixel,range[1]),q);

//.........这里部分代码省略.........    if (p == (const PixelPacket *) NULL)      break;    for (x=0; x < (long) image->columns; x++)    {      if ((channel & RedChannel) != 0)        histogram[ScaleQuantumToChar(p->red)].red++;      if ((channel & GreenChannel) != 0)        histogram[ScaleQuantumToChar(p->green)].green++;      if ((channel & BlueChannel) != 0)        histogram[ScaleQuantumToChar(p->blue)].blue++;      p++;    }  }  maximum=histogram[0].red;  for (x=0; x < (long) histogram_image->columns; x++)  {    if (((channel & RedChannel) != 0) && (maximum < histogram[x].red))      maximum=histogram[x].red;    if (((channel & GreenChannel) != 0) && (maximum < histogram[x].green))      maximum=histogram[x].green;    if (((channel & BlueChannel) != 0) && (maximum < histogram[x].blue))      maximum=histogram[x].blue;  }  scale=(MagickRealType) histogram_image->rows/maximum;  /*    Initialize histogram image.  */  exception=(&image->exception);  (void) QueryColorDatabase("#000000",&histogram_image->background_color,    &image->exception);  (void) SetImageBackgroundColor(histogram_image);  for (x=0; x < (long) histogram_image->columns; x++)  {    q=GetAuthenticPixels(histogram_image,x,0,1,histogram_image->rows,exception);    if (q == (PixelPacket *) NULL)      break;    if ((channel & RedChannel) != 0)      {        y=(long) (histogram_image->rows-scale*histogram[x].red+0.5);        r=q+y;        for ( ; y < (long) histogram_image->rows; y++)        {          r->red=(Quantum) QuantumRange;          r++;        }      }    if ((channel & GreenChannel) != 0)      {        y=(long) (histogram_image->rows-scale*histogram[x].green+0.5);        r=q+y;        for ( ; y < (long) histogram_image->rows; y++)        {          r->green=(Quantum) QuantumRange;          r++;        }      }    if ((channel & BlueChannel) != 0)      {        y=(long) (histogram_image->rows-scale*histogram[x].blue+0.5);        r=q+y;        for ( ; y < (long) histogram_image->rows; y++)        {          r->blue=(Quantum) QuantumRange;          r++;        }      }

//.........这里部分代码省略.........        jas_image_destroy(jp2_image);        ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");      }  }  image->depth=maximum_component_depth;  if (image_info->ping != MagickFalse)    {      (void) jas_stream_close(jp2_stream);      jas_image_destroy(jp2_image);      return(GetFirstImageInList(image));    }  for (i=0; i < (long) number_components; i++)  {    long      j;    map[i]=(QuantumAny *) AcquireQuantumMemory(MaxMap+1,sizeof(**map));    if (map[i] == (QuantumAny *) NULL)      {        for (--i; i >= 0; i--)          map[i]=(QuantumAny *) RelinquishMagickMemory(map[i]);        for (i=0; i < (long) number_components; i++)          jas_matrix_destroy(pixels[i]);        jas_image_destroy(jp2_image);        ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");      }    range=GetQuantumRange((unsigned long) jas_image_cmptprec(jp2_image,      components[i]));    for (j=0; j <= (long) MaxMap; j++)      map[i][j]=ScaleQuantumToMap(ScaleAnyToQuantum((QuantumAny) j,range));  }  for (y=0; y < (long) image->rows; y++)  {    q=GetAuthenticPixels(image,0,y,image->columns,1,exception);    if (q == (PixelPacket *) NULL)      break;    for (i=0; i < (long) number_components; i++)      (void) jas_image_readcmpt(jp2_image,(short) components[i],0,        ((unsigned int) y)/y_step[i],((unsigned int) image->columns)/x_step[i],        1,pixels[i]);    switch (number_components)    {      case 1:      {        /*          Grayscale.        */        for (x=0; x < (long) image->columns; x++)        {          pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);          q->red=(Quantum) map[0][pixel];          q->green=q->red;          q->blue=q->red;          q++;        }        break;      }      case 3:      {        /*          RGB.        */        for (x=0; x < (long) image->columns; x++)        {          pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);          q->red=(Quantum) map[0][pixel];

//.........这里部分代码省略.........    */    if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))      if (image->scene >= (image_info->scene+image_info->number_scenes-1))        break;    status=SetImageExtent(image,image->columns,image->rows);    if (status == MagickFalse)      {        InheritException(exception,&image->exception);        return(DestroyImageList(image));      }    if (scene == 0)      {        length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);        pixels=(const unsigned char *) ReadBlobStream(image,length,          GetQuantumPixels(quantum_info),&count);      }    for (y=0; y < (ssize_t) image->extract_info.height; y++)    {      register const PixelPacket        *magick_restrict p;      register PixelPacket        *magick_restrict q;      register ssize_t        x;      if (count != (ssize_t) length)        {          ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",            image->filename);          break;        }      q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,exception);      if (q == (PixelPacket *) NULL)        break;      length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,quantum_info,        quantum_type,pixels,exception);      if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)        break;      if (((y-image->extract_info.y) >= 0) &&          ((y-image->extract_info.y) < (ssize_t) image->rows))        {          p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,            image->columns,1,exception);          q=QueueAuthenticPixels(image,0,y-image->extract_info.y,image->columns,            1,exception);          if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))            break;          for (x=0; x < (ssize_t) image->columns; x++)          {            SetPixelRed(q,GetPixelRed(p));            SetPixelGreen(q,GetPixelGreen(p));            SetPixelBlue(q,GetPixelBlue(p));            p++;            q++;          }          if (SyncAuthenticPixels(image,exception) == MagickFalse)            break;        }      if (image->previous == (Image *) NULL)        {          status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,            image->rows);          if (status == MagickFalse)            break;

static MagickBooleanType load_tile_rle(Image *image,Image *tile_image,  XCFDocInfo *inDocInfo,XCFLayerInfo *inLayerInfo,size_t data_length,  ExceptionInfo *exception){  MagickOffsetType    size;  Quantum    alpha;  register Quantum    *q;  size_t    length;  ssize_t    bytes_per_pixel,    count,    i,    j;  unsigned char    data,    pixel,    *xcfdata,    *xcfodata,    *xcfdatalimit;  bytes_per_pixel=(ssize_t) inDocInfo->bytes_per_pixel;  xcfdata=(unsigned char *) AcquireQuantumMemory(data_length,sizeof(*xcfdata));  if (xcfdata == (unsigned char *) NULL)    ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",      image->filename);  xcfodata=xcfdata;  count=ReadBlob(image, (size_t) data_length, xcfdata);  xcfdatalimit = xcfodata+count-1;  alpha=ScaleCharToQuantum((unsigned char) inLayerInfo->alpha);  for (i=0; i < (ssize_t) bytes_per_pixel; i++)  {    q=GetAuthenticPixels(tile_image,0,0,tile_image->columns,tile_image->rows,      exception);    if (q == (Quantum *) NULL)      continue;    size=(MagickOffsetType) tile_image->rows*tile_image->columns;    while (size > 0)    {      if (xcfdata > xcfdatalimit)        goto bogus_rle;      pixel=(*xcfdata++);      length=(size_t) pixel;      if (length >= 128)        {          length=255-(length-1);          if (length == 128)            {              if (xcfdata >= xcfdatalimit)                goto bogus_rle;              length=(size_t) ((*xcfdata << 8) + xcfdata[1]);              xcfdata+=2;            }          size-=length;          if (size < 0)            goto bogus_rle;          if (&xcfdata[length-1] > xcfdatalimit)            goto bogus_rle;          while (length-- > 0)          {            data=(*xcfdata++);            switch (i)            {              case 0:              {                if (inDocInfo->image_type == GIMP_GRAY)                  SetPixelGray(tile_image,ScaleCharToQuantum(data),q);                else                  {                    SetPixelRed(tile_image,ScaleCharToQuantum(data),q);                    SetPixelGreen(tile_image,ScaleCharToQuantum(data),q);                    SetPixelBlue(tile_image,ScaleCharToQuantum(data),q);                  }                SetPixelAlpha(tile_image,alpha,q);                break;              }              case 1:              {                if (inDocInfo->image_type == GIMP_GRAY)                  SetPixelAlpha(tile_image,ScaleCharToQuantum(data),q);                else                  SetPixelGreen(tile_image,ScaleCharToQuantum(data),q);                break;              }              case 2:              {                SetPixelBlue(tile_image,ScaleCharToQuantum(data),q);                break;              }              case 3:              {                SetPixelAlpha(tile_image,ScaleCharToQuantum(data),q);//.........这里部分代码省略.........

static Image *ReadPlasmaImage(const ImageInfo *image_info,  ExceptionInfo *exception){  Image    *image;  ImageInfo    *read_info;  ssize_t    y;  MagickBooleanType    status;  register ssize_t    x;  register PixelPacket    *q;  register size_t    i;  SegmentInfo    segment_info;  size_t    depth,    max_depth;  /*    Recursively apply plasma to the image.  */  read_info=CloneImageInfo(image_info);  SetImageInfoBlob(read_info,(void *) NULL,0);  (void) FormatMagickString(read_info->filename,MaxTextExtent,    "gradient:%s",image_info->filename);  image=ReadImage(read_info,exception);  read_info=DestroyImageInfo(read_info);  if (image == (Image *) NULL)    return((Image *) NULL);  image->storage_class=DirectClass;  for (y=0; y < (ssize_t) image->rows; y++)  {    q=GetAuthenticPixels(image,0,y,image->columns,1,exception);    if (q == (PixelPacket *) NULL)      break;    for (x=0; x < (ssize_t) image->columns; x++)    {      q->opacity=(Quantum) (QuantumRange/2);      q++;    }    if (SyncAuthenticPixels(image,exception) == MagickFalse)      break;  }  segment_info.x1=0;  segment_info.y1=0;  segment_info.x2=(double) image->columns-1;  segment_info.y2=(double) image->rows-1;  if (LocaleCompare(image_info->filename,"fractal") == 0)    {      RandomInfo        *random_info;      /*        Seed pixels before recursion.      */      random_info=AcquireRandomInfo();      PlasmaPixel(image,random_info,segment_info.x1,segment_info.y1);      PlasmaPixel(image,random_info,segment_info.x1,(segment_info.y1+        segment_info.y2)/2);      PlasmaPixel(image,random_info,segment_info.x1,segment_info.y2);      PlasmaPixel(image,random_info,(segment_info.x1+segment_info.x2)/2,        segment_info.y1);      PlasmaPixel(image,random_info,(segment_info.x1+segment_info.x2)/2,        (segment_info.y1+segment_info.y2)/2);      PlasmaPixel(image,random_info,(segment_info.x1+segment_info.x2)/2,        segment_info.y2);      PlasmaPixel(image,random_info,segment_info.x2,segment_info.y1);      PlasmaPixel(image,random_info,segment_info.x2,(segment_info.y1+        segment_info.y2)/2);      PlasmaPixel(image,random_info,segment_info.x2,segment_info.y2);      random_info=DestroyRandomInfo(random_info);    }  i=(size_t) MagickMax(image->columns,image->rows)/2;  for (max_depth=0; i != 0; max_depth++)    i>>=1;  for (depth=1; ; depth++)  {    if (PlasmaImage(image,&segment_info,0,depth) != MagickFalse)      break;    status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) depth,      max_depth);    if (status == MagickFalse)      break;  }  (void) SetImageAlphaChannel(image,DeactivateAlphaChannel);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  if (*rla_info.description != '/0')    (void) SetImageProperty(image,"comment",rla_info.description,exception);  /*    Read offsets to each scanline data.  */  for (i=0; i < (ssize_t) image->rows; i++)    scanlines[i]=(MagickOffsetType) ReadBlobMSBSignedLong(image);  /*    Read image data.  */  x=0;  for (y=0; y < (ssize_t) image->rows; y++)  {    offset=SeekBlob(image,scanlines[image->rows-y-1],SEEK_SET);    if (offset < 0)      ThrowReaderException(CorruptImageError,"ImproperImageHeader");    for (channel=0; channel < (int) rla_info.number_channels; channel++)    {      length=ReadBlobMSBSignedShort(image);      while (length > 0)      {        byte=(unsigned char) ReadBlobByte(image);        runlength=byte;        if (byte > 127)          runlength=byte-256;        length--;        if (length == 0)          break;        if (runlength < 0)          {            while (runlength < 0)            {              q=GetAuthenticPixels(image,(ssize_t) (x % image->columns),                (ssize_t) (y % image->rows),1,1,exception);              if (q == (Quantum *) NULL)                break;              byte=(unsigned char) ReadBlobByte(image);              length--;              switch (channel)              {                case 0:                {                  SetPixelRed(image,ScaleCharToQuantum(byte),q);                  break;                }                case 1:                {                  SetPixelGreen(image,ScaleCharToQuantum(byte),q);                  break;                }                case 2:                {                  SetPixelBlue(image,ScaleCharToQuantum(byte),q);                  break;                }                case 3:                default:                {                  SetPixelAlpha(image,ScaleCharToQuantum(byte),q);                  break;                }              }              if (SyncAuthenticPixels(image,exception) == MagickFalse)                break;              x++;

//.........这里部分代码省略.........    /*    Write IPL header.  */  /* Shockingly (maybe not if you have used IPLab),  IPLab itself CANNOT read MSBEndian  files!   The reader above can, but they cannot.  For compatability reasons, I will leave  the code in here, but it is all but useless if you want to use IPLab. */  if(image_info->endian == MSBEndian)    (void) WriteBlob(image, 4, (const unsigned char *) "mmmm");  else{    image->endian = LSBEndian;    (void) WriteBlob(image, 4, (const unsigned char *) "iiii");  }  (void) WriteBlobLong(image, 4);  (void) WriteBlob(image, 4, (const unsigned char *) "100f");  (void) WriteBlob(image, 4, (const unsigned char *) "data");  (void) WriteBlobLong(image, ipl_info.size);  (void) WriteBlobLong(image, ipl_info.width);   (void) WriteBlobLong(image, ipl_info.height);  (void) WriteBlobLong(image, ipl_info.colors);  if(image_info->adjoin == MagickFalse)  (void) WriteBlobLong(image, 1);  else  (void) WriteBlobLong(image, ipl_info.z);  (void) WriteBlobLong(image, ipl_info.time);  (void) WriteBlobLong(image, ipl_info.byteType);    exception=(&image->exception);  do    {      /*  Convert MIFF to IPL raster pixels.      */      pixels=GetQuantumPixels(quantum_info);  if(ipl_info.colors == 1){  /* Red frame */  for(y = 0; y < (ssize_t) ipl_info.height; y++){    p=GetAuthenticPixels(image,0,y,image->columns,1,exception);    if (p == (PixelPacket *) NULL)      break;      (void) ExportQuantumPixels(image,(const CacheView *) NULL, quantum_info,        GrayQuantum, pixels,&image->exception);      (void) WriteBlob(image, image->columns*image->depth/8, pixels);  }}  if(ipl_info.colors == 3){  /* Red frame */  for(y = 0; y < (ssize_t) ipl_info.height; y++){    p=GetAuthenticPixels(image,0,y,image->columns,1,exception);    if (p == (PixelPacket *) NULL)      break;      (void) ExportQuantumPixels(image,(const CacheView *) NULL, quantum_info,        RedQuantum, pixels,&image->exception);      (void) WriteBlob(image, image->columns*image->depth/8, pixels);  }    /* Green frame */    for(y = 0; y < (ssize_t) ipl_info.height; y++){      p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);      if (p == (PixelPacket *) NULL)        break;        (void) ExportQuantumPixels(image,(const CacheView *) NULL, quantum_info,          GreenQuantum, pixels,&image->exception);        (void) WriteBlob(image, image->columns*image->depth/8, pixels);    }    /* Blue frame */    for(y = 0; y < (ssize_t) ipl_info.height; y++){      p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);      if (p == (PixelPacket *) NULL)        break;      (void) ExportQuantumPixels(image,(const CacheView *) NULL, quantum_info,        BlueQuantum, pixels,&image->exception);      (void) WriteBlob(image, image->columns*image->depth/8, pixels);      if (image->previous == (Image *) NULL)        {          status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,                image->rows);          if (status == MagickFalse)            break;        }    }  }  quantum_info=DestroyQuantumInfo(quantum_info);      if (GetNextImageInList(image) == (Image *) NULL)  break;      image=SyncNextImageInList(image);      status=SetImageProgress(image,SaveImagesTag,scene++,        GetImageListLength(image));      if (status == MagickFalse)        break;    }while (image_info->adjoin != MagickFalse);  (void) WriteBlob(image, 4, (const unsigned char *) "fini");  (void) WriteBlobLong(image, 0);CloseBlob(image);return(MagickTrue);}

//.........这里部分代码省略.........      if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)        histogram[ScaleQuantumToChar(GetPixelRed(image,p))].red++;      if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)        histogram[ScaleQuantumToChar(GetPixelGreen(image,p))].green++;      if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)        histogram[ScaleQuantumToChar(GetPixelBlue(image,p))].blue++;      p+=GetPixelChannels(image);    }  }  maximum=histogram[0].red;  for (x=0; x < (ssize_t) histogram_image->columns; x++)  {    if (((GetPixelRedTraits(image) & UpdatePixelTrait) != 0) &&        (maximum < histogram[x].red))      maximum=histogram[x].red;    if (((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0) &&        (maximum < histogram[x].green))      maximum=histogram[x].green;    if (((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0) &&        (maximum < histogram[x].blue))      maximum=histogram[x].blue;  }  scale=0.0;  if (fabs(maximum) >= MagickEpsilon)    scale=(double) histogram_image->rows/maximum;  /*    Initialize histogram image.  */  (void) QueryColorCompliance("#000000",AllCompliance,    &histogram_image->background_color,exception);  (void) SetImageBackgroundColor(histogram_image,exception);  for (x=0; x < (ssize_t) histogram_image->columns; x++)  {    q=GetAuthenticPixels(histogram_image,x,0,1,histogram_image->rows,exception);    if (q == (Quantum *) NULL)      break;    if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)      {        y=(ssize_t) ceil(histogram_image->rows-scale*histogram[x].red-0.5);        r=q+y*GetPixelChannels(histogram_image);        for ( ; y < (ssize_t) histogram_image->rows; y++)        {          SetPixelRed(histogram_image,QuantumRange,r);          r+=GetPixelChannels(histogram_image);        }      }    if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)      {        y=(ssize_t) ceil(histogram_image->rows-scale*histogram[x].green-0.5);        r=q+y*GetPixelChannels(histogram_image);        for ( ; y < (ssize_t) histogram_image->rows; y++)        {          SetPixelGreen(histogram_image,QuantumRange,r);          r+=GetPixelChannels(histogram_image);        }      }    if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)      {        y=(ssize_t) ceil(histogram_image->rows-scale*histogram[x].blue-0.5);        r=q+y*GetPixelChannels(histogram_image);        for ( ; y < (ssize_t) histogram_image->rows; y++)        {          SetPixelBlue(histogram_image,QuantumRange,r);          r+=GetPixelChannels(histogram_image);        }      }

//.........这里部分代码省略.........          if (q == (PixelPacket *) NULL)            break;          for (x=0; x < (ssize_t) chroma_image->columns; x++)          {            SetPixelRed(q,0);            if (quantum == 1)              SetPixelGreen(q,ScaleCharToQuantum(*p++));            else              {                SetPixelGreen(q,ScaleShortToQuantum(((*p) << 8) | *(p+1)));                p+=2;              }            SetPixelBlue(q,0);            q++;          }          if (SyncAuthenticPixels(chroma_image,exception) == MagickFalse)            break;        }      if (interlace == PartitionInterlace)        {          (void) CloseBlob(image);          AppendImageFormat("V",image->filename);          status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);          if (status == MagickFalse)            {              image=DestroyImageList(image);              return((Image *) NULL);            }        }      for (y=0; y < (ssize_t) chroma_image->rows; y++)      {        (void) ReadBlob(image,(size_t) quantum*chroma_image->columns,scanline);        p=scanline;        q=GetAuthenticPixels(chroma_image,0,y,chroma_image->columns,1,          exception);        if (q == (PixelPacket *) NULL)          break;        for (x=0; x < (ssize_t) chroma_image->columns; x++)        {          if (quantum == 1)            SetPixelBlue(q,ScaleCharToQuantum(*p++));          else            {              SetPixelBlue(q,ScaleShortToQuantum(((*p) << 8) | *(p+1)));              p+=2;            }          q++;        }        if (SyncAuthenticPixels(chroma_image,exception) == MagickFalse)          break;      }    }    /*      Scale image.    */    resize_image=ResizeImage(chroma_image,image->columns,image->rows,      TriangleFilter,1.0,exception);    chroma_image=DestroyImage(chroma_image);    if (resize_image == (Image *) NULL)      ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");    for (y=0; y < (ssize_t) image->rows; y++)    {      q=GetAuthenticPixels(image,0,y,image->columns,1,exception);      chroma_pixels=GetVirtualPixels(resize_image,0,y,resize_image->columns,1,        &resize_image->exception);      if ((q == (PixelPacket *) NULL) ||

//.........这里部分代码省略.........            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;                for (x=0; x < (ssize_t) image->columns; x++)                {                    if (matte_image[i] != 0)                        SetPixelIndex(image,(Quantum) image->colors,q);                    q+=GetPixelChannels(image);                }            }        }        if (matte_image != (unsigned char *) NULL)            matte_image=(unsigned char *) RelinquishMagickMemory(matte_image);    }    /*      Compute the character per pixel.    */    characters_per_pixel=1;    for (k=MaxCixels; (ssize_t) colors > k; k*=MaxCixels)        characters_per_pixel++;    /*      UIL header.    */    symbol=AcquireString("");    (void) WriteBlobString(image,"/* UIL *//n");    GetPathComponent(image->filename,BasePath,basename);    (void) FormatLocaleString(buffer,MagickPathExtent,                              "value/n  %s_ct : color_table(/n",basename);    (void) WriteBlobString(image,buffer);    GetPixelInfo(image,&pixel);    for (i=0; i < (ssize_t) colors; i++)    {        /*

//.........这里部分代码省略.........    token;  unsigned char    *p;  wchar_t    fileName[MagickPathExtent];  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);  image=AcquireImage(image_info,exception);  if (Gdiplus::GdiplusStartup(&token,&startup_input,NULL) !=     Gdiplus::Status::Ok)    ThrowReaderException(CoderError, "GdiplusStartupFailed");  MultiByteToWideChar(CP_UTF8,0,image->filename,-1,fileName,MagickPathExtent);  source=Gdiplus::Image::FromFile(fileName);  if (source == (Gdiplus::Image *) NULL)    {      Gdiplus::GdiplusShutdown(token);      ThrowReaderException(FileOpenError,"UnableToOpenFile");    }  image->resolution.x=source->GetHorizontalResolution();  image->resolution.y=source->GetVerticalResolution();  image->columns=(size_t) source->GetWidth();  image->rows=(size_t) source->GetHeight();  if (image_info->density != (char *) NULL)    {      flags=ParseGeometry(image_info->density,&geometry_info);      image->resolution.x=geometry_info.rho;      image->resolution.y=geometry_info.sigma;      if ((flags & SigmaValue) == 0)        image->resolution.y=image->resolution.x;      if ((image->resolution.x > 0.0) && (image->resolution.y > 0.0))        {          image->columns=(size_t) floor((Gdiplus::REAL) source->GetWidth() /            source->GetHorizontalResolution() * image->resolution.x + 0.5);          image->rows=(size_t)floor((Gdiplus::REAL) source->GetHeight() /            source->GetVerticalResolution() * image->resolution.y + 0.5);        }    }  bitmap=new Gdiplus::Bitmap((INT) image->columns,(INT) image->rows,    PixelFormat32bppARGB);  graphics=Gdiplus::Graphics::FromImage(bitmap);  graphics->SetInterpolationMode(Gdiplus::InterpolationModeHighQualityBicubic);  graphics->SetSmoothingMode(Gdiplus::SmoothingModeHighQuality);  graphics->SetTextRenderingHint(Gdiplus::TextRenderingHintClearTypeGridFit);  graphics->Clear(Gdiplus::Color((BYTE) ScaleQuantumToChar(    image->background_color.alpha),(BYTE) ScaleQuantumToChar(    image->background_color.red),(BYTE) ScaleQuantumToChar(    image->background_color.green),(BYTE) ScaleQuantumToChar(    image->background_color.blue)));  graphics->DrawImage(source,0,0,(INT) image->columns,(INT) image->rows);  delete graphics;  delete source;  rect=Gdiplus::Rect(0,0,(INT) image->columns,(INT) image->rows);  if (bitmap->LockBits(&rect,Gdiplus::ImageLockModeRead,PixelFormat32bppARGB,    &bitmap_data) != Gdiplus::Ok)  {    delete bitmap;    Gdiplus::GdiplusShutdown(token);    ThrowReaderException(FileOpenError,"UnableToReadImageData");  }  image->alpha_trait=BlendPixelTrait;  for (y=0; y < (ssize_t) image->rows; y++)  {    p=(unsigned char *) bitmap_data.Scan0+(y*abs(bitmap_data.Stride));    if (bitmap_data.Stride < 0)      q=GetAuthenticPixels(image,0,image->rows-y-1,image->columns,1,exception);    else      q=GetAuthenticPixels(image,0,y,image->columns,1,exception);    if (q == (Quantum *) NULL)      break;    for (x=0; x < (ssize_t) image->columns; x++)    {      SetPixelBlue(image,ScaleCharToQuantum(*p++),q);      SetPixelGreen(image,ScaleCharToQuantum(*p++),q);      SetPixelRed(image,ScaleCharToQuantum(*p++),q);      SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);      q+=GetPixelChannels(image);    }    if (SyncAuthenticPixels(image,exception) == MagickFalse)      break;  }  bitmap->UnlockBits(&bitmap_data);  delete bitmap;  Gdiplus::GdiplusShutdown(token);  return(image);}

//.........这里部分代码省略.........        break;    switch (image_info->interlace)    {      case NoInterlace:      default:      {        /*          No interlacing:  RGBRGBRGBRGBRGBRGB...        */        if (scene == 0)          {            length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);            count=ReadBlob(image,length,pixels);            if (count != (ssize_t) length)              break;          }        for (y=0; y < (long) image->extract_info.height; y++)        {          register const PixelPacket            *__restrict p;          register long            x;          register PixelPacket            *__restrict q;          if (count != (ssize_t) length)            {              ThrowFileException(exception,CorruptImageError,                "UnexpectedEndOfFile",image->filename);              break;            }          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,            exception);          if (q == (PixelPacket *) NULL)            break;          length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,            quantum_info,quantum_type,pixels,exception);          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)            break;          if (((y-image->extract_info.y) >= 0) &&              ((y-image->extract_info.y) < (long) image->rows))            {              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,                canvas_image->columns,1,exception);              q=QueueAuthenticPixels(image,0,y-image->extract_info.y,                image->columns,1,exception);              if ((p == (const PixelPacket *) NULL) ||                  (q == (PixelPacket *) NULL))                break;              for (x=0; x < (long) image->columns; x++)              {                qx[0]=p->red;                qx[1]=p->green;                qx[2]=p->blue;                for (i=0; i < 3; i++)                  switch(quantum_types[i])                  {                    case RedQuantum:   q->red=qx[i];   break;                    case GreenQuantum: q->green=qx[i]; break;                    case BlueQuantum:  q->blue=qx[i];  break;                    default:                           break;                  }                q->opacity=OpaqueOpacity;                if (image->matte != MagickFalse)

//.........这里部分代码省略.........                {                case GRAYColorspace:                {                    if (image->alpha_trait != UndefinedPixelTrait)                    {                        count=(ssize_t) sscanf(text,"%ld,%ld: (%lf%*[%,]%lf%*[%,]",                                               &x_offset,&y_offset,&red,&alpha);                        green=red;                        blue=red;                        break;                    }                    count=(ssize_t) sscanf(text,"%ld,%ld: (%lf%*[%,]",&x_offset,                                           &y_offset,&red);                    green=red;                    blue=red;                    break;                }                case CMYKColorspace:                {                    if (image->alpha_trait != UndefinedPixelTrait)                    {                        count=(ssize_t) sscanf(text,                                               "%ld,%ld: (%lf%*[%,]%lf%*[%,]%lf%*[%,]%lf%*[%,]%lf%*[%,]",                                               &x_offset,&y_offset,&red,&green,&blue,&black,&alpha);                        break;                    }                    count=(ssize_t) sscanf(text,                                           "%ld,%ld: (%lf%*[%,]%lf%*[%,]%lf%*[%,]%lf%*[%,]",&x_offset,                                           &y_offset,&red,&green,&blue,&black);                    break;                }                default:                {                    if (image->alpha_trait != UndefinedPixelTrait)                    {                        count=(ssize_t) sscanf(text,                                               "%ld,%ld: (%lf%*[%,]%lf%*[%,]%lf%*[%,]%lf%*[%,]",                                               &x_offset,&y_offset,&red,&green,&blue,&alpha);                        break;                    }                    count=(ssize_t) sscanf(text,                                           "%ld,%ld: (%lf%*[%,]%lf%*[%,]%lf%*[%,]",&x_offset,                                           &y_offset,&red,&green,&blue);                    break;                }                }                if (strchr(text,'%') != (char *) NULL)                {                    red*=0.01*range;                    green*=0.01*range;                    blue*=0.01*range;                    black*=0.01*range;                    alpha*=0.01*range;                }                if (image->colorspace == LabColorspace)                {                    green+=(range+1)/2.0;                    blue+=(range+1)/2.0;                }                pixel.red=(MagickRealType) ScaleAnyToQuantum((QuantumAny) (red+0.5),                          range);                pixel.green=(MagickRealType) ScaleAnyToQuantum((QuantumAny) (green+0.5),                            range);                pixel.blue=(MagickRealType) ScaleAnyToQuantum((QuantumAny) (blue+0.5),                           range);                pixel.black=(MagickRealType) ScaleAnyToQuantum((QuantumAny) (black+0.5),                            range);                pixel.alpha=(MagickRealType) ScaleAnyToQuantum((QuantumAny) (alpha+0.5),                            range);                q=GetAuthenticPixels(image,(ssize_t) x_offset,(ssize_t) y_offset,1,1,                                     exception);                if (q == (Quantum *) NULL)                    continue;                SetPixelViaPixelInfo(image,&pixel,q);                if (SyncAuthenticPixels(image,exception) == MagickFalse)                    break;            }        }        (void) ReadBlobString(image,text);        if (LocaleNCompare((char *) text,MagickID,strlen(MagickID)) == 0)        {            /*              Allocate next image structure.            */            AcquireNextImage(image_info,image,exception);            if (GetNextImageInList(image) == (Image *) NULL)            {                image=DestroyImageList(image);                return((Image *) NULL);            }            image=SyncNextImageInList(image);            status=SetImageProgress(image,LoadImagesTag,TellBlob(image),                                    GetBlobSize(image));            if (status == MagickFalse)                break;        }    } while (LocaleNCompare((char *) text,MagickID,strlen(MagickID)) == 0);    (void) CloseBlob(image);    return(GetFirstImageInList(image));}

//.........这里部分代码省略.........    affinity_image=BlobToImage(blob_info,Graymap,GraymapExtent,      &image->exception);  else    affinity_image=BlobToImage(blob_info,Colormap,ColormapExtent,      &image->exception);  (void) RelinquishUniqueFileResource(blob_info->filename);  blob_info=DestroyImageInfo(blob_info);  if ((picon == (Image *) NULL) || (affinity_image == (Image *) NULL))    return(MagickFalse);  quantize_info=AcquireQuantizeInfo(image_info);  status=RemapImage(quantize_info,picon,affinity_image);  quantize_info=DestroyQuantizeInfo(quantize_info);  affinity_image=DestroyImage(affinity_image);  transparent=MagickFalse;  exception=(&image->exception);  if (picon->storage_class == PseudoClass)    {      (void) CompressImageColormap(picon);      if (picon->matte != MagickFalse)        transparent=MagickTrue;    }  else    {      /*        Convert DirectClass to PseudoClass picon.      */      if (picon->matte != MagickFalse)        {          /*            Map all the transparent pixels.          */          for (y=0; y < (ssize_t) picon->rows; y++)          {            q=GetAuthenticPixels(picon,0,y,picon->columns,1,exception);            if (q == (PixelPacket *) NULL)              break;            for (x=0; x < (ssize_t) picon->columns; x++)            {              if (q->opacity == (Quantum) TransparentOpacity)                transparent=MagickTrue;              else                SetPixelOpacity(q,OpaqueOpacity);              q++;            }            if (SyncAuthenticPixels(picon,exception) == MagickFalse)              break;          }        }      (void) SetImageType(picon,PaletteType);    }  colors=picon->colors;  if (transparent != MagickFalse)    {      register IndexPacket        *indexes;      colors++;      picon->colormap=(PixelPacket *) ResizeQuantumMemory((void **)        picon->colormap,(size_t) colors,sizeof(*picon->colormap));      if (picon->colormap == (PixelPacket *) NULL)        ThrowWriterException(ResourceLimitError,"MemoryAllocationError");      for (y=0; y < (ssize_t) picon->rows; y++)      {        q=GetAuthenticPixels(picon,0,y,picon->columns,1,exception);        if (q == (PixelPacket *) NULL)          break;

//.........这里部分代码省略.........  y=y_offset;  start=0;  s=segment_stack;  PushSegmentStack(y,x,x,1);  PushSegmentStack(y+1,x,x,-1);  GetMagickPixelPacket(image,&fill);  GetMagickPixelPacket(image,&pixel);  while (s > segment_stack)  {    register const IndexPacket      *__restrict indexes;    register const PixelPacket      *__restrict p;    register long      x;    register PixelPacket      *__restrict q;    /*      Pop segment off stack.    */    s--;    x1=(long) s->x1;    x2=(long) s->x2;    offset=(long) s->y2;    y=(long) s->y1+offset;    /*      Recolor neighboring pixels.    */    p=GetVirtualPixels(image,0,y,(unsigned long) (x1+1),1,exception);    q=GetAuthenticPixels(floodplane_image,0,y,(unsigned long) (x1+1),1,      exception);    if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))      break;    indexes=GetVirtualIndexQueue(image);    p+=x1;    q+=x1;    for (x=x1; x >= 0; x--)    {      if (q->opacity == (Quantum) TransparentOpacity)        break;      SetMagickPixelPacket(image,p,indexes+x,&pixel);      if (IsMagickColorSimilar(&pixel,target) == invert)        break;      q->opacity=(Quantum) TransparentOpacity;      p--;      q--;    }    if (SyncAuthenticPixels(floodplane_image,exception) == MagickFalse)      break;    skip=x >= x1 ? MagickTrue : MagickFalse;    if (skip == MagickFalse)      {        start=x+1;        if (start < x1)          PushSegmentStack(y,start,x1-1,-offset);        x=x1+1;      }    do    {      if (skip == MagickFalse)        {          if (x < (long) image->columns)