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

//.........这里部分代码省略.........%  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;  long    y;  MagickBooleanType    status;  register long    x;  register PixelPacket    *q;  register unsigned char    *p;  ssize_t    count;  size_t    length;  unsigned char    *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);    }  /*    Convert HRZ raster image to pixel packets.  */  image->columns=256;  image->rows=240;  image->depth=8;  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 < (long) 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 == (PixelPacket *) NULL)      break;    for (x=0; x < (long) image->columns; x++)    {      q->red=4*ScaleCharToQuantum(*p++);      q->green=4*ScaleCharToQuantum(*p++);      q->blue=4*ScaleCharToQuantum(*p++);      q->opacity=OpaqueOpacity;      q++;    }    if (SyncAuthenticPixels(image,exception) == MagickFalse)      break;    if (SetImageProgress(image,LoadImageTag,y,image->rows) == MagickFalse)      break;  }  pixels=(unsigned char *) RelinquishMagickMemory(pixels);  if (EOFBlob(image) != MagickFalse)    ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",      image->filename);  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   R e a d X C I m a g e                                                     %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ReadXCImage creates a constant image and initializes it to the%  X server color as specified by the filename.  It allocates the memory%  necessary for the new Image structure and returns a pointer to the new%  image.%%  The format of the ReadXCImage method is:%%      Image *ReadXCImage(const ImageInfo *image_info,ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image:  The image.%%    o image_info: the image info.%%    o exception: return any errors or warnings in this structure.%*/static Image *ReadXCImage(const ImageInfo *image_info,ExceptionInfo *exception){  Image    *image;  MagickBooleanType    status;  PixelInfo    pixel;  register ssize_t    x;  register Quantum    *q;  ssize_t    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);  image=AcquireImage(image_info,exception);  if (image->columns == 0)    image->columns=1;  if (image->rows == 0)    image->rows=1;  (void) CopyMagickString(image->filename,image_info->filename,MaxTextExtent);  if (*image_info->filename == '/0')    pixel=image->background_color;  else    {      status=QueryColorCompliance((char *) image_info->filename,AllCompliance,        &pixel,exception);      if (status == MagickFalse)        {          image=DestroyImage(image);          return((Image *) NULL);        }    }  (void) SetImageColorspace(image,pixel.colorspace,exception);  image->alpha_trait=pixel.alpha_trait;  for (y=0; y < (ssize_t) image->rows; y++)  {    q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);    if (q == (Quantum *) NULL)      break;    for (x=0; x < (ssize_t) image->columns; x++)    {      SetPixelInfoPixel(image,&pixel,q);      q+=GetPixelChannels(image);    }    if (SyncAuthenticPixels(image,exception) == MagickFalse)      break;  }  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........  size_t    height,    width;  /*    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);  (void) ResetImagePage(image,"0x0+0+0");  property=InterpretImageProperties(image_info,image,image_info->filename);  (void) SetImageProperty(image,"label",property);  property=DestroyString(property);  label=GetImageProperty(image,"label");  draw_info=CloneDrawInfo(image_info,(DrawInfo *) NULL);  draw_info->text=ConstantString(label);  if (((image->columns != 0) || (image->rows != 0)) &&      (image_info->pointsize == 0.0))    {      /*        Fit label to canvas size.      */      status=GetMultilineTypeMetrics(image,draw_info,&metrics);      for ( ; status != MagickFalse; draw_info->pointsize*=2.0)      {        width=(size_t) floor(metrics.width+draw_info->stroke_width+0.5);        height=(size_t) floor(metrics.height+draw_info->stroke_width+0.5);        if (((image->columns != 0) && (width > (image->columns+1))) ||            ((image->rows != 0) && (height > (image->rows+1))))          break;        status=GetMultilineTypeMetrics(image,draw_info,&metrics);      }      for ( ; status != MagickFalse; draw_info->pointsize--)      {        width=(size_t) floor(metrics.width+draw_info->stroke_width+0.5);        height=(size_t) floor(metrics.height+draw_info->stroke_width+0.5);        if ((image->columns != 0) && (width <= (image->columns+1)) &&           ((image->rows == 0) || (height <= (image->rows+1))))          break;        if ((image->rows != 0) && (height <= (image->rows+1)) &&           ((image->columns == 0) || (width <= (image->columns+1))))          break;        if (draw_info->pointsize < 2.0)          break;        status=GetMultilineTypeMetrics(image,draw_info,&metrics);      }    }  status=GetMultilineTypeMetrics(image,draw_info,&metrics);  if (status == MagickFalse)    {      InheritException(exception,&image->exception);      image=DestroyImageList(image);      return((Image *) NULL);    }  if (image->columns == 0)    image->columns=(size_t) (metrics.width+draw_info->stroke_width+1.5);  if (image->columns == 0)    image->columns=(size_t) (draw_info->pointsize+draw_info->stroke_width+1.5);  if ((draw_info->gravity == UndefinedGravity) ||      (draw_info->direction == RightToLeftDirection))    {      (void) FormatLocaleString(geometry,MaxTextExtent,"%+g%+g",        -metrics.bounds.x1+draw_info->stroke_width/2.0,metrics.ascent+        draw_info->stroke_width/2.0);      if (draw_info->direction == RightToLeftDirection)        (void) FormatLocaleString(geometry,MaxTextExtent,"%+g%+g",          image->columns-(metrics.bounds.x2+draw_info->stroke_width/2.0),          metrics.ascent+draw_info->stroke_width/2.0);      draw_info->geometry=AcquireString(geometry);    }  if (image->rows == 0)    image->rows=(size_t) floor(metrics.height+draw_info->stroke_width+0.5);  if (image->rows == 0)    image->rows=(size_t) floor(draw_info->pointsize+draw_info->stroke_width+      0.5);  if (SetImageBackgroundColor(image) == MagickFalse)    {      InheritException(exception,&image->exception);      image=DestroyImageList(image);      return((Image *) NULL);    }  (void) AnnotateImage(image,draw_info);  if (image_info->pointsize == 0.0)    {      char        pointsize[MaxTextExtent];      (void) FormatLocaleString(pointsize,MaxTextExtent,"%.20g",        draw_info->pointsize);      (void) SetImageProperty(image,"label:pointsize",pointsize);    }  draw_info=DestroyDrawInfo(draw_info);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........    p=next;    next=NextXPMLine(p);    (void) CopyXPMColor(key,p,MagickMin((size_t) width,MaxTextExtent-1));    status=AddValueToSplayTree(xpm_colors,ConstantString(key),(void *) j);    /*      Parse color.    */    (void) CopyMagickString(target,"gray",MaxTextExtent);    q=ParseXPMColor(p+width,MagickTrue);    if (q != (char *) NULL)      {        while ((isspace((int) ((unsigned char) *q)) == 0) && (*q != '/0'))          q++;        if ((next-q) < 0)          break;        if (next != (char *) NULL)          (void) CopyXPMColor(target,q,MagickMin((size_t) (next-q),            MaxTextExtent-1));        else          (void) CopyMagickString(target,q,MaxTextExtent);        q=ParseXPMColor(target,MagickFalse);        if (q != (char *) NULL)          *q='/0';      }    StripString(target);    grey=strstr(target,"grey");    if (grey != (char *) NULL)      grey[2]='a';    if (LocaleCompare(target,"none") == 0)      {        image->storage_class=DirectClass;        image->matte=MagickTrue;      }    status=QueryColorCompliance(target,XPMCompliance,&image->colormap[j],      exception);    if (status == MagickFalse)      break;    (void) QueryMagickColorCompliance(target,XPMCompliance,&pixel,exception);    if (image->depth < pixel.depth)      image->depth=pixel.depth;  }  if (j < (ssize_t) image->colors)    {      xpm_colors=DestroySplayTree(xpm_colors);      xpm_buffer=DestroyString(xpm_buffer);      ThrowReaderException(CorruptImageError,"CorruptImage");    }  j=0;  if (image_info->ping == MagickFalse)    {      /*        Read image pixels.      */      status=SetImageExtent(image,image->columns,image->rows);      if (status == MagickFalse)        {          InheritException(exception,&image->exception);          return(DestroyImageList(image));        }      for (y=0; y < (ssize_t) image->rows; y++)      {        p=NextXPMLine(p);        if (p == (char *) NULL)          break;        r=QueueAuthenticPixels(image,0,y,image->columns,1,exception);        if (r == (PixelPacket *) NULL)          break;        indexes=GetAuthenticIndexQueue(image);        for (x=0; x < (ssize_t) image->columns; x++)        {          ssize_t count=CopyXPMColor(key,p,MagickMin(width,MaxTextExtent-1));          if (count != (ssize_t) width)            break;          j=(ssize_t) GetValueFromSplayTree(xpm_colors,key);          if (image->storage_class == PseudoClass)            SetPixelIndex(indexes+x,j);          *r=image->colormap[j];          p+=count;          r++;        }        if (x < (ssize_t) image->columns)          break;        if (SyncAuthenticPixels(image,exception) == MagickFalse)          break;      }      if (y < (ssize_t) image->rows)        {          xpm_colors=DestroySplayTree(xpm_colors);          xpm_buffer=DestroyString(xpm_buffer);          ThrowReaderException(CorruptImageError,"NotEnoughPixelData");        }    }  /*    Relinquish resources.  */  xpm_colors=DestroySplayTree(xpm_colors);  xpm_buffer=DestroyString(xpm_buffer);  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........    /*      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;    status=SetImageExtent(image,image->columns,image->rows,exception);    if (status == MagickFalse)      return(DestroyImageList(image));    SetImageColorspace(image,GRAYColorspace,exception);    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 Quantum        *magick_restrict p;      register ssize_t        x;      register Quantum        *magick_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 == (Quantum *) 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 Quantum *) NULL) ||              (q == (Quantum *) NULL))            break;          for (x=0; x < (ssize_t) image->columns; x++)          {            SetPixelGray(image,GetPixelGray(canvas_image,p),q);            p+=GetPixelChannels(canvas_image);            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;        }      pixels=(const unsigned char *) ReadBlobStream(image,length,        GetQuantumPixels(quantum_info),&count);    }    SetQuantumImageType(image,quantum_type);    /*      Proceed to next image.    */    if (image_info->number_scenes != 0)      if (image->scene >= (image_info->scene+image_info->number_scenes-1))        break;    if (count == (ssize_t) length)      {        /*          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;      }    scene++;  } while (count == (ssize_t) length);  quantum_info=DestroyQuantumInfo(quantum_info);  canvas_image=DestroyImage(canvas_image);  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........        (jas_image_cmpttly(jp2_image,components[i]) != 0) ||        (x_step[i] != 1) || (y_step[i] != 1) ||        (jas_image_cmptsgnd(jp2_image,components[i]) != MagickFalse))      {        (void) jas_stream_close(jp2_stream);        jas_image_destroy(jp2_image);        ThrowReaderException(CoderError,"IrregularChannelGeometryNotSupported");      }  }  /*    Convert JPEG 2000 pixels.  */  image->matte=number_components > 3 ? MagickTrue : MagickFalse;  maximum_component_depth=0;  for (i=0; i < (long) 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 < (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)    {

//.........这里部分代码省略.........      pango_layout_get_pixel_extents(layout,NULL,&extent);      image->columns=extent.x+extent.width+2*page.x;    }  else    {      image->columns-=2*page.x;      pango_layout_set_width(layout,(int) ((PANGO_SCALE*image->columns*        image->x_resolution+36.0)/72.0+0.5));    }  if (image->rows == 0)    {      pango_layout_get_pixel_extents(layout,NULL,&extent);      image->rows=extent.y+extent.height+2*page.y;    }  else    {      image->rows-=2*page.y;      pango_layout_set_height(layout,(int) ((PANGO_SCALE*image->rows*        image->y_resolution+36.0)/72.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);  p=pixels;  for (y=0; y < (ssize_t) image->rows; y++)  {    register PixelPacket      *q;    register ssize_t      x;    q=GetAuthenticPixels(image,0,y,image->columns,1,exception);    if (q == (PixelPacket *) NULL)      break;    for (x=0; x < (ssize_t) image->columns; x++)    {      double        gamma;      fill_color.blue=ScaleCharToQuantum(*p++);      fill_color.green=ScaleCharToQuantum(*p++);      fill_color.red=ScaleCharToQuantum(*p++);      fill_color.opacity=QuantumRange-ScaleCharToQuantum(*p++);      /*        Disassociate alpha.      */      gamma=1.0-QuantumScale*fill_color.opacity;      gamma=MagickEpsilonReciprocal(gamma);      fill_color.blue*=gamma;      fill_color.green*=gamma;      fill_color.red*=gamma;      MagickCompositeOver(&fill_color,fill_color.opacity,q,(MagickRealType)        q->opacity,q);      q++;    }    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));}

//.........这里部分代码省略.........    {      double        high,        low;      /*        Auto fit text into bounding box.      */      for ( ; ; draw_info->pointsize*=2.0)      {        text=AcquireString(caption);        i=FormatMagickCaption(image,draw_info,MagickFalse,&metrics,&text);        (void) CloneString(&draw_info->text,text);        text=DestroyString(text);        (void) FormatLocaleString(geometry,MaxTextExtent,"%+g%+g",          -metrics.bounds.x1,metrics.ascent);        if (draw_info->gravity == UndefinedGravity)          (void) CloneString(&draw_info->geometry,geometry);        status=GetMultilineTypeMetrics(image,draw_info,&metrics);        (void) status;        width=(size_t) floor(metrics.width+draw_info->stroke_width+0.5);        height=(size_t) floor(metrics.height+draw_info->stroke_width+0.5);        if ((image->columns != 0) && (image->rows != 0))          {            if ((width >= image->columns) && (height >= image->rows))              break;          }        else          if (((image->columns != 0) && (width >= image->columns)) ||              ((image->rows != 0) && (height >= image->rows)))            break;      }      high=draw_info->pointsize;      for (low=1.0; (high-low) > 1.0; )      {        draw_info->pointsize=(low+high)/2.0;        text=AcquireString(caption);        i=FormatMagickCaption(image,draw_info,MagickFalse,&metrics,&text);        (void) CloneString(&draw_info->text,text);        text=DestroyString(text);        (void) FormatLocaleString(geometry,MaxTextExtent,"%+g%+g",          -metrics.bounds.x1,metrics.ascent);        if (draw_info->gravity == UndefinedGravity)          (void) CloneString(&draw_info->geometry,geometry);        status=GetMultilineTypeMetrics(image,draw_info,&metrics);        width=(size_t) floor(metrics.width+draw_info->stroke_width+0.5);        height=(size_t) floor(metrics.height+draw_info->stroke_width+0.5);        if ((image->columns != 0) && (image->rows != 0))          {            if ((width < image->columns) && (height < image->rows))              low=draw_info->pointsize+1.0;            else              high=draw_info->pointsize-1.0;          }        else          if (((image->columns != 0) && (width < image->columns)) ||              ((image->rows != 0) && (height < image->rows)))            low=draw_info->pointsize+1.0;          else            high=draw_info->pointsize-1.0;      }      draw_info->pointsize=(low+high)/2.0-1.0;    }  (void) CloneString(&draw_info->text,caption);  i=FormatMagickCaption(image,draw_info,MagickFalse,&metrics,&caption);  if (SetImageBackgroundColor(image) == MagickFalse)    {      InheritException(exception,&image->exception);      image=DestroyImageList(image);      return((Image *) NULL);    }  /*    Draw caption.  */  (void) CloneString(&draw_info->text,caption);  status=GetMultilineTypeMetrics(image,draw_info,&metrics);  if ((draw_info->gravity != UndefinedGravity) &&      (draw_info->direction != RightToLeftDirection))    image->page.x=(ssize_t) (metrics.bounds.x1-draw_info->stroke_width/2.0);  else    {      (void) FormatLocaleString(geometry,MaxTextExtent,"%+g%+g",        -metrics.bounds.x1+draw_info->stroke_width/2.0,metrics.ascent+        draw_info->stroke_width/2.0);      if (draw_info->direction == RightToLeftDirection)        (void) FormatLocaleString(geometry,MaxTextExtent,"%+g%+g",          image->columns-(metrics.bounds.x2+draw_info->stroke_width/2.0),          metrics.ascent+draw_info->stroke_width/2.0);      draw_info->geometry=AcquireString(geometry);    }  status=AnnotateImage(image,draw_info);  draw_info=DestroyDrawInfo(draw_info);  caption=DestroyString(caption);  if (status == MagickFalse)    {      image=DestroyImageList(image);      return((Image *) NULL);    }  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........#if 0        {        /* NOTE: XCF layers are REVERSED from composite order! */        signed int  j;        for (j=number_layers-1; j>=0; j--) {          /* BOGUS: need to consider layer blending modes!! */          if ( layer_info[j].visible ) { /* only visible ones, please! */            CompositeImage(image, layer_info[j].image, OverCompositeOp,               MagickTrue, layer_info[j].offset_x, layer_info[j].offset_y );             layer_info[j].image =DestroyImage( layer_info[j].image );            /*  If we do this, we'll get REAL gray images! */            if ( image_type == GIMP_GRAY ) {              QuantizeInfo  qi;              GetQuantizeInfo(&qi);              qi.colorspace = GRAYColorspace;              QuantizeImage( &qi, layer_info[j].image );            }          }        }      }#else      {        /* NOTE: XCF layers are REVERSED from composite order! */        signed int  j;        /* first we copy the last layer on top of the main image */        (void) CompositeImage(image,CopyCompositeOp,          layer_info[number_layers-1].image,layer_info[number_layers-1].offset_x,          layer_info[number_layers-1].offset_y);        layer_info[number_layers-1].image=DestroyImage(          layer_info[number_layers-1].image);        /* now reverse the order of the layers as they are put           into subimages        */      image->next=layer_info[number_layers-2].image;      layer_info[number_layers-2].image->previous=image;      for (j=number_layers-2; j>=0; j--)      {        if (j > 0)          layer_info[j].image->next=layer_info[j-1].image;        if (j < (number_layers-1))          layer_info[j].image->previous=layer_info[j+1].image;        layer_info[j].image->page.x = layer_info[j].offset_x;        layer_info[j].image->page.y = layer_info[j].offset_y;        layer_info[j].image->page.width = layer_info[j].width;        layer_info[j].image->page.height = layer_info[j].height;        }      }#endif    }    layer_info=(XCFLayerInfo *) RelinquishMagickMemory(layer_info);#if 0  /* BOGUS: do we need the channels?? */    while (MagickTrue)    {      /* read in the offset of the next channel */      info->cp += xcf_read_int32 (info->fp, &offset, 1);      /* if the offset is 0 then we are at the end      *  of the channel list.      */      if (offset == 0)        break;      /* save the current position as it is where the      *  next channel offset is stored.      */      saved_pos = info->cp;      /* seek to the channel offset */      xcf_seek_pos (info, offset);      /* read in the layer */      channel = xcf_load_channel (info, gimage);      if (channel == 0)        goto error;      num_successful_elements++;      /* add the channel to the image if its not the selection */      if (channel != gimage->selection_mask)        gimp_image_add_channel (gimage, channel, -1);      /* restore the saved position so we'll be ready to      *  read the next offset.      */      xcf_seek_pos (info, saved_pos);    }#endif  }  (void) CloseBlob(image);  if (image_type == GIMP_GRAY)    image->type=GrayscaleType;  return(GetFirstImageInList(image));}

static MagickBooleanType ForwardFourier(const FourierInfo *fourier_info,  Image *image,double *magnitude,double *phase,ExceptionInfo *exception){  CacheView    *magnitude_view,    *phase_view;  double    *magnitude_source,    *phase_source;  Image    *magnitude_image,    *phase_image;  long    i,    y;  MagickBooleanType    status;  register IndexPacket    *indexes;  register long    x;  register PixelPacket    *q;  magnitude_image=GetFirstImageInList(image);  phase_image=GetNextImageInList(image);  if (phase_image == (Image *) NULL)    {      (void) ThrowMagickException(exception,GetMagickModule(),ImageError,        "ImageSequenceRequired","`%s'",image->filename);      return(MagickFalse);    }  /*    Create "Fourier Transform" image from constituent arrays.  */  magnitude_source=(double *) AcquireQuantumMemory((size_t)    fourier_info->height,fourier_info->width*sizeof(*magnitude_source));  if (magnitude_source == (double *) NULL)    return(MagickFalse);  (void) ResetMagickMemory(magnitude_source,0,fourier_info->width*    fourier_info->height*sizeof(*magnitude_source));  phase_source=(double *) AcquireQuantumMemory((size_t) fourier_info->height,    fourier_info->width*sizeof(*phase_source));  if (magnitude_source == (double *) NULL)    {      (void) ThrowMagickException(exception,GetMagickModule(),        ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);      magnitude_source=(double *) RelinquishMagickMemory(magnitude_source);      return(MagickFalse);    }  status=ForwardQuadrantSwap(fourier_info->height,fourier_info->height,    magnitude,magnitude_source);  if (status != MagickFalse)    status=ForwardQuadrantSwap(fourier_info->height,fourier_info->height,phase,      phase_source);  CorrectPhaseLHS(fourier_info->height,fourier_info->height,phase_source);  if (fourier_info->modulus != MagickFalse)    {      i=0L;      for (y=0L; y < (long) fourier_info->height; y++)        for (x=0L; x < (long) fourier_info->width; x++)        {          phase_source[i]/=(2.0*MagickPI);          phase_source[i]+=0.5;          i++;        }    }  magnitude_view=AcquireCacheView(magnitude_image);  phase_view=AcquireCacheView(phase_image);  i=0L;  for (y=0L; y < (long) fourier_info->height; y++)  {    q=GetCacheViewAuthenticPixels(magnitude_view,0L,y,fourier_info->height,1UL,      exception);    if (q == (PixelPacket *) NULL)      break;    indexes=GetCacheViewAuthenticIndexQueue(magnitude_view);    for (x=0L; x < (long) fourier_info->width; x++)    {      switch (fourier_info->channel)      {        case RedChannel:        default:        {          q->red=ClampToQuantum(QuantumRange*magnitude_source[i]);          break;        }        case GreenChannel:        {          q->green=ClampToQuantum(QuantumRange*magnitude_source[i]);          break;        }        case BlueChannel://.........这里部分代码省略.........

//.........这里部分代码省略.........                canvas_image=DestroyImageList(canvas_image);                image=DestroyImageList(image);                return((Image *) NULL);              }            length=GetQuantumExtent(canvas_image,quantum_info,AlphaQuantum);            for (i=0; i < (ssize_t) scene; i++)              for (y=0; y < (ssize_t) image->extract_info.height; y++)                if (ReadBlob(image,length,pixels) != (ssize_t) length)                  {                    ThrowFileException(exception,CorruptImageError,                      "UnexpectedEndOfFile",image->filename);                    break;                  }            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,BlueQuantum,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=GetAuthenticPixels(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++)                  {                    SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));                    p++;                    q++;                  }                  if (SyncAuthenticPixels(image,exception) == MagickFalse)                    break;               }              count=ReadBlob(image,length,pixels);            }            if (image->previous == (Image *) NULL)              {                status=SetImageProgress(image,LoadImageTag,4,5);                if (status == MagickFalse)                  break;              }          }        if (image->previous == (Image *) NULL)          {            status=SetImageProgress(image,LoadImageTag,5,5);            if (status == MagickFalse)              break;          }        break;      }    }    SetQuantumImageType(image,quantum_type);    /*      Proceed to next image.    */    if (image_info->number_scenes != 0)      if (image->scene >= (image_info->scene+image_info->number_scenes-1))        break;    if (count == (ssize_t) length)      {        /*          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;      }    scene++;  } while (count == (ssize_t) length);  quantum_info=DestroyQuantumInfo(quantum_info);  InheritException(&image->exception,&canvas_image->exception);  canvas_image=DestroyImage(canvas_image);  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   R e a d N U L L I m a g e                                                 %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ReadNULLImage creates a constant image and initializes it to the%  X server color as specified by the filename.  It allocates the memory%  necessary for the new Image structure and returns a pointer to the new%  image.%%  The format of the ReadNULLImage method is:%%      Image *ReadNULLImage(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 *ReadNULLImage(const ImageInfo *image_info,  ExceptionInfo *exception){  Image    *image;  MagickBooleanType    status;  MagickPixelPacket    background;  register IndexPacket    *indexes;  register ssize_t    x;  register PixelPacket    *q;  ssize_t    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);  image=AcquireImage(image_info);  if (image->columns == 0)    image->columns=1;  if (image->rows == 0)    image->rows=1;  status=SetImageExtent(image,image->columns,image->rows);  if (status == MagickFalse)    {      InheritException(exception,&image->exception);      return(DestroyImageList(image));    }  image->matte=MagickTrue;  GetMagickPixelPacket(image,&background);  background.opacity=(MagickRealType) TransparentOpacity;  if (image->colorspace == CMYKColorspace)    ConvertRGBToCMYK(&background);  for (y=0; y < (ssize_t) image->rows; y++)  {    q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);    if (q == (PixelPacket *) NULL)      break;    indexes=GetAuthenticIndexQueue(image);    for (x=0; x < (ssize_t) image->columns; x++)    {      SetPixelPacket(image,&background,q,indexes);      q++;      indexes++;    }    if (SyncAuthenticPixels(image,exception) == MagickFalse)      break;  }  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........        UnlockSemaphoreInfo(constitute_semaphore);    }  if (read_info->temporary != MagickFalse)    {      (void) RelinquishUniqueFileResource(read_info->filename);      read_info->temporary=MagickFalse;      if (image != (Image *) NULL)        (void) CopyMagickString(image->filename,filename,MaxTextExtent);    }  if (image == (Image *) NULL)    {      read_info=DestroyImageInfo(read_info);      return(image);    }  if (exception->severity >= ErrorException)    (void) LogMagickEvent(ExceptionEvent,GetMagickModule(),      "Coder (%s) generated an image despite an error (%d), "      "notify the developers",image->magick,exception->severity);  if (IsBlobTemporary(image) != MagickFalse)    (void) RelinquishUniqueFileResource(read_info->filename);  if ((GetNextImageInList(image) != (Image *) NULL) &&      (IsSceneGeometry(read_info->scenes,MagickFalse) != MagickFalse))    {      Image        *clones;      clones=CloneImages(image,read_info->scenes,exception);      if (clones == (Image *) NULL)        (void) ThrowMagickException(exception,GetMagickModule(),OptionError,          "SubimageSpecificationReturnsNoImages","`%s'",read_info->filename);      else        {          image=DestroyImageList(image);          image=GetFirstImageInList(clones);        }    }  if (GetBlobError(image) != MagickFalse)    {      ThrowFileException(exception,FileOpenError,        "AnErrorHasOccurredReadingFromFile",read_info->filename);      image=DestroyImageList(image);      read_info=DestroyImageInfo(read_info);      return((Image *) NULL);    }  for (next=image; next != (Image *) NULL; next=GetNextImageInList(next))  {    char      *property,      timestamp[MaxTextExtent];    const char      *option;    const StringInfo      *profile;    next->taint=MagickFalse;    if (next->magick_columns == 0)      next->magick_columns=next->columns;    if (next->magick_rows == 0)      next->magick_rows=next->rows;    if ((LocaleCompare(magick,"HTTP") != 0) &&        (LocaleCompare(magick,"FTP") != 0))      (void) CopyMagickString(next->magick,magick,MaxTextExtent);    (void) CopyMagickString(next->magick_filename,magick_filename,      MaxTextExtent);

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   W r i t e I m a g e s                                                     %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  WriteImages() writes an image sequence.%%  The format of the WriteImages method is:%%      MagickBooleanType WriteImages(const ImageInfo *image_info,Image *images,%        const char *filename,ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image_info: the image info.%%    o images: the image list.%%    o filename: the image filename.%%    o exception: return any errors or warnings in this structure.%*/MagickExport MagickBooleanType WriteImages(const ImageInfo *image_info,  Image *images,const char *filename,ExceptionInfo *exception){#define WriteImageTag  "Write/Image"  BlobInfo    *blob;  ExceptionInfo    *sans_exception;  ImageInfo    *write_info;  MagickBooleanType    proceed;  MagickOffsetType    i;  MagickProgressMonitor    progress_monitor;  MagickSizeType    number_images;  MagickStatusType    status;  register Image    *p;  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  assert(images != (Image *) NULL);  assert(images->signature == MagickSignature);  if (images->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);  assert(exception != (ExceptionInfo *) NULL);  write_info=CloneImageInfo(image_info);  images=GetFirstImageInList(images);  blob=CloneBlobInfo(images->blob);  /* thread specific I/O handler */  DestroyBlob(images);  images->blob=blob;  if (filename != (const char *) NULL)    for (p=images; p != (Image *) NULL; p=GetNextImageInList(p))      (void) CopyMagickString(p->filename,filename,MaxTextExtent);  (void) CopyMagickString(write_info->filename,images->filename,MaxTextExtent);  if (*write_info->magick == '/0')    (void) CopyMagickString(write_info->magick,images->magick,MaxTextExtent);  sans_exception=AcquireExceptionInfo();  (void) SetImageInfo(write_info,(unsigned int) GetImageListLength(images),    sans_exception);  sans_exception=DestroyExceptionInfo(sans_exception);  p=images;  for ( ; GetNextImageInList(p) != (Image *) NULL; p=GetNextImageInList(p))    if (p->scene >= GetNextImageInList(p)->scene)      {        register ssize_t          i;        /*          Generate consistent scene numbers.        */        i=(ssize_t) images->scene;        for (p=images; p != (Image *) NULL; p=GetNextImageInList(p))          p->scene=(size_t) i++;        break;      }  /*    Write images.//.........这里部分代码省略.........

MagickExport Image *ChannelFxImage(const Image *image,const char *expression,                                   ExceptionInfo *exception){#define ChannelFxImageTag  "ChannelFx/Image"    ChannelFx    channel_op;    ChannelType    channel_mask;    char    token[MagickPathExtent];    const char    *p;    const Image    *source_image;    double    pixel;    Image    *destination_image;    MagickBooleanType    status;    PixelChannel    source_channel,    destination_channel;    ssize_t    channels;    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);    source_image=image;    destination_image=CloneImage(source_image,0,0,MagickTrue,exception);    if (destination_image == (Image *) NULL)        return((Image *) NULL);    if (expression == (const char *) NULL)        return(destination_image);    destination_channel=RedPixelChannel;    channel_mask=UndefinedChannel;    pixel=0.0;    p=(char *) expression;    GetMagickToken(p,&p,token);    channel_op=ExtractChannelOp;    for (channels=0; *token != '/0'; )    {        ssize_t        i;        /*          Interpret channel expression.        */        switch (*token)        {        case ',':        {            GetMagickToken(p,&p,token);            break;        }        case '|':        {            if (GetNextImageInList(source_image) != (Image *) NULL)                source_image=GetNextImageInList(source_image);            else                source_image=GetFirstImageInList(source_image);            GetMagickToken(p,&p,token);            break;        }        case ';':        {            Image            *canvas;            (void) SetPixelChannelMask(destination_image,channel_mask);            if ((channel_op == ExtractChannelOp) && (channels == 1))                (void) SetImageColorspace(destination_image,GRAYColorspace,exception);            status=SetImageStorageClass(destination_image,DirectClass,exception);            if (status == MagickFalse)            {                destination_image=DestroyImageList(destination_image);                return(destination_image);            }            canvas=CloneImage(source_image,0,0,MagickTrue,exception);            if (canvas == (Image *) NULL)            {                destination_image=DestroyImageList(destination_image);                return(destination_image);            }            AppendImageToList(&destination_image,canvas);            destination_image=GetLastImageInList(destination_image);//.........这里部分代码省略.........

//.........这里部分代码省略.........              image->colormap[i].green=ScaleCharToQuantum(*(p+map_length));              image->colormap[i].blue=ScaleCharToQuantum(*(p+map_length*2));              p++;            }        p=rle_pixels;        if (image->matte == MagickFalse)          {            /*              Convert raster image to PseudoClass pixel packets.            */            for (y=0; y < (long) image->rows; y++)            {              q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);              if (q == (PixelPacket *) NULL)                break;              indexes=GetAuthenticIndexQueue(image);              for (x=0; x < (long) image->columns; x++)                indexes[x]=(IndexPacket) (*p++);              if (SyncAuthenticPixels(image,exception) == MagickFalse)                break;              if (image->previous == (Image *) NULL)                {                  status=SetImageProgress(image,LoadImageTag,y,image->rows);                  if (status == MagickFalse)                    break;                }            }            (void) SyncImage(image);          }        else          {            /*              Image has a matte channel-- promote to DirectClass.            */            for (y=0; y < (long) image->rows; y++)            {              q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);              if (q == (PixelPacket *) NULL)                break;              for (x=0; x < (long) image->columns; x++)              {                q->red=image->colormap[*p++].red;                q->green=image->colormap[*p++].green;                q->blue=image->colormap[*p++].blue;                q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(*p++));                q++;              }              if (SyncAuthenticPixels(image,exception) == MagickFalse)                break;              if (image->previous == (Image *) NULL)                {                  status=SetImageProgress(image,LoadImageTag,y,image->rows);                  if (status == MagickFalse)                    break;                }            }            image->colormap=(PixelPacket *)              RelinquishMagickMemory(image->colormap);            image->storage_class=DirectClass;            image->colors=0;          }      }    if (number_colormaps != 0)      colormap=(unsigned char *) RelinquishMagickMemory(colormap);    rle_pixels=(unsigned char *) RelinquishMagickMemory(rle_pixels);    if (EOFBlob(image) != MagickFalse)      {        ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",          image->filename);        break;      }    /*      Proceed to next image.    */    if (image_info->number_scenes != 0)      if (image->scene >= (image_info->scene+image_info->number_scenes-1))        break;    (void) ReadBlobByte(image);    count=ReadBlob(image,2,(unsigned char *) magick);    if ((count != 0) && (memcmp(magick,"/122/314",2) == 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 ((count != 0) && (memcmp(magick,"/122/314",2) == 0));  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........    }  if (EOFBlob(image) != MagickFalse)    ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",      image->filename);  number_pixels=(MagickSizeType) fits_info.columns*fits_info.rows;  if ((fits_info.simple == MagickFalse) || (fits_info.number_axes < 1) ||      (fits_info.number_axes > 4) || (number_pixels == 0))    ThrowReaderException(CorruptImageError,"ImageTypeNotSupported");  for (scene=0; scene < (ssize_t) fits_info.number_planes; scene++)  {    image->columns=(size_t) fits_info.columns;    image->rows=(size_t) fits_info.rows;    image->depth=(size_t) (fits_info.bits_per_pixel < 0 ? -1 : 1)*      fits_info.bits_per_pixel;    image->endian=fits_info.endian;    image->scene=(size_t) scene;    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,exception);    if (status == MagickFalse)      return(DestroyImageList(image));    /*      Initialize image structure.    */    (void) SetImageColorspace(image,GRAYColorspace,exception);    if ((fits_info.min_data == 0.0) && (fits_info.max_data == 0.0))      {        if (fits_info.zero == 0.0)          (void) GetFITSPixelExtrema(image,fits_info.bits_per_pixel,            &fits_info.min_data,&fits_info.max_data);        else          fits_info.max_data=GetFITSPixelRange((size_t)            fits_info.bits_per_pixel);      }    else      fits_info.max_data=GetFITSPixelRange((size_t) fits_info.bits_per_pixel);    /*      Convert FITS pixels to pixel packets.    */    scale=QuantumRange/(fits_info.max_data-fits_info.min_data);    for (y=(ssize_t) image->rows-1; y >= 0; y--)    {      q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);      if (q == (Quantum *) NULL)        break;      for (x=0; x < (ssize_t) image->columns; x++)      {        pixel=GetFITSPixel(image,fits_info.bits_per_pixel);        if ((image->depth == 16) || (image->depth == 32) ||            (image->depth == 64))          SetFITSUnsignedPixels(1,image->depth,image->endian,            (unsigned char *) &pixel);        SetPixelGray(image,ClampToQuantum(scale*(fits_info.scale*(pixel-          fits_info.min_data)+fits_info.zero)),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;        }    }    if (EOFBlob(image) != MagickFalse)      {        ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",          image->filename);        break;      }    /*      Proceed to next image.    */    if (image_info->number_scenes != 0)      if (image->scene >= (image_info->scene+image_info->number_scenes-1))        break;    if (scene < (ssize_t) (fits_info.number_planes-1))      {        /*          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;      }  }  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ReadXCImage creates a constant image and initializes it to the%  X server color as specified by the filename.  It allocates the memory%  necessary for the new Image structure and returns a pointer to the new%  image.%%  The format of the ReadXCImage method is:%%      Image *ReadXCImage(const ImageInfo *image_info,ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image:  The image.%%    o image_info: the image info.%%    o exception: return any errors or warnings in this structure.%*/static Image *ReadXCImage(const ImageInfo *image_info,ExceptionInfo *exception){  Image    *image;  IndexPacket    index,    *indexes;  MagickBooleanType    status;  MagickPixelPacket    color;  PixelPacket    pixel;  register ssize_t    x;  register PixelPacket    *q;  ssize_t    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);  image=AcquireImage(image_info);  if (image->columns == 0)    image->columns=1;  if (image->rows == 0)    image->rows=1;  status=SetImageExtent(image,image->columns,image->rows);  if (status == MagickFalse)    {      InheritException(exception,&image->exception);      return(DestroyImageList(image));    }  (void) CopyMagickString(image->filename,image_info->filename,MaxTextExtent);  status=QueryMagickColor((char *) image_info->filename,&color,exception);  if (status == MagickFalse)    {      image=DestroyImage(image);      return((Image *) NULL);    }  (void) SetImageColorspace(image,color.colorspace);  image->matte=color.matte;  (void) ResetMagickMemory(&pixel,0,sizeof(pixel));  index=0;  SetPixelPacket(image,&color,&pixel,&index);  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++)      *q++=pixel;    if (image->colorspace == CMYKColorspace)      {        indexes=GetAuthenticIndexQueue(image);        for (x=0; x < (ssize_t) image->columns; x++)          SetPixelIndex(indexes+x,index);      }    if (SyncAuthenticPixels(image,exception) == MagickFalse)      break;  }  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........      Initialize image structure.    */    image->columns=width;    image->rows=height;    if (bits_per_pixel == 8)      if (AcquireImageColormap(image,256,exception) == MagickFalse)        ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");    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,exception);    if (status == MagickFalse)      return(DestroyImageList(image));    /*      Convert PIX raster image to pixel packets.    */    red=(Quantum) 0;    green=(Quantum) 0;    blue=(Quantum) 0;    index=0;    length=0;    for (y=0; y < (ssize_t) image->rows; y++)    {      q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);      if (q == (Quantum *) NULL)        break;      for (x=0; x < (ssize_t) image->columns; x++)      {        if (length == 0)          {            length=(size_t) ReadBlobByte(image);            if (bits_per_pixel == 8)              index=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));            else              {                blue=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));                green=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));                red=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));              }          }        if (image->storage_class == PseudoClass)          SetPixelIndex(image,index,q);        SetPixelBlue(image,blue,q);        SetPixelGreen(image,green,q);        SetPixelRed(image,red,q);        length--;        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;        }    }    if (image->storage_class == PseudoClass)      (void) SyncImage(image,exception);    if (EOFBlob(image) != MagickFalse)      {        ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",          image->filename);        break;      }    /*      Proceed to next image.    */    if (image_info->number_scenes != 0)      if (image->scene >= (image_info->scene+image_info->number_scenes-1))        break;    width=ReadBlobMSBLong(image);    height=ReadBlobMSBLong(image);    (void) ReadBlobMSBShort(image);    (void) ReadBlobMSBShort(image);    bits_per_pixel=ReadBlobMSBShort(image);    status=(width != 0UL) && (height == 0UL) && ((bits_per_pixel == 8) ||      (bits_per_pixel == 24)) ? MagickTrue : MagickFalse;    if (status != MagickFalse)      {        /*          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 (status != MagickFalse);  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........                  (void) sscanf(value,"%d +X %d",&height,&width);                  image->columns=(size_t) width;                  image->rows=(size_t) height;                  break;                }              (void) FormatLocaleString(tag,MaxTextExtent,"hdr:%s",keyword);              (void) SetImageProperty(image,tag,value,exception);              break;            }            default:            {              (void) FormatLocaleString(tag,MaxTextExtent,"hdr:%s",keyword);              (void) SetImageProperty(image,tag,value,exception);              break;            }          }        }    if ((image->columns == 0) && (image->rows == 0))      while (isspace((int) ((unsigned char) c)) != 0)        c=ReadBlobByte(image);  }  if ((LocaleCompare(format,"32-bit_rle_rgbe") != 0) &&      (LocaleCompare(format,"32-bit_rle_xyze") != 0))    ThrowReaderException(CorruptImageError,"ImproperImageHeader");  if ((image->columns == 0) || (image->rows == 0))    ThrowReaderException(CorruptImageError,"NegativeOrZeroImageSize");  if (LocaleCompare(format,"32-bit_rle_xyze") == 0)    image->colorspace=XYZColorspace;  image->compression=(image->columns < 8) || (image->columns > 0x7ffff) ?    NoCompression : RLECompression;  if (image_info->ping != MagickFalse)    {      (void) CloseBlob(image);      return(GetFirstImageInList(image));    }  /*    Read RGBE (red+green+blue+exponent) pixels.  */  pixels=(unsigned char *) AcquireQuantumMemory(image->columns,4*    sizeof(*pixels));  if (pixels == (unsigned char *) NULL)    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  for (y=0; y < (ssize_t) image->rows; y++)  {    if (image->compression != RLECompression)      {        count=ReadBlob(image,4*image->columns*sizeof(*pixels),pixels);        if (count != (ssize_t) (4*image->columns*sizeof(*pixels)))          break;      }    else      {        count=ReadBlob(image,4*sizeof(*pixel),pixel);        if (count != 4)          break;        if ((size_t) ((((size_t) pixel[2]) << 8) | pixel[3]) != image->columns)          {            (void) memcpy(pixels,pixel,4*sizeof(*pixel));            count=ReadBlob(image,4*(image->columns-1)*sizeof(*pixels),pixels+4);            image->compression=NoCompression;          }        else          {            p=pixels;            for (i=0; i < 4; i++)            {

//.........这里部分代码省略.........  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 MTV image.  */  (void) ReadBlobString(image,buffer);  count=(ssize_t) sscanf(buffer,"%lu %lu/n",&columns,&rows);  if (count <= 0)    ThrowReaderException(CorruptImageError,"ImproperImageHeader");  do  {    /*      Initialize image structure.    */    image->columns=columns;    image->rows=rows;    image->depth=8;    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,exception);    if (status == MagickFalse)      return(DestroyImageList(image));    /*      Convert MTV raster image to pixel packets.    */    pixels=(unsigned char *) AcquireQuantumMemory(image->columns,      3UL*sizeof(*pixels));    if (pixels == (unsigned char *) NULL)      ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");    for (y=0; y < (ssize_t) image->rows; y++)    {      count=(ssize_t) ReadBlob(image,(size_t) (3*image->columns),pixels);      if (count != (ssize_t) (3*image->columns))        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(*p++),q);        SetPixelGreen(image,ScaleCharToQuantum(*p++),q);        SetPixelBlue(image,ScaleCharToQuantum(*p++),q);        SetPixelAlpha(image,OpaqueAlpha,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;        }    }    pixels=(unsigned char *) RelinquishMagickMemory(pixels);    if (EOFBlob(image) != MagickFalse)      {        ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",          image->filename);        break;      }    /*      Proceed to next image.    */    if (image_info->number_scenes != 0)      if (image->scene >= (image_info->scene+image_info->number_scenes-1))        break;    *buffer='/0';    (void) ReadBlobString(image,buffer);    count=(ssize_t) sscanf(buffer,"%lu %lu/n",&columns,&rows);    if (count > 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 (count > 0);  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........      offset+=4;      if (cin.film.prefix != ~0UL)        (void) FormatImageProperty(image,"dpx:film.prefix","%.20g",(double)          cin.film.prefix);      cin.film.count=ReadBlobLong(image);      offset+=4;      offset+=ReadBlob(image,sizeof(cin.film.format),(unsigned char *)        cin.film.format);      (void) SetImageProperty(image,"dpx:film.format",cin.film.format);      cin.film.frame_position=ReadBlobLong(image);      offset+=4;      if (cin.film.frame_position != ~0UL)        (void) FormatImageProperty(image,"dpx:film.frame_position","%.20g",          (double) cin.film.frame_position);      cin.film.frame_rate=ReadBlobFloat(image);      offset+=4;      if (IsFloatDefined(cin.film.frame_rate) != MagickFalse)        (void) FormatImageProperty(image,"dpx:film.frame_rate","%g",          cin.film.frame_rate);      offset+=ReadBlob(image,sizeof(cin.film.frame_id),(unsigned char *)        cin.film.frame_id);      (void) SetImageProperty(image,"dpx:film.frame_id",cin.film.frame_id);      offset+=ReadBlob(image,sizeof(cin.film.slate_info),(unsigned char *)        cin.film.slate_info);      (void) SetImageProperty(image,"dpx:film.slate_info",cin.film.slate_info);      offset+=ReadBlob(image,sizeof(cin.film.reserve),(unsigned char *)        cin.film.reserve);    }  if ((cin.file.image_offset > 2048) && (cin.file.user_length != 0))    {      StringInfo        *profile;      /*        User defined data.      */      profile=BlobToStringInfo((const void *) NULL,cin.file.user_length);      if (profile == (StringInfo *) NULL)        ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");      offset+=ReadBlob(image,GetStringInfoLength(profile),        GetStringInfoDatum(profile));      (void) SetImageProfile(image,"dpx:user.data",profile);      profile=DestroyStringInfo(profile);    }  for ( ; offset < (MagickOffsetType) cin.file.image_offset; offset++)    (void) ReadBlobByte(image);  image->depth=cin.image.channel[0].bits_per_pixel;  image->columns=cin.image.channel[0].pixels_per_line;  image->rows=cin.image.channel[0].lines_per_image;  if (image_info->ping)    {      (void) CloseBlob(image);      return(image);    }  /*    Convert CIN raster image to pixel packets.  */  quantum_info=AcquireQuantumInfo(image_info,image);  if (quantum_info == (QuantumInfo *) NULL)    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  quantum_info->quantum=32;  quantum_info->pack=MagickFalse;  quantum_type=RGBQuantum;  pixels=GetQuantumPixels(quantum_info);  length=GetQuantumExtent(image,quantum_info,quantum_type);  length=GetBytesPerRow(image->columns,3,image->depth,MagickTrue);  if (cin.image.number_channels == 1)    {      quantum_type=GrayQuantum;      length=GetBytesPerRow(image->columns,1,image->depth,MagickTrue);    }  for (y=0; y < (ssize_t) image->rows; y++)  {    q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);    if (q == (PixelPacket *) NULL)      break;    count=ReadBlob(image,length,pixels);    if ((size_t) count != length)      break;    (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,      quantum_type,pixels,exception);    if (SyncAuthenticPixels(image,exception) == MagickFalse)      break;    if (image->previous == (Image *) NULL)      {        status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,          image->rows);        if (status == MagickFalse)          break;      }  }  SetQuantumImageType(image,quantum_type);  quantum_info=DestroyQuantumInfo(quantum_info);  if (EOFBlob(image) != MagickFalse)    ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",      image->filename);  SetImageColorspace(image,LogColorspace);  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........            &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2);      }    if (count != 4)      continue;    /*      Set PCL render geometry.    */    width=(size_t) floor(bounds.x2-bounds.x1+0.5);    height=(size_t) floor(bounds.y2-bounds.y1+0.5);    if (width > page.width)      page.width=width;    if (height > page.height)      page.height=height;  }  (void) CloseBlob(image);  /*    Render PCL with the GhostPCL delegate.  */  if ((page.width == 0) || (page.height == 0))    (void) ParseAbsoluteGeometry(PSPageGeometry,&page);  if (image_info->page != (char *) NULL)    (void) ParseAbsoluteGeometry(image_info->page,&page);  (void) FormatLocaleString(geometry,MagickPathExtent,"%.20gx%.20g",(double)    page.width,(double) page.height);  if (image_info->monochrome != MagickFalse)    delegate_info=GetDelegateInfo("pcl:mono",(char *) NULL,exception);  else     if (cmyk != MagickFalse)       delegate_info=GetDelegateInfo("pcl:cmyk",(char *) NULL,exception);     else       delegate_info=GetDelegateInfo("pcl:color",(char *) NULL,exception);  if (delegate_info == (const DelegateInfo *) NULL)    return((Image *) NULL);  if ((page.width == 0) || (page.height == 0))    (void) ParseAbsoluteGeometry(PSPageGeometry,&page);  if (image_info->page != (char *) NULL)    (void) ParseAbsoluteGeometry(image_info->page,&page);  density=AcquireString("");  options=AcquireString("");  (void) FormatLocaleString(density,MagickPathExtent,"%gx%g",image->resolution.x,    image->resolution.y);  page.width=(size_t) floor(page.width*image->resolution.x/delta.x+0.5);  page.height=(size_t) floor(page.height*image->resolution.y/delta.y+0.5);  (void) FormatLocaleString(options,MagickPathExtent,"-g%.20gx%.20g ",(double)     page.width,(double) page.height);  image=DestroyImage(image);  read_info=CloneImageInfo(image_info);  *read_info->magick='/0';  if (read_info->number_scenes != 0)    {      if (read_info->number_scenes != 1)        (void) FormatLocaleString(options,MagickPathExtent,"-dLastPage=%.20g",          (double) (read_info->scene+read_info->number_scenes));      else        (void) FormatLocaleString(options,MagickPathExtent,          "-dFirstPage=%.20g -dLastPage=%.20g",(double) read_info->scene+1,          (double) (read_info->scene+read_info->number_scenes));      read_info->number_scenes=0;      if (read_info->scenes != (char *) NULL)        *read_info->scenes='/0';    }  (void) CopyMagickString(filename,read_info->filename,MagickPathExtent);  (void) AcquireUniqueFilename(read_info->filename);  (void) FormatLocaleString(command,MagickPathExtent,    GetDelegateCommands(delegate_info),    read_info->antialias != MagickFalse ? 4 : 1,    read_info->antialias != MagickFalse ? 4 : 1,density,options,    read_info->filename,input_filename);  options=DestroyString(options);  density=DestroyString(density);  status=ExternalDelegateCommand(MagickFalse,read_info->verbose,command,    (char *) NULL,exception) != 0 ? MagickTrue : MagickFalse;  image=ReadImage(read_info,exception);  (void) RelinquishUniqueFileResource(read_info->filename);  (void) RelinquishUniqueFileResource(input_filename);  read_info=DestroyImageInfo(read_info);  if (image == (Image *) NULL)    ThrowReaderException(DelegateError,"PCLDelegateFailed");  if (LocaleCompare(image->magick,"BMP") == 0)    {      Image        *cmyk_image;      cmyk_image=ConsolidateCMYKImages(image,exception);      if (cmyk_image != (Image *) NULL)        {          image=DestroyImageList(image);          image=cmyk_image;        }    }  do  {    (void) CopyMagickString(image->filename,filename,MagickPathExtent);    image->page=page;    next_image=SyncNextImageInList(image);    if (next_image != (Image *) NULL)      image=next_image;  } while (next_image != (Image *) NULL);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........  else if (dds_info.pixelformat.flags & DDPF_FOURCC)    {      switch (dds_info.pixelformat.fourcc)      {        case FOURCC_DXT1:        {          matte = MagickFalse;          compression = DXT1Compression;          decoder = ReadDXT1;          break;        }                case FOURCC_DXT3:        {          matte = MagickTrue;          compression = DXT3Compression;          decoder = ReadDXT3;          break;        }                case FOURCC_DXT5:        {          matte = MagickTrue;          compression = DXT5Compression;          decoder = ReadDXT5;          break;        }                default:        {          /* Unknown FOURCC */          ThrowReaderException(CorruptImageError, "ImageTypeNotSupported");        }      }    }  else    {      /* Neither compressed nor uncompressed... thus unsupported */      ThrowReaderException(CorruptImageError, "ImageTypeNotSupported");    }    num_images = 1;  if (cubemap)    {      /*        Determine number of faces defined in the cubemap      */      num_images = 0;      if (dds_info.ddscaps2 & DDSCAPS2_CUBEMAP_POSITIVEX) num_images++;      if (dds_info.ddscaps2 & DDSCAPS2_CUBEMAP_NEGATIVEX) num_images++;      if (dds_info.ddscaps2 & DDSCAPS2_CUBEMAP_POSITIVEY) num_images++;      if (dds_info.ddscaps2 & DDSCAPS2_CUBEMAP_NEGATIVEY) num_images++;      if (dds_info.ddscaps2 & DDSCAPS2_CUBEMAP_POSITIVEZ) num_images++;      if (dds_info.ddscaps2 & DDSCAPS2_CUBEMAP_NEGATIVEZ) num_images++;    }    if (volume)    num_images = dds_info.depth;    for (n = 0; n < num_images; n++)  {    if (n != 0)      {        /* Start a new image */        AcquireNextImage(image_info,image);        if (GetNextImageInList(image) == (Image *) NULL)          {            image = DestroyImageList(image);            return((Image *) NULL);          }        image=SyncNextImageInList(image);      }        image->matte = matte;    image->compression = compression;    image->columns = dds_info.width;    image->rows = dds_info.height;    image->storage_class = DirectClass;    image->endian = LSBEndian;    image->depth = 8;    if (image_info->ping != MagickFalse)      {        (void) CloseBlob(image);        return(GetFirstImageInList(image));      }        if ((decoder)(image, &dds_info) != MagickTrue)      {        (void) CloseBlob(image);        return(GetFirstImageInList(image));      }  }    if (EOFBlob(image) != MagickFalse)    ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",      image->filename);    (void) CloseBlob(image);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........          high,          low;        /*          Auto fit text into bounding box.        */        for ( ; ; draw_info->pointsize*=2.0)        {          (void) FormatLocaleString(geometry,MaxTextExtent,"%+g%+g",            -metrics.bounds.x1,metrics.ascent);          if (draw_info->gravity == UndefinedGravity)            (void) CloneString(&draw_info->geometry,geometry);          status=GetMultilineTypeMetrics(image,draw_info,&metrics,exception);          width=(size_t) floor(metrics.width+draw_info->stroke_width+0.5);          height=(size_t) floor(metrics.height+draw_info->stroke_width+0.5);          if ((image->columns != 0) && (image->rows != 0))            {              if ((width >= image->columns) && (height >= image->rows))                break;            }          else            if (((image->columns != 0) && (width >= image->columns)) ||                ((image->rows != 0) && (height >= image->rows)))              break;        }        high=draw_info->pointsize;        for (low=1.0; (high-low) > 0.5; )        {          draw_info->pointsize=(low+high)/2.0;          (void) FormatLocaleString(geometry,MaxTextExtent,"%+g%+g",            -metrics.bounds.x1,metrics.ascent);          if (draw_info->gravity == UndefinedGravity)            (void) CloneString(&draw_info->geometry,geometry);          status=GetMultilineTypeMetrics(image,draw_info,&metrics,exception);          width=(size_t) floor(metrics.width+draw_info->stroke_width+0.5);          height=(size_t) floor(metrics.height+draw_info->stroke_width+0.5);          if ((image->columns != 0) && (image->rows != 0))            {              if ((width < image->columns) && (height < image->rows))                low=draw_info->pointsize+0.5;              else                high=draw_info->pointsize-0.5;            }          else            if (((image->columns != 0) && (width < image->columns)) ||                ((image->rows != 0) && (height < image->rows)))              low=draw_info->pointsize+0.5;            else              high=draw_info->pointsize-0.5;        }        draw_info->pointsize=(low+high)/2.0-0.5;      }  status=GetMultilineTypeMetrics(image,draw_info,&metrics,exception);  if (status == MagickFalse)    {      image=DestroyImageList(image);      return((Image *) NULL);    }  if (image->columns == 0)    image->columns=(size_t) (metrics.width+draw_info->stroke_width+0.5);  if (image->columns == 0)    image->columns=(size_t) (draw_info->pointsize+draw_info->stroke_width+0.5);  if (image->rows == 0)    image->rows=(size_t) (metrics.ascent-metrics.descent+      draw_info->stroke_width+0.5);  if (image->rows == 0)    image->rows=(size_t) (draw_info->pointsize+draw_info->stroke_width+0.5);  if (draw_info->gravity == UndefinedGravity)    {      (void) FormatLocaleString(geometry,MaxTextExtent,"%+g%+g",        -metrics.bounds.x1+draw_info->stroke_width/2.0,metrics.ascent+        draw_info->stroke_width/2.0);      (void) CloneString(&draw_info->geometry,geometry);    }  if (draw_info->direction == RightToLeftDirection)    {      if (draw_info->direction == RightToLeftDirection)        (void) FormatLocaleString(geometry,MaxTextExtent,"%+g%+g",          image->columns-(metrics.bounds.x2+draw_info->stroke_width/2.0),          metrics.ascent+draw_info->stroke_width/2.0);      (void) CloneString(&draw_info->geometry,geometry);    }  if (SetImageBackgroundColor(image,exception) == MagickFalse)    {      image=DestroyImageList(image);      return((Image *) NULL);    }  (void) AnnotateImage(image,draw_info,exception);  if (image_info->pointsize == 0.0)    {      char        pointsize[MaxTextExtent];      (void) FormatLocaleString(pointsize,MaxTextExtent,"%.20g",        draw_info->pointsize);      (void) SetImageProperty(image,"label:pointsize",pointsize,exception);    }  draw_info=DestroyDrawInfo(draw_info);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........            switch (depth)            {              default:                ThrowReaderException(CorruptImageError,                  "ImageDepthNotSupported");              case 8:              {                unsigned char                  pixel;                for (i=0; i < (long) image->colors; i++)                {                  p=PushCharPixel(p,&pixel);                  image->colormap[i].red=ScaleCharToQuantum(pixel);                  p=PushCharPixel(p,&pixel);                  image->colormap[i].green=ScaleCharToQuantum(pixel);                  p=PushCharPixel(p,&pixel);                  image->colormap[i].blue=ScaleCharToQuantum(pixel);                }                break;              }              case 16:              {                unsigned short                  pixel;                for (i=0; i < (long) image->colors; i++)                {                  p=PushShortPixel(MSBEndian,p,&pixel);                  image->colormap[i].red=ScaleShortToQuantum(pixel);                  p=PushShortPixel(MSBEndian,p,&pixel);                  image->colormap[i].green=ScaleShortToQuantum(pixel);                  p=PushShortPixel(MSBEndian,p,&pixel);                  image->colormap[i].blue=ScaleShortToQuantum(pixel);                }                break;              }              case 32:              {                unsigned long                  pixel;                for (i=0; i < (long) image->colors; i++)                {                  p=PushLongPixel(MSBEndian,p,&pixel);                  image->colormap[i].red=ScaleLongToQuantum(pixel);                  p=PushLongPixel(MSBEndian,p,&pixel);                  image->colormap[i].green=ScaleLongToQuantum(pixel);                  p=PushLongPixel(MSBEndian,p,&pixel);                  image->colormap[i].blue=ScaleLongToQuantum(pixel);                }                break;              }            }            colormap=(unsigned char *) RelinquishMagickMemory(colormap);          }      }    if (EOFBlob(image) != MagickFalse)      {        ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",          image->filename);        break;      }    if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))      if (image->scene >= (image_info->scene+image_info->number_scenes-1))        break;    /*      Attach persistent pixel cache.    */    status=PersistPixelCache(image,cache_filename,MagickTrue,&offset,exception);    if (status == MagickFalse)      ThrowReaderException(CacheError,"UnableToPersistPixelCache");    /*      Proceed to next image.    */    do    {      c=ReadBlobByte(image);    } while ((isgraph(c) == MagickFalse) && (c != EOF));    if (c != EOF)      {        /*          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 (c != EOF);  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........  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);    }  image->columns = 256;  image->rows = 192;  status=SetImageExtent(image,image->columns,image->rows,exception);  if (status == MagickFalse)    return(DestroyImageList(image));  count=ReadBlob(image,6144,(unsigned char *) zxscr);  (void) count;  count=ReadBlob(image,768,(unsigned char *) zxattr);  for(zonenr=0;zonenr<3;zonenr++)  {      for(zoneline=0;zoneline<8;zoneline++)        {        for(octetline=0;octetline<8;octetline++)      {          for(octetnr=(zoneline*32);octetnr<((zoneline*32)+32);octetnr++)            {            octet_val = zxscr[octetnr+(256*octetline)+(zonenr*2048)];            attr_nr = zxattr[octetnr+(256*zonenr)];            pix = (((8*octetnr)-(256*zoneline)));            piy = ((octetline+(8*zoneline)+(zonenr*64)));            pbin = binar;            abin = attrbin;            one_nr=1;            for(z=0;z<8;z++)          {              if(octet_val&one_nr)            {                *pbin = 1;            } else {                *pbin = 0;            }              one_nr=one_nr*2;              pbin++;          }            one_nr = 1;            for(z=0;z<8;z++)          {              if(attr_nr&one_nr)            {                *abin = 1;            } else {                *abin = 0;            }              one_nr=one_nr*2;              abin++;          }            ink = (attrbin[0]+(2*attrbin[1])+(4*attrbin[2]));            paper = (attrbin[3]+(2*attrbin[4])+(4*attrbin[5]));            bright = attrbin[6];            if(bright) { ink=ink+8; paper=paper+8; }            for(z=7;z>-1;z--)          {              q=QueueAuthenticPixels(image,pix,piy,1,1,exception);              if (q == (Quantum *) NULL)                break;              if(binar[z])            {                SetPixelRed(image,ScaleCharToQuantum(                  colour_palette[3*ink]),q);                SetPixelGreen(image,ScaleCharToQuantum(                  colour_palette[1+(3*ink)]),q);                SetPixelBlue(image,ScaleCharToQuantum(                  colour_palette[2+(3*ink)]),q);            } else {                SetPixelRed(image,ScaleCharToQuantum(                  colour_palette[3*paper]),q);                SetPixelGreen(image,ScaleCharToQuantum(                  colour_palette[1+(3*paper)]),q);                SetPixelBlue(image,ScaleCharToQuantum(                  colour_palette[2+(3*paper)]),q);            }              pix++;          }        }      }    }  }  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........      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=(long) ReadBlob(image,MagickMaxBufferExtent,buffer);    if (length == 0)      break;    p=buffer;    count=0;    while ((length > 0) && ((status == JBG_EAGAIN) || (status == JBG_EOK)))    {      size_t        count;      status=jbg_dec_in(&jbig_info,p,length,&count);      p+=count;      length-=(long) count;    }  } while ((status == JBG_EAGAIN) || (status == JBG_EOK));  /*    Create colormap.  */  image->columns=jbg_dec_getwidth(&jbig_info);  image->rows=jbg_dec_getheight(&jbig_info);  if (AcquireImageColormap(image,2) == MagickFalse)    {      buffer=(unsigned char *) RelinquishMagickMemory(buffer);      ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");    }  image->colormap[0].red=0;  image->colormap[0].green=0;  image->colormap[0].blue=0;  image->colormap[1].red=QuantumRange;  image->colormap[1].green=QuantumRange;  image->colormap[1].blue=QuantumRange;  image->x_resolution=300;  image->y_resolution=300;  if (image_info->ping != MagickFalse)    {      (void) CloseBlob(image);      return(GetFirstImageInList(image));    }  /*    Convert X bitmap image to pixel packets.  */  p=jbg_dec_getimage(&jbig_info,0);  for (y=0; y < (long) image->rows; y++)  {    q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);    if (q == (PixelPacket *) NULL)      break;    indexes=GetAuthenticIndexQueue(image);    bit=0;    byte=0;    for (x=0; x < (long) image->columns; x++)    {      if (bit == 0)        byte=(*p++);      index=(byte & 0x80) ? 0 : 1;      bit++;      byte<<=1;      if (bit == 8)        bit=0;      indexes[x]=index;      *q++=image->colormap[(long) index];    }    if (SyncAuthenticPixels(image,exception) == MagickFalse)      break;    status=SetImageProgress(image,LoadImageTag,y,image->rows);    if (status == MagickFalse)      break;  }  /*    Free scale resource.  */  jbg_dec_free(&jbig_info);  buffer=(unsigned char *) RelinquishMagickMemory(buffer);  (void) CloseBlob(image);  return(GetFirstImageInList(image));}

//.........这里部分代码省略.........  while (ReadBlobString(image,buffer) != (char *) NULL)  {    if (sscanf(buffer,"static short %32s = {",name) == 1)      version=10;    else      if (sscanf(buffer,"static unsigned char %32s = {",name) == 1)        version=11;      else        if (sscanf(buffer,"static char %32s = {",name) == 1)          version=11;        else          continue;    p=(unsigned char *) strrchr(name,'_');    if (p == (unsigned char *) NULL)      p=(unsigned char *) name;    else      p++;    if (LocaleCompare("bits[]",(char *) p) == 0)      break;  }  if ((image->columns == 0) || (image->rows == 0) ||      (EOFBlob(image) != MagickFalse))    ThrowReaderException(CorruptImageError,"ImproperImageHeader");  /*    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));    }  status=SetImageExtent(image,image->columns,image->rows,exception);  if (status == MagickFalse)    return(DestroyImageList(image));  /*    Initialize hex values.  */  hex_digits[(int) '0']=0;  hex_digits[(int) '1']=1;  hex_digits[(int) '2']=2;  hex_digits[(int) '3']=3;  hex_digits[(int) '4']=4;  hex_digits[(int) '5']=5;  hex_digits[(int) '6']=6;  hex_digits[(int) '7']=7;  hex_digits[(int) '8']=8;  hex_digits[(int) '9']=9;  hex_digits[(int) 'A']=10;  hex_digits[(int) 'B']=11;  hex_digits[(int) 'C']=12;  hex_digits[(int) 'D']=13;  hex_digits[(int) 'E']=14;  hex_digits[(int) 'F']=15;  hex_digits[(int) 'a']=10;  hex_digits[(int) 'b']=11;  hex_digits[(int) 'c']=12;  hex_digits[(int) 'd']=13;  hex_digits[(int) 'e']=14;  hex_digits[(int) 'f']=15;  hex_digits[(int) 'x']=0;  hex_digits[(int) ' ']=(-1);  hex_digits[(int) ',']=(-1);  hex_digits[(int) '}']=(-1);  hex_digits[(int) '/n']=(-1);  hex_digits[(int) '/t']=(-1);  /*    Read hex image data.  */  padding=0;  if (((image->columns % 16) != 0) && ((image->columns % 16) < 9) &&      (version == 10))    padding=1;  bytes_per_line=(unsigned int) (image->columns+7)/8+padding;  length=(unsigned int) image->rows;  data=(unsigned char *) AcquireQuantumMemory(length,bytes_per_line*    sizeof(*data));  if (data == (unsigned char *) NULL)    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  p=data;  if (version == 10)    for (i=0; i < (ssize_t) (bytes_per_line*image->rows); (i+=2))    {      value=XBMInteger(image,hex_digits);      *p++=(unsigned char) value;      if ((padding == 0) || (((i+2) % bytes_per_line) != 0))        *p++=(unsigned char) (value >> 8);    }  else    for (i=0; i < (ssize_t) (bytes_per_line*image->rows); i++)

//.........这里部分代码省略.........  int    number_files;  MagickBooleanType    status;  MontageInfo    *montage_info;  RectangleInfo    geometry;  register ssize_t    i;  /*    Expand the filename.  */  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);  filelist=(char **) AcquireMagickMemory(sizeof(*filelist));  if (filelist == (char **) NULL)    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  filelist[0]=ConstantString(image_info->filename);  number_files=1;  status=ExpandFilenames(&number_files,&filelist);  if ((status == MagickFalse) || (number_files == 0))    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  image=DestroyImage(image);  /*    Read each image and convert them to a tile.  */  images=NewImageList();  read_info=CloneImageInfo(image_info);  SetImageInfoBlob(read_info,(void *) NULL,0);  (void) SetImageInfoProgressMonitor(read_info,(MagickProgressMonitor) NULL,    (void *) NULL);  if (read_info->size == (char *) NULL)    (void) CloneString(&read_info->size,DefaultTileGeometry);  for (i=0; i < (ssize_t) number_files; i++)  {    if (image_info->debug != MagickFalse)      (void) LogMagickEvent(CoderEvent,GetMagickModule(),"name: %s",        filelist[i]);    (void) CopyMagickString(read_info->filename,filelist[i],MaxTextExtent);    filelist[i]=DestroyString(filelist[i]);    *read_info->magick='/0';    next_image=ReadImage(read_info,exception);    CatchException(exception);    if (next_image == (Image *) NULL)      break;    label=InterpretImageProperties(image_info,next_image,DefaultTileLabel);    (void) SetImageProperty(next_image,"label",label);    label=DestroyString(label);    if (image_info->debug != MagickFalse)      (void) LogMagickEvent(CoderEvent,GetMagickModule(),        "geometry: %.20gx%.20g",(double) next_image->columns,(double)        next_image->rows);    SetGeometry(next_image,&geometry);    (void) ParseMetaGeometry(read_info->size,&geometry.x,&geometry.y,      &geometry.width,&geometry.height);    thumbnail_image=ThumbnailImage(next_image,geometry.width,geometry.height,      exception);    if (thumbnail_image != (Image *) NULL)      {        next_image=DestroyImage(next_image);        next_image=thumbnail_image;      }    if (image_info->debug != MagickFalse)      (void) LogMagickEvent(CoderEvent,GetMagickModule(),        "thumbnail geometry: %.20gx%.20g",(double) next_image->columns,(double)        next_image->rows);    AppendImageToList(&images,next_image);    status=SetImageProgress(images,LoadImagesTag,i,number_files);    if (status == MagickFalse)      break;  }  read_info=DestroyImageInfo(read_info);  filelist=(char **) RelinquishMagickMemory(filelist);  if (images == (Image *) NULL)    ThrowReaderException(CorruptImageError,      "ImageFileDoesNotContainAnyImageData");  /*    Create the visual image directory.  */  montage_info=CloneMontageInfo(image_info,(MontageInfo *) NULL);  if (image_info->debug != MagickFalse)    (void) LogMagickEvent(CoderEvent,GetMagickModule(),"creating montage");  montage_image=MontageImageList(image_info,montage_info,    GetFirstImageInList(images),exception);  montage_info=DestroyMontageInfo(montage_info);  images=DestroyImageList(images);  return(montage_image);}