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

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   W r i t e D E B U G I m a g e                                             %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  WriteDEBUGImage writes the image pixel values with 20 places of precision.%%  The format of the WriteDEBUGImage method is:%%      MagickBooleanType WriteDEBUGImage(const ImageInfo *image_info,%        Image *image,ExceptionInfo *exception)%%  A description of each parameter follows.%%    o image_info: the image info.%%    o image:  The image.%%    o exception: return any errors or warnings in this structure.%*/static MagickBooleanType WriteDEBUGImage(const ImageInfo *image_info,  Image *image,ExceptionInfo *exception){  char    buffer[MagickPathExtent],    colorspace[MagickPathExtent],    tuple[MagickPathExtent];  ssize_t    y;  MagickBooleanType    status;  MagickOffsetType    scene;  PixelInfo    pixel;  register const Quantum    *p;  register ssize_t    x;  /*    Open output image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  status=OpenBlob(image_info,image,WriteBlobMode,exception);  if (status == MagickFalse)    return(status);  scene=0;  do  {    (void) CopyMagickString(colorspace,CommandOptionToMnemonic(      MagickColorspaceOptions,(ssize_t) image->colorspace),MagickPathExtent);    LocaleLower(colorspace);    image->depth=GetImageQuantumDepth(image,MagickTrue);    if (image->alpha_trait != UndefinedPixelTrait)      (void) ConcatenateMagickString(colorspace,"a",MagickPathExtent);    (void) FormatLocaleString(buffer,MagickPathExtent,      "# ImageMagick pixel debugging: %.20g,%.20g,%.20g,%s/n",(double)      image->columns,(double) image->rows,(double) ((MagickOffsetType)      GetQuantumRange(image->depth)),colorspace);    (void) WriteBlobString(image,buffer);    GetPixelInfo(image,&pixel);    for (y=0; y < (ssize_t) image->rows; y++)    {      p=GetVirtualPixels(image,0,y,image->columns,1,exception);      if (p == (const Quantum *) NULL)        break;      for (x=0; x < (ssize_t) image->columns; x++)      {        (void) FormatLocaleString(buffer,MagickPathExtent,"%.20g,%.20g: ",(double)          x,(double) y);        (void) WriteBlobString(image,buffer);        GetPixelInfoPixel(image,p,&pixel);        (void) FormatLocaleString(tuple,MagickPathExtent,"%.20g,%.20g,%.20g ",          (double) pixel.red,(double) pixel.green,(double) pixel.blue);        if (pixel.colorspace == CMYKColorspace)          {            char              black[MagickPathExtent];            (void) FormatLocaleString(black,MagickPathExtent,",%.20g ",              (double) pixel.black);//.........这里部分代码省略.........

//.........这里部分代码省略.........        (void) FormatLocaleString(buffer,MagickPathExtent,"/033*b2M");        (void) WriteBlobString(image,buffer);        break;      }      default:      {        compress_pixels=(unsigned char *) AcquireQuantumMemory(3*length+256,          sizeof(*compress_pixels));        if (compress_pixels == (unsigned char *) NULL)          {            pixels=(unsigned char *) RelinquishMagickMemory(pixels);            ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");          }        (void) ResetMagickMemory(compress_pixels,0,(3*length+256)*          sizeof(*compress_pixels));        previous_pixels=(unsigned char *) AcquireQuantumMemory(length+1,          sizeof(*previous_pixels));        if (previous_pixels == (unsigned char *) NULL)          {            compress_pixels=(unsigned char *) RelinquishMagickMemory(              compress_pixels);            pixels=(unsigned char *) RelinquishMagickMemory(pixels);            ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");          }        (void) ResetMagickMemory(previous_pixels,0,(length+1)*          sizeof(*previous_pixels));        (void) FormatLocaleString(buffer,MagickPathExtent,"/033*b3M");        (void) WriteBlobString(image,buffer);        break;      }    }    for (y=0; y < (ssize_t) image->rows; y++)    {      p=GetVirtualPixels(image,0,y,image->columns,1,exception);      if (p == (const Quantum *) NULL)        break;      q=pixels;      switch (bits_per_pixel)      {        case 1:        {          register unsigned char            bit,            byte;          /*            Monochrome image.          */          bit=0;          byte=0;          for (x=0; x < (ssize_t) image->columns; x++)          {            byte<<=1;            if (GetPixelLuma(image,p) < (QuantumRange/2.0))              byte|=0x01;            bit++;            if (bit == 8)              {                *q++=byte;                bit=0;                byte=0;              }            p+=GetPixelChannels(image);          }          if (bit != 0)            *q++=byte << (8-bit);

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

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   I m a g e T o H B i t m a p                                               %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ImageToHBITMAP() creates a Windows HBITMAP from an image.%%  The format of the ImageToHBITMAP method is:%%      HBITMAP ImageToHBITMAP(Image *image,Exceptioninfo *exception)%%  A description of each parameter follows:%%    o image: the image to convert.%*/MagickExport void *ImageToHBITMAP(Image *image,ExceptionInfo *exception){  BITMAP    bitmap;  HANDLE    bitmap_bitsH;  HBITMAP    bitmapH;  register ssize_t    x;  register const Quantum    *p;  register RGBQUAD    *q;  RGBQUAD    *bitmap_bits;  size_t    length;  ssize_t    y;  (void) ResetMagickMemory(&bitmap,0,sizeof(bitmap));  bitmap.bmType=0;  bitmap.bmWidth=(LONG) image->columns;  bitmap.bmHeight=(LONG) image->rows;  bitmap.bmWidthBytes=4*bitmap.bmWidth;  bitmap.bmPlanes=1;  bitmap.bmBitsPixel=32;  bitmap.bmBits=NULL;  length=bitmap.bmWidthBytes*bitmap.bmHeight;  bitmap_bitsH=(HANDLE) GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,length);  if (bitmap_bitsH == NULL)    {      char        *message;      message=GetExceptionMessage(errno);      (void) ThrowMagickException(exception,GetMagickModule(),        ResourceLimitError,"MemoryAllocationFailed","`%s'",message);      message=DestroyString(message);      return(NULL);    }  bitmap_bits=(RGBQUAD *) GlobalLock((HGLOBAL) bitmap_bitsH);  q=bitmap_bits;  if (bitmap.bmBits == NULL)    bitmap.bmBits=bitmap_bits;  (void) SetImageColorspace(image,sRGBColorspace,exception);  for (y=0; y < (ssize_t) image->rows; y++)  {    p=GetVirtualPixels(image,0,y,image->columns,1,exception);    if (p == (const Quantum *) NULL)      break;    for (x=0; x < (ssize_t) image->columns; x++)    {      q->rgbRed=ScaleQuantumToChar(GetPixelRed(image,p));      q->rgbGreen=ScaleQuantumToChar(GetPixelGreen(image,p));      q->rgbBlue=ScaleQuantumToChar(GetPixelBlue(image,p));      q->rgbReserved=0;      p+=GetPixelChannels(image);      q++;    }  }  bitmap.bmBits=bitmap_bits;  bitmapH=CreateBitmapIndirect(&bitmap);  if (bitmapH == NULL)    {      char        *message;      message=GetExceptionMessage(errno);//.........这里部分代码省略.........

//.........这里部分代码省略.........          break;        indexes=GetAuthenticIndexQueue(picon);        for (x=0; x < (ssize_t) picon->columns; x++)        {          if (q->opacity == (Quantum) TransparentOpacity)            SetPixelIndex(indexes+x,picon->colors);          q++;        }        if (SyncAuthenticPixels(picon,exception) == MagickFalse)          break;      }    }  /*    Compute the character per pixel.  */  characters_per_pixel=1;  for (k=MaxCixels; (ssize_t) colors > k; k*=MaxCixels)    characters_per_pixel++;  /*    XPM header.  */  (void) WriteBlobString(image,"/* XPM *//n");  GetPathComponent(picon->filename,BasePath,basename);  (void) FormatLocaleString(buffer,MaxTextExtent,    "static char *%s[] = {/n",basename);  (void) WriteBlobString(image,buffer);  (void) WriteBlobString(image,"/* columns rows colors chars-per-pixel *//n");  (void) FormatLocaleString(buffer,MaxTextExtent,    "/"%.20g %.20g %.20g %.20g/",/n",(double) picon->columns,(double)    picon->rows,(double) colors,(double) characters_per_pixel);  (void) WriteBlobString(image,buffer);  GetMagickPixelPacket(image,&pixel);  for (i=0; i < (ssize_t) colors; i++)  {    /*      Define XPM color.    */    SetMagickPixelPacket(image,picon->colormap+i,(IndexPacket *) NULL,&pixel);    pixel.colorspace=sRGBColorspace;    pixel.depth=8;    pixel.opacity=(MagickRealType) OpaqueOpacity;    (void) QueryMagickColorname(image,&pixel,XPMCompliance,name,      &image->exception);    if (transparent != MagickFalse)      {        if (i == (ssize_t) (colors-1))          (void) CopyMagickString(name,"grey75",MaxTextExtent);      }    /*      Write XPM color.    */    k=i % MaxCixels;    symbol[0]=Cixel[k];    for (j=1; j < (ssize_t) characters_per_pixel; j++)    {      k=((i-k)/MaxCixels) % MaxCixels;      symbol[j]=Cixel[k];    }    symbol[j]='/0';    (void) FormatLocaleString(buffer,MaxTextExtent,"/"%s c %s/",/n",       symbol,name);    (void) WriteBlobString(image,buffer);  }  /*    Define XPM pixels.  */  (void) WriteBlobString(image,"/* pixels *//n");  for (y=0; y < (ssize_t) picon->rows; y++)  {    p=GetVirtualPixels(picon,0,y,picon->columns,1,&picon->exception);    if (p == (const PixelPacket *) NULL)      break;    indexes=GetVirtualIndexQueue(picon);    (void) WriteBlobString(image,"/"");    for (x=0; x < (ssize_t) picon->columns; x++)    {      k=((ssize_t) GetPixelIndex(indexes+x) % MaxCixels);      symbol[0]=Cixel[k];      for (j=1; j < (ssize_t) characters_per_pixel; j++)      {        k=(((int) GetPixelIndex(indexes+x)-k)/MaxCixels) % MaxCixels;        symbol[j]=Cixel[k];      }      symbol[j]='/0';      (void) CopyMagickString(buffer,symbol,MaxTextExtent);      (void) WriteBlobString(image,buffer);    }    (void) FormatLocaleString(buffer,MaxTextExtent,"/"%s/n",      y == (ssize_t) (picon->rows-1) ? "" : ",");    (void) WriteBlobString(image,buffer);    status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,      picon->rows);    if (status == MagickFalse)      break;  }  picon=DestroyImage(picon);  (void) WriteBlobString(image,"};/n");  (void) CloseBlob(image);  return(MagickTrue);}

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

//.........这里部分代码省略.........      jas_image_setcmpttype(jp2_image,2,        JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));      if (number_components == 4)        jas_image_setcmpttype(jp2_image,3,JAS_IMAGE_CT_OPACITY);    }  /*    Convert to JPEG 2000 pixels.  */  for (i=0; i < (long) number_components; i++)  {    pixels[i]=jas_matrix_create(1,(int) image->columns);    if (pixels[i] == (jas_matrix_t *) NULL)      {        for (x=0; x < i; x++)          jas_matrix_destroy(pixels[x]);        jas_image_destroy(jp2_image);        ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");      }  }  range=GetQuantumRange((unsigned long) component_info[0].prec);  map=(unsigned short *) AcquireQuantumMemory(MaxMap+1,sizeof(*map));  for (i=0; i <= (long) MaxMap; i++)    map[i]=(unsigned short) ScaleQuantumToMap((Quantum)      ScaleQuantumToAny((Quantum) i,range));  if (map == (unsigned short *) NULL)    {      for (i=0; i < (long) number_components; i++)        jas_matrix_destroy(pixels[i]);      jas_image_destroy(jp2_image);      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");    }  for (y=0; y < (long) image->rows; y++)  {    p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);    if (p == (const PixelPacket *) NULL)      break;    for (x=0; x < (long) image->columns; x++)    {      if (number_components == 1)        jas_matrix_setv(pixels[0],x,map[ScaleQuantumToMap(          PixelIntensityToQuantum(p))]);      else        {          jas_matrix_setv(pixels[0],x,map[ScaleQuantumToMap(p->red)]);          jas_matrix_setv(pixels[1],x,map[ScaleQuantumToMap(p->green)]);          jas_matrix_setv(pixels[2],x,map[ScaleQuantumToMap(p->blue)]);          if (number_components > 3)            jas_matrix_setv(pixels[3],x,map[ScaleQuantumToMap((Quantum)              (QuantumRange-p->opacity))]);        }      p++;    }    for (i=0; i < (long) number_components; i++)      (void) jas_image_writecmpt(jp2_image,(short) i,0,(unsigned int) y,        (unsigned int) image->columns,1,pixels[i]);    status=SetImageProgress(image,SaveImageTag,y,image->rows);    if (status == MagickFalse)      break;  }  map=(unsigned short *) RelinquishMagickMemory(map);  (void) CopyMagickString(magick,image_info->magick,MaxTextExtent);  LocaleLower(magick);  format=jas_image_strtofmt(magick);  options=(char *) NULL;  ResetImageOptionIterator(image_info);  key=GetNextImageOption(image_info);

//.........这里部分代码省略.........    {      /*        Unknow.      */      jas_image_setclrspc(jp2_image,JAS_CLRSPC_UNKNOWN);      jas_image_setcmpttype(jp2_image,0,(jas_image_cmpttype_t)        JAS_IMAGE_CT_COLOR(0));      jas_image_setcmpttype(jp2_image,1,(jas_image_cmpttype_t)        JAS_IMAGE_CT_COLOR(1));      jas_image_setcmpttype(jp2_image,2,(jas_image_cmpttype_t)        JAS_IMAGE_CT_COLOR(2));      if (number_components == 4)        jas_image_setcmpttype(jp2_image,3,JAS_IMAGE_CT_OPACITY);      break;    }  }  /*    Convert to JPEG 2000 pixels.  */  for (i=0; i < (ssize_t) number_components; i++)  {    pixels[i]=jas_matrix_create(1,(int) image->columns);    if (pixels[i] == (jas_matrix_t *) NULL)      {        for (x=0; x < i; x++)          jas_matrix_destroy(pixels[x]);        jas_image_destroy(jp2_image);        ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");      }  }  range=GetQuantumRange((size_t) component_info[0].prec);  for (y=0; y < (ssize_t) image->rows; y++)  {    p=GetVirtualPixels(image,0,y,image->columns,1,exception);    if (p == (const Quantum *) NULL)      break;    for (x=0; x < (ssize_t) image->columns; x++)    {      if (number_components == 1)        jas_matrix_setv(pixels[0],x,(jas_seqent_t) ScaleQuantumToAny(          ClampToQuantum(GetPixelLuma(image,p)),range));      else        {          jas_matrix_setv(pixels[0],x,(jas_seqent_t) ScaleQuantumToAny(            GetPixelRed(image,p),range));          jas_matrix_setv(pixels[1],x,(jas_seqent_t) ScaleQuantumToAny(            GetPixelGreen(image,p),range));          jas_matrix_setv(pixels[2],x,(jas_seqent_t) ScaleQuantumToAny(            GetPixelBlue(image,p),range));          if (number_components > 3)            jas_matrix_setv(pixels[3],x,(jas_seqent_t) ScaleQuantumToAny(              GetPixelAlpha(image,p),range));        }      p+=GetPixelChannels(image);    }    for (i=0; i < (ssize_t) number_components; i++)      (void) jas_image_writecmpt(jp2_image,(short) i,0,(unsigned int) y,        (unsigned int) image->columns,1,pixels[i]);    status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,      image->rows);    if (status == MagickFalse)      break;  }  (void) CopyMagickString(magick,image_info->magick,MaxTextExtent);  if (LocaleCompare(magick,"J2C") == 0)    (void) CopyMagickString(magick,"JPC",MaxTextExtent);

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

//.........这里部分代码省略.........          if (image->total_colors != 0)            {              (void) FormatMagickSize(image->total_colors,MagickFalse,format);              (void) fprintf(file,"%s ",format);            }        }      else        if (image->total_colors <= image->colors)          (void) fprintf(file,"PseudoClass %.20gc ",(double) image->colors);        else          (void) fprintf(file,"PseudoClass %.20g=>%.20gc ",(double)            image->total_colors,(double) image->colors);      if (image->error.mean_error_per_pixel != 0.0)        (void) fprintf(file,"%.20g/%f/%fdb ",(double)          (image->error.mean_error_per_pixel+0.5),          image->error.normalized_mean_error,          image->error.normalized_maximum_error);      if (GetBlobSize(image) != 0)        {          (void) FormatMagickSize(GetBlobSize(image),MagickFalse,format);          (void) fprintf(file,"%sB ",format);        }      (void) fprintf(file,"%0.3fu %lu:%02lu.%03lu",user_time,(unsigned long)        (elapsed_time/60.0),(unsigned long) floor(fmod(elapsed_time,60.0)),        (unsigned long) (1000.0*(elapsed_time-floor(elapsed_time))));      (void) fprintf(file,"/n");      (void) fflush(file);      return(ferror(file) != 0 ? MagickFalse : MagickTrue);    }  /*    Display verbose info about the image.  */  exception=AcquireExceptionInfo();  pixels=GetVirtualPixels(image,0,0,1,1,exception);  exception=DestroyExceptionInfo(exception);  ping=pixels == (const PixelPacket *) NULL ? MagickTrue : MagickFalse;  type=GetImageType(image,&image->exception);  (void) SignatureImage(image);  (void) fprintf(file,"Image: %s/n",image->filename);  if (*image->magick_filename != '/0')    if (LocaleCompare(image->magick_filename,image->filename) != 0)      {        char          filename[MaxTextExtent];        GetPathComponent(image->magick_filename,TailPath,filename);        (void) fprintf(file,"  Base filename: %s/n",filename);      }  magick_info=GetMagickInfo(image->magick,&image->exception);  if ((magick_info == (const MagickInfo *) NULL) ||      (*GetMagickDescription(magick_info) == '/0'))    (void) fprintf(file,"  Format: %s/n",image->magick);  else    (void) fprintf(file,"  Format: %s (%s)/n",image->magick,      GetMagickDescription(magick_info));  (void) fprintf(file,"  Class: %s/n",MagickOptionToMnemonic(MagickClassOptions,    (ssize_t) image->storage_class));  (void) fprintf(file,"  Geometry: %.20gx%.20g%+.20g%+.20g/n",(double)    image->columns,(double) image->rows,(double) image->tile_offset.x,(double)    image->tile_offset.y);  if ((image->magick_columns != 0) || (image->magick_rows != 0))    if ((image->magick_columns != image->columns) ||        (image->magick_rows != image->rows))      (void) fprintf(file,"  Base geometry: %.20gx%.20g/n",(double)        image->magick_columns,(double) image->magick_rows);  if ((image->x_resolution != 0.0) && (image->y_resolution != 0.0))

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   W r i t e T X T I m a g e                                                 %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  WriteTXTImage writes the pixel values as text numbers.%%  The format of the WriteTXTImage method is:%%      MagickBooleanType WriteTXTImage(const ImageInfo *image_info,Image *image)%%  A description of each parameter follows.%%    o image_info: the image info.%%    o image:  The image.%*/static MagickBooleanType WriteTXTImage(const ImageInfo *image_info,Image *image){  char    buffer[MaxTextExtent],    colorspace[MaxTextExtent],    tuple[MaxTextExtent];  MagickBooleanType    status;  MagickOffsetType    scene;  MagickPixelPacket    pixel;  register const IndexPacket    *indexes;  register const PixelPacket    *p;  register ssize_t    x;  ssize_t    y;  /*    Open output image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  status=OpenBlob(image_info,image,WriteBlobMode,&image->exception);  if (status == MagickFalse)    return(status);  scene=0;  do  {    ComplianceType      compliance;    const char      *value;    (void) CopyMagickString(colorspace,CommandOptionToMnemonic(      MagickColorspaceOptions,(ssize_t) image->colorspace),MaxTextExtent);    LocaleLower(colorspace);    image->depth=GetImageQuantumDepth(image,MagickTrue);    if (image->matte != MagickFalse)      (void) ConcatenateMagickString(colorspace,"a",MaxTextExtent);    compliance=NoCompliance;    value=GetImageOption(image_info,"txt:compliance");    if (value != (char *) NULL)      compliance=(ComplianceType) ParseCommandOption(MagickComplianceOptions,        MagickFalse,value);    if (LocaleCompare(image_info->magick,"SPARSE-COLOR") != 0)      {        (void) FormatLocaleString(buffer,MaxTextExtent,          "# ImageMagick pixel enumeration: %.20g,%.20g,%.20g,%s/n",(double)          image->columns,(double) image->rows,(double) ((MagickOffsetType)          GetQuantumRange(image->depth)),colorspace);        (void) WriteBlobString(image,buffer);      }    GetMagickPixelPacket(image,&pixel);    for (y=0; y < (ssize_t) image->rows; y++)    {      p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);      if (p == (const PixelPacket *) NULL)        break;      indexes=GetVirtualIndexQueue(image);      for (x=0; x < (ssize_t) image->columns; x++)//.........这里部分代码省略.........

//.........这里部分代码省略.........    (void) WriteBlobByte(image,iris_info.storage);    (void) WriteBlobByte(image,iris_info.bytes_per_pixel);    (void) WriteBlobMSBShort(image,iris_info.dimension);    (void) WriteBlobMSBShort(image,iris_info.columns);    (void) WriteBlobMSBShort(image,iris_info.rows);    (void) WriteBlobMSBShort(image,iris_info.depth);    (void) WriteBlobMSBLong(image,(unsigned int) iris_info.minimum_value);    (void) WriteBlobMSBLong(image,(unsigned int) iris_info.maximum_value);    (void) WriteBlobMSBLong(image,(unsigned int) iris_info.sans);    value=GetImageProperty(image,"label");    if (value != (const char *) NULL)      (void) CopyMagickString(iris_info.name,value,sizeof(iris_info.name));    (void) WriteBlob(image,sizeof(iris_info.name),(unsigned char *)      iris_info.name);    (void) WriteBlobMSBLong(image,(unsigned int) iris_info.pixel_format);    (void) WriteBlob(image,sizeof(iris_info.filler),iris_info.filler);    /*      Allocate SGI pixels.    */    number_pixels=(MagickSizeType) image->columns*image->rows;    if ((4*iris_info.bytes_per_pixel*number_pixels) !=        ((MagickSizeType) (size_t) (4*iris_info.bytes_per_pixel*number_pixels)))      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");    pixel_info=AcquireVirtualMemory((size_t) number_pixels,4*      iris_info.bytes_per_pixel*sizeof(*pixels));    if (pixel_info == (MemoryInfo *) NULL)      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");    pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);    /*      Convert image pixels to uncompressed SGI pixels.    */    for (y=0; y < (ssize_t) image->rows; y++)    {      p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);      if (p == (const PixelPacket *) NULL)        break;      if (image->depth <= 8)        for (x=0; x < (ssize_t) image->columns; x++)        {          register unsigned char            *q;          q=(unsigned char *) pixels;          q+=((iris_info.rows-1)-y)*(4*iris_info.columns)+4*x;          *q++=ScaleQuantumToChar(GetPixelRed(p));          *q++=ScaleQuantumToChar(GetPixelGreen(p));          *q++=ScaleQuantumToChar(GetPixelBlue(p));          *q++=ScaleQuantumToChar(GetPixelAlpha(p));          p++;        }      else        for (x=0; x < (ssize_t) image->columns; x++)        {          register unsigned short            *q;          q=(unsigned short *) pixels;          q+=((iris_info.rows-1)-y)*(4*iris_info.columns)+4*x;          *q++=ScaleQuantumToShort(GetPixelRed(p));          *q++=ScaleQuantumToShort(GetPixelGreen(p));          *q++=ScaleQuantumToShort(GetPixelBlue(p));          *q++=ScaleQuantumToShort(GetPixelAlpha(p));          p++;        }      if (image->previous == (Image *) NULL)        {

static MagickBooleanType WriteWBMPImage(const ImageInfo *image_info,  Image *image,ExceptionInfo *exception){  MagickBooleanType    status;  register const Quantum    *p;  register ssize_t    x;  ssize_t    y;  unsigned char    bit,    byte;  /*    Open output image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);  if (status == MagickFalse)    return(status);  if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)    (void) TransformImageColorspace(image,sRGBColorspace,exception);  /*    Convert image to a bi-level image.  */  (void) SetImageType(image,BilevelType,exception);  (void) WriteBlobMSBShort(image,0);  WBMPWriteInteger(image,image->columns);  WBMPWriteInteger(image,image->rows);  for (y=0; y < (ssize_t) image->rows; y++)  {    p=GetVirtualPixels(image,0,y,image->columns,1,exception);    if (p == (const Quantum *) NULL)      break;    bit=0;    byte=0;    for (x=0; x < (ssize_t) image->columns; x++)    {      if (GetPixelLuma(image,p) >= (QuantumRange/2.0))        byte|=0x1 << (7-bit);      bit++;      if (bit == 8)        {          (void) WriteBlobByte(image,byte);          bit=0;          byte=0;        }      p+=GetPixelChannels(image);    }    if (bit != 0)      (void) WriteBlobByte(image,byte);    status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,      image->rows);    if (status == MagickFalse)      break;  }  (void) CloseBlob(image);  return(MagickTrue);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   W r i t e A V S I m a g e                                                 %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  WriteAVSImage() writes an image to a file in AVS X image format.%%  The format of the WriteAVSImage method is:%%      MagickBooleanType WriteAVSImage(const ImageInfo *image_info,Image *image)%%  A description of each parameter follows.%%    o image_info: the image info.%%    o image:  The image.%*/static MagickBooleanType WriteAVSImage(const ImageInfo *image_info,Image *image){  MagickBooleanType    status;  MagickOffsetType    scene;  register const PixelPacket    *restrict p;  register ssize_t    x;  register unsigned char    *restrict q;  ssize_t    count,    y;  unsigned char    *pixels;  /*    Open output image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);  if (status == MagickFalse)    return(status);  scene=0;  do  {    /*      Write AVS header.    */    if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)      (void) TransformImageColorspace(image,sRGBColorspace);    (void) WriteBlobMSBLong(image,(unsigned int) image->columns);    (void) WriteBlobMSBLong(image,(unsigned int) image->rows);    /*      Allocate memory for pixels.    */    pixels=(unsigned char *) AcquireQuantumMemory((size_t) image->columns,      4*sizeof(*pixels));    if (pixels == (unsigned char *) NULL)      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");    /*      Convert MIFF to AVS raster pixels.    */    for (y=0; y < (ssize_t) image->rows; y++)    {      p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);      if (p == (PixelPacket *) NULL)        break;      q=pixels;      for (x=0; x < (ssize_t) image->columns; x++)      {        *q++=ScaleQuantumToChar((Quantum) (QuantumRange-(image->matte !=          MagickFalse ? GetPixelOpacity(p) : OpaqueOpacity)));        *q++=ScaleQuantumToChar(GetPixelRed(p));        *q++=ScaleQuantumToChar(GetPixelGreen(p));        *q++=ScaleQuantumToChar(GetPixelBlue(p));        p++;      }      count=WriteBlob(image,(size_t) (q-pixels),pixels);      if (count != (ssize_t) (q-pixels))        break;      if (image->previous == (Image *) NULL)        {//.........这里部分代码省略.........

static MagickBooleanType WriteHDRImage(const ImageInfo *image_info,Image *image,  ExceptionInfo *exception){  char    header[MaxTextExtent];  const char    *property;  MagickBooleanType    status;  register const Quantum    *p;  register ssize_t    i,    x;  size_t    length;  ssize_t    count,    y;  unsigned char    pixel[4],    *pixels;  /*    Open output image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);  if (status == MagickFalse)    return(status);  if (IsRGBColorspace(image->colorspace) == MagickFalse)    (void) TransformImageColorspace(image,RGBColorspace,exception);  /*    Write header.  */  (void) ResetMagickMemory(header,' ',MaxTextExtent);  length=CopyMagickString(header,"#?RGBE/n",MaxTextExtent);  (void) WriteBlob(image,length,(unsigned char *) header);  property=GetImageProperty(image,"comment",exception);  if ((property != (const char *) NULL) &&      (strchr(property,'/n') == (char *) NULL))    {      count=FormatLocaleString(header,MaxTextExtent,"#%s/n",property);      (void) WriteBlob(image,(size_t) count,(unsigned char *) header);    }  property=GetImageProperty(image,"hdr:exposure",exception);  if (property != (const char *) NULL)    {      count=FormatLocaleString(header,MaxTextExtent,"EXPOSURE=%g/n",        atof(property));      (void) WriteBlob(image,(size_t) count,(unsigned char *) header);    }  if (image->gamma != 0.0)    {      count=FormatLocaleString(header,MaxTextExtent,"GAMMA=%g/n",image->gamma);      (void) WriteBlob(image,(size_t) count,(unsigned char *) header);    }  count=FormatLocaleString(header,MaxTextExtent,    "PRIMARIES=%g %g %g %g %g %g %g %g/n",    image->chromaticity.red_primary.x,image->chromaticity.red_primary.y,    image->chromaticity.green_primary.x,image->chromaticity.green_primary.y,    image->chromaticity.blue_primary.x,image->chromaticity.blue_primary.y,    image->chromaticity.white_point.x,image->chromaticity.white_point.y);  (void) WriteBlob(image,(size_t) count,(unsigned char *) header);  length=CopyMagickString(header,"FORMAT=32-bit_rle_rgbe/n/n",MaxTextExtent);  (void) WriteBlob(image,length,(unsigned char *) header);  count=FormatLocaleString(header,MaxTextExtent,"-Y %.20g +X %.20g/n",    (double) image->rows,(double) image->columns);  (void) WriteBlob(image,(size_t) count,(unsigned char *) header);  /*    Write HDR pixels.  */  pixels=(unsigned char *) AcquireQuantumMemory(image->columns,4*    sizeof(*pixels));  if (pixels == (unsigned char *) NULL)    ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");  for (y=0; y < (ssize_t) image->rows; y++)  {    p=GetVirtualPixels(image,0,y,image->columns,1,exception);    if (p == (const Quantum *) NULL)      break;    if ((image->columns >= 8) && (image->columns <= 0x7ffff))      {        pixel[0]=2;        pixel[1]=2;        pixel[2]=(unsigned char) (image->columns >> 8);//.........这里部分代码省略.........

//.........这里部分代码省略.........          case JPEGCompression:          {            status=InjectImageBlob(image_info,image,image,"jpeg",exception);            if (status == MagickFalse)              {                (void) CloseBlob(image);                return(MagickFalse);              }            break;          }          case RLECompression:          default:          {            MemoryInfo              *pixel_info;            register unsigned char              *q;            /*              Allocate pixel array.            */            length=(size_t) number_pixels;            pixel_info=AcquireVirtualMemory(length,sizeof(*pixels));            if (pixel_info == (MemoryInfo *) NULL)              ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");            pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);            /*              Dump runlength encoded pixels.            */            q=pixels;            for (y=0; y < (ssize_t) image->rows; y++)            {              p=GetVirtualPixels(image,0,y,image->columns,1,exception);              if (p == (const Quantum *) NULL)                break;              for (x=0; x < (ssize_t) image->columns; x++)              {                *q++=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));                p+=GetPixelChannels(image);              }              progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,                image->rows);              if (progress == MagickFalse)                break;            }            length=(size_t) (q-pixels);            if (compression == LZWCompression)              status=LZWEncodeImage(image,length,pixels,exception);            else              status=PackbitsEncodeImage(image,length,pixels,exception);            pixel_info=RelinquishVirtualMemory(pixel_info);            if (status == MagickFalse)              {                (void) CloseBlob(image);                return(MagickFalse);              }            break;          }          case NoCompression:          {            /*              Dump uncompressed PseudoColor packets.            */            Ascii85Initialize(image);            for (y=0; y < (ssize_t) image->rows; y++)

//.........这里部分代码省略.........  offset+=WriteBlobFloat(image,cin.origination.gamma);  offset+=WriteBlob(image,sizeof(cin.origination.reserve),(unsigned char *)    cin.origination.reserve);  /*    Image film information.  */  cin.film.id=0;  value=GetCINProperty(image_info,image,"dpx:film.id");  if (value != (const char *) NULL)    cin.film.id=(char) StringToLong(value);  offset+=WriteBlobByte(image,(unsigned char) cin.film.id);  cin.film.type=0;  value=GetCINProperty(image_info,image,"dpx:film.type");  if (value != (const char *) NULL)    cin.film.type=(char) StringToLong(value);  offset+=WriteBlobByte(image,(unsigned char) cin.film.type);  cin.film.offset=0;  value=GetCINProperty(image_info,image,"dpx:film.offset");  if (value != (const char *) NULL)    cin.film.offset=(char) StringToLong(value);  offset+=WriteBlobByte(image,(unsigned char) cin.film.offset);  offset+=WriteBlobByte(image,(unsigned char) cin.film.reserve1);  cin.film.prefix=0UL;  value=GetCINProperty(image_info,image,"dpx:film.prefix");  if (value != (const char *) NULL)    cin.film.prefix=StringToUnsignedLong(value);  offset+=WriteBlobLong(image,(unsigned int) cin.film.prefix);  cin.film.count=0UL;  value=GetCINProperty(image_info,image,"dpx:film.count");  if (value != (const char *) NULL)    cin.film.count=StringToUnsignedLong(value);  offset+=WriteBlobLong(image,(unsigned int) cin.film.count);  value=GetCINProperty(image_info,image,"dpx:film.format");  if (value != (const char *) NULL)    (void) CopyMagickString(cin.film.format,value,sizeof(cin.film.format));  offset+=WriteBlob(image,sizeof(cin.film.format),(unsigned char *)    cin.film.format);  cin.film.frame_position=0UL;  value=GetCINProperty(image_info,image,"dpx:film.frame_position");  if (value != (const char *) NULL)    cin.film.frame_position=StringToUnsignedLong(value);  offset+=WriteBlobLong(image,(unsigned int) cin.film.frame_position);  cin.film.frame_rate=0.0f;  value=GetCINProperty(image_info,image,"dpx:film.frame_rate");  if (value != (const char *) NULL)    cin.film.frame_rate=StringToDouble(value,(char **) NULL);  offset+=WriteBlobFloat(image,cin.film.frame_rate);  value=GetCINProperty(image_info,image,"dpx:film.frame_id");  if (value != (const char *) NULL)    (void) CopyMagickString(cin.film.frame_id,value,sizeof(cin.film.frame_id));  offset+=WriteBlob(image,sizeof(cin.film.frame_id),(unsigned char *)    cin.film.frame_id);  value=GetCINProperty(image_info,image,"dpx:film.slate_info");  if (value != (const char *) NULL)    (void) CopyMagickString(cin.film.slate_info,value,      sizeof(cin.film.slate_info));  offset+=WriteBlob(image,sizeof(cin.film.slate_info),(unsigned char *)    cin.film.slate_info);  offset+=WriteBlob(image,sizeof(cin.film.reserve),(unsigned char *)    cin.film.reserve);  if (profile != (StringInfo *) NULL)    offset+=WriteBlob(image,GetStringInfoLength(profile),      GetStringInfoDatum(profile));  while (offset < (MagickOffsetType) cin.file.image_offset)    offset+=WriteBlobByte(image,0x00);  /*    Convert pixel packets to CIN raster image.  */  quantum_info=AcquireQuantumInfo(image_info,image);  if (quantum_info == (QuantumInfo *) NULL)    ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");  quantum_info->quantum=32;  quantum_info->pack=MagickFalse;  quantum_type=RGBQuantum;  pixels=GetQuantumPixels(quantum_info);  length=GetBytesPerRow(image->columns,3,image->depth,MagickTrue);  if (0)    {      quantum_type=GrayQuantum;      length=GetBytesPerRow(image->columns,1UL,image->depth,MagickTrue);    }  for (y=0; y < (ssize_t) image->rows; y++)  {    p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);    if (p == (const PixelPacket *) NULL)      break;    (void) ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,      quantum_type,pixels,&image->exception);    count=WriteBlob(image,length,pixels);    if (count != (ssize_t) length)      break;    status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,      image->rows);    if (status == MagickFalse)      break;  }  quantum_info=DestroyQuantumInfo(quantum_info);  (void) CloseBlob(image);  return(status);}

static MagickBooleanType SerializeImage(const ImageInfo *image_info,  Image *image,unsigned char **pixels,size_t *length){  long    y;  MagickBooleanType    status;  register const IndexPacket    *indexes;  register const PixelPacket    *p;  register long    x;  register unsigned char    *q;  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  status=MagickTrue;  *length=(image->colorspace == CMYKColorspace ? 4 : 3)*    (size_t) image->columns*image->rows;  *pixels=(unsigned char *) AcquireQuantumMemory(*length,sizeof(**pixels));  if (*pixels == (unsigned char *) NULL)    ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");  q=(*pixels);  for (y=0; y < (long) image->rows; y++)  {    p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);    if (p == (const PixelPacket *) NULL)      break;    indexes=GetVirtualIndexQueue(image);    if (image->colorspace != CMYKColorspace)      for (x=0; x < (long) image->columns; x++)      {        *q++=ScaleQuantumToChar(p->red);        *q++=ScaleQuantumToChar(p->green);        *q++=ScaleQuantumToChar(p->blue);        p++;      }    else      for (x=0; x < (long) image->columns; x++)      {        *q++=ScaleQuantumToChar(p->red);        *q++=ScaleQuantumToChar(p->green);        *q++=ScaleQuantumToChar(p->blue);        *q++=ScaleQuantumToChar(indexes[x]);        p++;      }    if (image->previous == (Image *) NULL)      {        status=SetImageProgress(image,SaveImageTag,y,image->rows);        if (status == MagickFalse)          break;      }  }  if (status == MagickFalse)    *pixels=(unsigned char *) RelinquishMagickMemory(*pixels);  return(status);}

//.........这里部分代码省略.........    image->depth > 8 ? GetFITSPixelRange(image->depth)/2.0 : 0.0);  (void) strncpy(fits_info+offset,header,strlen(header));  offset+=80;  (void) FormatLocaleString(header,FITSBlocksize,"DATAMAX =         %E",    1.0*((MagickOffsetType) GetQuantumRange(image->depth)));  (void) strncpy(fits_info+offset,header,strlen(header));  offset+=80;  (void) FormatLocaleString(header,FITSBlocksize,"DATAMIN =         %E",0.0);  (void) strncpy(fits_info+offset,header,strlen(header));  offset+=80;  if (image->endian == LSBEndian)    {      (void) FormatLocaleString(header,FITSBlocksize,"XENDIAN = 'SMALL'");      (void) strncpy(fits_info+offset,header,strlen(header));      offset+=80;    }  (void) FormatLocaleString(header,FITSBlocksize,"HISTORY %.72s",    GetMagickVersion((size_t *) NULL));  (void) strncpy(fits_info+offset,header,strlen(header));  offset+=80;  (void) strncpy(header,"END",FITSBlocksize);  (void) strncpy(fits_info+offset,header,strlen(header));  offset+=80;  (void) WriteBlob(image,FITSBlocksize,(unsigned char *) fits_info);  /*    Convert image to fits scale PseudoColor class.  */  pixels=(unsigned char *) GetQuantumPixels(quantum_info);  if (SetImageGray(image,exception) != MagickFalse)    {      length=GetQuantumExtent(image,quantum_info,GrayQuantum);      for (y=(ssize_t) image->rows-1; y >= 0; y--)      {        p=GetVirtualPixels(image,0,y,image->columns,1,exception);        if (p == (const Quantum *) NULL)          break;        length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,          GrayQuantum,pixels,exception);        if (image->depth == 16)          SetFITSUnsignedPixels(image->columns,image->depth,image->endian,            pixels);        if (((image->depth == 32) || (image->depth == 64)) &&            (quantum_info->format != FloatingPointQuantumFormat))          SetFITSUnsignedPixels(image->columns,image->depth,image->endian,            pixels);        count=WriteBlob(image,length,pixels);        if (count != (ssize_t) length)          break;        status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,          image->rows);        if (status == MagickFalse)          break;      }    }  else    {      length=GetQuantumExtent(image,quantum_info,RedQuantum);      for (y=(ssize_t) image->rows-1; y >= 0; y--)      {        p=GetVirtualPixels(image,0,y,image->columns,1,exception);        if (p == (const Quantum *) NULL)          break;        length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,          RedQuantum,pixels,exception);        if (image->depth == 16)          SetFITSUnsignedPixels(image->columns,image->depth,image->endian,

static MagickBooleanType SerializeImageChannel(const ImageInfo *image_info,  Image *image,unsigned char **pixels,size_t *length){  long    y;  MagickBooleanType    status;  register const PixelPacket    *p;  register long    x;  register unsigned char    *q;  unsigned char    code,    bit;  unsigned long    pack,    padded_columns;  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  status=MagickTrue;  pack=IsMonochromeImage(image,&image->exception) == MagickFalse ? 1UL : 8UL;  padded_columns=((image->columns+pack-1)/pack)*pack;  *length=(size_t) padded_columns*image->rows/pack;  *pixels=(unsigned char *) AcquireQuantumMemory(*length,sizeof(**pixels));  if (*pixels == (unsigned char *) NULL)    ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");  q=(*pixels);  for (y=0; y < (long) image->rows; y++)  {    p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);    if (p == (const PixelPacket *) NULL)      break;    if (pack == 1)      for (x=0; x < (long) image->columns; x++)      {        *q++=ScaleQuantumToChar(PixelIntensityToQuantum(p));        p++;      }    else      {        code='/0';        for (x=0; x < (long) padded_columns; x++)        {          bit=(unsigned char) 0x00;          if (x < (long) image->columns)            bit=(unsigned char) (PixelIntensityToQuantum(p) ==              (Quantum) TransparentOpacity ? 0x01 : 0x00);          code=(code << 1)+bit;          if (((x+1) % pack) == 0)            {              *q++=code;              code='/0';            }          p++;        }      }    status=SetImageProgress(image,SaveImageTag,y,image->rows);    if (status == MagickFalse)      break;  }  if (status == MagickFalse)    *pixels=(unsigned char *) RelinquishMagickMemory(*pixels);  return(status);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   W r i t e M T V I m a g e                                                 %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  WriteMTVImage() writes an image to a file in red, green, and blue MTV%  rasterfile format.%%  The format of the WriteMTVImage method is:%%      MagickBooleanType WriteMTVImage(const ImageInfo *image_info,%        Image *image,ExceptionInfo *exception)%%  A description of each parameter follows.%%    o image_info: the image info.%%    o image:  The image.%%    o exception: return any errors or warnings in this structure.%*/static MagickBooleanType WriteMTVImage(const ImageInfo *image_info,Image *image,  ExceptionInfo *exception){  char    buffer[MagickPathExtent];  MagickBooleanType    status;  MagickOffsetType    scene;  register const Quantum    *p;  register ssize_t    x;  register unsigned char    *q;  ssize_t    y;  unsigned char    *pixels;  /*    Open output image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);  if (status == MagickFalse)    return(status);  scene=0;  do  {    /*      Allocate memory for pixels.    */    (void) TransformImageColorspace(image,sRGBColorspace,exception);    pixels=(unsigned char *) AcquireQuantumMemory(image->columns,      3UL*sizeof(*pixels));    if (pixels == (unsigned char *) NULL)      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");    /*      Initialize raster file header.    */    (void) FormatLocaleString(buffer,MagickPathExtent,"%.20g %.20g/n",(double)      image->columns,(double) image->rows);    (void) WriteBlobString(image,buffer);    for (y=0; y < (ssize_t) image->rows; y++)    {      p=GetVirtualPixels(image,0,y,image->columns,1,exception);      if (p == (const Quantum *) NULL)        break;      q=pixels;      for (x=0; x < (ssize_t) image->columns; x++)      {        *q++=ScaleQuantumToChar(GetPixelRed(image,p));        *q++=ScaleQuantumToChar(GetPixelGreen(image,p));        *q++=ScaleQuantumToChar(GetPixelBlue(image,p));        p+=GetPixelChannels(image);      }      (void) WriteBlob(image,(size_t) (q-pixels),pixels);//.........这里部分代码省略.........

static MagickBooleanType WriteHISTOGRAMImage(const ImageInfo *image_info,  Image *image){#define HistogramDensity  "256x200"  ChannelType    channel;  char    filename[MaxTextExtent];  const char    *option;  ExceptionInfo    *exception;  Image    *histogram_image;  ImageInfo    *write_info;  long    y;  MagickBooleanType    status;  MagickPixelPacket    *histogram;  MagickRealType    maximum,    scale;  RectangleInfo    geometry;  register const PixelPacket    *p;  register long    x;  register PixelPacket    *q,    *r;  size_t    length;  /*    Allocate histogram image.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",      image_info->filename);  SetGeometry(image,&geometry);  if (image_info->density == (char *) NULL)    (void) ParseAbsoluteGeometry(HistogramDensity,&geometry);  else    (void) ParseAbsoluteGeometry(image_info->density,&geometry);  histogram_image=CloneImage(image,geometry.width,geometry.height,MagickTrue,    &image->exception);  if (histogram_image == (Image *) NULL)    ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");  (void) SetImageStorageClass(histogram_image,DirectClass);  /*    Allocate histogram count arrays.  */  length=MagickMax((size_t) ScaleQuantumToChar((Quantum) QuantumRange)+1UL,    histogram_image->columns);  histogram=(MagickPixelPacket *) AcquireQuantumMemory(length,    sizeof(*histogram));  if (histogram == (MagickPixelPacket *) NULL)    {      histogram_image=DestroyImage(histogram_image);      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");    }  /*    Initialize histogram count arrays.  */  channel=image_info->channel;  (void) ResetMagickMemory(histogram,0,length*sizeof(*histogram));  for (y=0; y < (long) image->rows; y++)  {    p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);    if (p == (const PixelPacket *) NULL)      break;    for (x=0; x < (long) image->columns; x++)    {      if ((channel & RedChannel) != 0)        histogram[ScaleQuantumToChar(GetRedPixelComponent(p))].red++;      if ((channel & GreenChannel) != 0)        histogram[ScaleQuantumToChar(GetGreenPixelComponent(p))].green++;//.........这里部分代码省略.........

//.........这里部分代码省略.........    *q;  RGBQUAD    *bitmap_bits;  ssize_t    y;  /*    Check crop geometry.  */  assert(image != (const Image *) NULL);  assert(image->signature == MagickCoreSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(geometry != (const RectangleInfo *) NULL);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickCoreSignature);  if (((geometry->x+(ssize_t) geometry->width) < 0) ||      ((geometry->y+(ssize_t) geometry->height) < 0) ||      (geometry->x >= (ssize_t) image->columns) ||      (geometry->y >= (ssize_t) image->rows))    ThrowImageException(OptionError,"GeometryDoesNotContainImage");  page=(*geometry);  if ((page.x+(ssize_t) page.width) > (ssize_t) image->columns)    page.width=image->columns-page.x;  if ((page.y+(ssize_t) page.height) > (ssize_t) image->rows)    page.height=image->rows-page.y;  if (page.x < 0)    {      page.width+=page.x;      page.x=0;    }  if (page.y < 0)    {      page.height+=page.y;      page.y=0;    }  if ((page.width == 0) || (page.height == 0))    ThrowImageException(OptionError,"GeometryDimensionsAreZero");  /*    Initialize crop image attributes.  */  bitmap.bmType         = 0;  bitmap.bmWidth        = (LONG) page.width;  bitmap.bmHeight       = (LONG) page.height;  bitmap.bmWidthBytes   = bitmap.bmWidth * 4;  bitmap.bmPlanes       = 1;  bitmap.bmBitsPixel    = 32;  bitmap.bmBits         = NULL;  bitmap_bitsH=(HANDLE) GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,page.width*    page.height*bitmap.bmBitsPixel);  if (bitmap_bitsH == NULL)    return(NULL);  bitmap_bits=(RGBQUAD *) GlobalLock((HGLOBAL) bitmap_bitsH);  if ( bitmap.bmBits == NULL )    bitmap.bmBits = bitmap_bits;  if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)    SetImageColorspace(image,sRGBColorspace,exception);  /*    Extract crop image.  */  q=bitmap_bits;  for (y=0; y < (ssize_t) page.height; y++)  {    register ssize_t      x;    p=GetVirtualPixels(image,page.x,page.y+y,page.width,1,exception);    if (p == (const Quantum *) NULL)      break;    /* Transfer pixels, scaling to Quantum */    for( x=(ssize_t) page.width ; x> 0 ; x-- )    {      q->rgbRed = ScaleQuantumToChar(GetPixelRed(image,p));      q->rgbGreen = ScaleQuantumToChar(GetPixelGreen(image,p));      q->rgbBlue = ScaleQuantumToChar(GetPixelBlue(image,p));      q->rgbReserved = 0;      p+=GetPixelChannels(image);      q++;    }    proceed=SetImageProgress(image,CropImageTag,y,page.height);    if (proceed == MagickFalse)      break;  }  if (y < (ssize_t) page.height)    {      GlobalUnlock((HGLOBAL) bitmap_bitsH);      GlobalFree((HGLOBAL) bitmap_bitsH);      return((void *) NULL);    }  bitmap.bmBits=bitmap_bits;  bitmapH=CreateBitmapIndirect(&bitmap);  GlobalUnlock((HGLOBAL) bitmap_bitsH);  GlobalFree((HGLOBAL) bitmap_bitsH);  return((void *) bitmapH);}

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

//.........这里部分代码省略.........          image->colormap[opacity].green=image->transparent_color.green;          image->colormap[opacity].blue=image->transparent_color.blue;        }    }  /*    Compute the character per pixel.  */  characters_per_pixel=1;  for (k=MaxCixels; (ssize_t) image->colors > k; k*=MaxCixels)    characters_per_pixel++;  /*    XPM header.  */  (void) WriteBlobString(image,"/* XPM *//n");  GetPathComponent(image->filename,BasePath,basename);  if (isalnum((int) ((unsigned char) *basename)) == 0)    {      (void) FormatLocaleString(buffer,MaxTextExtent,"xpm_%s",basename);      (void) CopyMagickString(basename,buffer,MaxTextExtent);    }  if (isalpha((int) ((unsigned char) basename[0])) == 0)    basename[0]='_';  for (i=1; basename[i] != '/0'; i++)    if (isalnum((int) ((unsigned char) basename[i])) == 0)      basename[i]='_';  (void) FormatLocaleString(buffer,MaxTextExtent,    "static char *%s[] = {/n",basename);  (void) WriteBlobString(image,buffer);  (void) WriteBlobString(image,"/* columns rows colors chars-per-pixel *//n");  (void) FormatLocaleString(buffer,MaxTextExtent,    "/"%.20g %.20g %.20g %.20g /",/n",(double) image->columns,(double)    image->rows,(double) image->colors,(double) characters_per_pixel);  (void) WriteBlobString(image,buffer);  GetMagickPixelPacket(image,&pixel);  for (i=0; i < (ssize_t) image->colors; i++)  {    /*      Define XPM color.    */    SetMagickPixelPacket(image,image->colormap+i,(IndexPacket *) NULL,&pixel);    pixel.colorspace=sRGBColorspace;    pixel.depth=8;    pixel.opacity=(MagickRealType) OpaqueOpacity;    (void) QueryMagickColorname(image,&pixel,XPMCompliance,name,exception);    if (i == opacity)      (void) CopyMagickString(name,"None",MaxTextExtent);    /*      Write XPM color.    */    k=i % MaxCixels;    symbol[0]=Cixel[k];    for (j=1; j < (ssize_t) characters_per_pixel; j++)    {      k=((i-k)/MaxCixels) % MaxCixels;      symbol[j]=Cixel[k];    }    symbol[j]='/0';    (void) FormatLocaleString(buffer,MaxTextExtent,"/"%s c %s/",/n",symbol,      name);    (void) WriteBlobString(image,buffer);  }  /*    Define XPM pixels.  */  (void) WriteBlobString(image,"/* pixels *//n");  for (y=0; y < (ssize_t) image->rows; y++)  {    p=GetVirtualPixels(image,0,y,image->columns,1,exception);    if (p == (const PixelPacket *) NULL)      break;    indexes=GetVirtualIndexQueue(image);    (void) WriteBlobString(image,"/"");    for (x=0; x < (ssize_t) image->columns; x++)    {      k=((ssize_t) GetPixelIndex(indexes+x) % MaxCixels);      symbol[0]=Cixel[k];      for (j=1; j < (ssize_t) characters_per_pixel; j++)      {        k=(((int) GetPixelIndex(indexes+x)-k)/MaxCixels) % MaxCixels;        symbol[j]=Cixel[k];      }      symbol[j]='/0';      (void) CopyMagickString(buffer,symbol,MaxTextExtent);      (void) WriteBlobString(image,buffer);    }    (void) FormatLocaleString(buffer,MaxTextExtent,"/"%s/n",      (y == (ssize_t) (image->rows-1) ? "" : ","));    (void) WriteBlobString(image,buffer);    if (image->previous == (Image *) NULL)      {        status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,          image->rows);        if (status == MagickFalse)          break;      }  }  (void) WriteBlobString(image,"};/n");  (void) CloseBlob(image);  return(MagickTrue);}

//.........这里部分代码省略.........        return(status);    }  quantum_type=RGBQuantum;  if (LocaleCompare(image_info->magick,"YCbCrA") == 0)    {      quantum_type=RGBAQuantum;      image->matte=MagickTrue;    }  scene=0;  do  {    /*      Convert MIFF to YCbCr raster pixels.    */    if (image->colorspace != YCbCrColorspace)      (void) TransformImageColorspace(image,YCbCrColorspace);    if ((LocaleCompare(image_info->magick,"YCbCrA") == 0) &&        (image->matte == MagickFalse))      (void) SetImageAlphaChannel(image,ResetAlphaChannel);    quantum_info=AcquireQuantumInfo(image_info,image);    if (quantum_info == (QuantumInfo *) NULL)      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");    pixels=GetQuantumPixels(quantum_info);    switch (image_info->interlace)    {      case NoInterlace:      default:      {        /*          No interlacing:  YCbCrYCbCrYCbCrYCbCrYCbCrYCbCr...        */        for (y=0; y < (ssize_t) image->rows; y++)        {          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);          if (p == (const PixelPacket *) NULL)            break;          length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,            quantum_type,pixels,&image->exception);          count=WriteBlob(image,length,pixels);          if (count != (ssize_t) length)            break;          if (image->previous == (Image *) NULL)            {              status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,                image->rows);              if (status == MagickFalse)                break;            }        }        break;      }      case LineInterlace:      {        /*          Line interlacing:  YYY...CbCbCb...CrCrCr...YYY...CbCbCb...CrCrCr...        */        for (y=0; y < (ssize_t) image->rows; y++)        {          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);          if (p == (const PixelPacket *) NULL)            break;          length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,            RedQuantum,pixels,&image->exception);          count=WriteBlob(image,length,pixels);          if (count != (ssize_t) length)            break;

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   W r i t e G R A Y I m a g e                                               %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  WriteGRAYImage() writes an image to a file as gray scale intensity%  values.%%  The format of the WriteGRAYImage method is:%%      MagickBooleanType WriteGRAYImage(const ImageInfo *image_info,%        Image *image,ExceptionInfo *exception)%%  A description of each parameter follows.%%    o image_info: the image info.%%    o image:  The image.%%    o exception: return any errors or warnings in this structure.%*/static MagickBooleanType WriteGRAYImage(const ImageInfo *image_info,  Image *image,ExceptionInfo *exception){  MagickBooleanType    status;  MagickOffsetType    scene;  QuantumInfo    *quantum_info;  QuantumType    quantum_type;  size_t    length;  ssize_t    count,    y;  unsigned char    *pixels;  /*    Open output image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickCoreSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickCoreSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickCoreSignature);  status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);  if (status == MagickFalse)    return(status);  scene=0;  do  {    /*      Write grayscale pixels.    */    (void) TransformImageColorspace(image,sRGBColorspace,exception);    quantum_type=GrayQuantum;    quantum_info=AcquireQuantumInfo(image_info,image);    if (quantum_info == (QuantumInfo *) NULL)      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");    pixels=(unsigned char *) GetQuantumPixels(quantum_info);    for (y=0; y < (ssize_t) image->rows; y++)    {      register const Quantum        *magick_restrict p;      p=GetVirtualPixels(image,0,y,image->columns,1,exception);      if (p == (const Quantum *) NULL)        break;      length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,        quantum_type,pixels,exception);      count=WriteBlob(image,length,pixels);      if (count != (ssize_t) length)        break;      if (image->previous == (Image *) NULL)        {          status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,            image->rows);          if (status == MagickFalse)            break;        }    }//.........这里部分代码省略.........

//.........这里部分代码省略.........    image->colorspace=YCbCrColorspace;    switch (image_info->interlace)    {      case NoInterlace:      default:      {        /*          No interlacing:  YCbCrYCbCrYCbCrYCbCrYCbCrYCbCr...        */        if (scene == 0)          {            length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);            count=ReadBlob(image,length,pixels);          }        for (y=0; y < (ssize_t) image->extract_info.height; y++)        {          if (count != (ssize_t) length)            {              ThrowFileException(exception,CorruptImageError,                "UnexpectedEndOfFile",image->filename);              break;            }          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,            exception);          if (q == (PixelPacket *) NULL)            break;          length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,            quantum_info,quantum_type,pixels,exception);          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)            break;          if (((y-image->extract_info.y) >= 0) &&               ((y-image->extract_info.y) < (ssize_t) image->rows))            {              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,                canvas_image->columns,1,exception);              q=QueueAuthenticPixels(image,0,y-image->extract_info.y,                image->columns,1,exception);              if ((p == (const PixelPacket *) NULL) ||                  (q == (PixelPacket *) NULL))                break;              for (x=0; x < (ssize_t) image->columns; x++)              {                SetRedPixelComponent(q,GetRedPixelComponent(p));                SetGreenPixelComponent(q,GetGreenPixelComponent(p));                SetBluePixelComponent(q,GetBluePixelComponent(p));                if (image->matte != MagickFalse)                  SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));                p++;                q++;              }              if (SyncAuthenticPixels(image,exception) == MagickFalse)                break;            }          if (image->previous == (Image *) NULL)            {              status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,                image->rows);              if (status == MagickFalse)                break;            }          count=ReadBlob(image,length,pixels);        }        break;      }      case LineInterlace:      {

static MagickBooleanType WriteCIPImage(const ImageInfo *image_info,Image *image){  char    buffer[MaxTextExtent];  const char    *value;  MagickBooleanType    status;  register const PixelPacket    *p;  register ssize_t    i,    x;  ssize_t    y;  unsigned char    byte;  /*    Open output image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);  if (status == MagickFalse)    return(status);  (void) WriteBlobString(image,"<CiscoIPPhoneImage>/n");  value=GetImageProperty(image,"label");  if (value != (const char *) NULL)    (void) FormatLocaleString(buffer,MaxTextExtent,"<Title>%s</Title>/n",value);  else    {      char        basename[MaxTextExtent];      GetPathComponent(image->filename,BasePath,basename);      (void) FormatLocaleString(buffer,MaxTextExtent,"<Title>%s</Title>/n",        basename);    }  (void) WriteBlobString(image,buffer);  (void) FormatLocaleString(buffer,MaxTextExtent,    "<LocationX>%.20g</LocationX>/n",(double) image->page.x);  (void) WriteBlobString(image,buffer);  (void) FormatLocaleString(buffer,MaxTextExtent,    "<LocationY>%.20g</LocationY>/n",(double) image->page.y);  (void) WriteBlobString(image,buffer);  (void) FormatLocaleString(buffer,MaxTextExtent,"<Width>%.20g</Width>/n",    (double) (image->columns+(image->columns % 2)));  (void) WriteBlobString(image,buffer);  (void) FormatLocaleString(buffer,MaxTextExtent,"<Height>%.20g</Height>/n",    (double) image->rows);  (void) WriteBlobString(image,buffer);  (void) FormatLocaleString(buffer,MaxTextExtent,"<Depth>2</Depth>/n");  (void) WriteBlobString(image,buffer);  (void) WriteBlobString(image,"<Data>");  if (IsRGBColorspace(image->colorspace) == MagickFalse)    (void) TransformImageColorspace(image,sRGBColorspace);  for (y=0; y < (ssize_t) image->rows; y++)  {    p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);    if (p == (const PixelPacket *) NULL)      break;    for (x=0; x < ((ssize_t) image->columns-3); x+=4)    {      byte=(unsigned char)        ((((size_t) (4*PixelIntensityToQuantum(p+3)/QuantumRange) & 0x03) << 6) |         (((size_t) (4*PixelIntensityToQuantum(p+2)/QuantumRange) & 0x03) << 4) |         (((size_t) (4*PixelIntensityToQuantum(p+1)/QuantumRange) & 0x03) << 2) |         (((size_t) (4*PixelIntensityToQuantum(p+0)/QuantumRange) & 0x03) << 0));      (void) FormatLocaleString(buffer,MaxTextExtent,"%02x",byte);      (void) WriteBlobString(image,buffer);      p+=4;    }    if ((image->columns % 4) != 0)      {        i=(ssize_t) image->columns % 4;        byte=(unsigned char)          ((((size_t) (4*PixelIntensityToQuantum(p+MagickMin(i,3))/QuantumRange) & 0x03) << 6) |           (((size_t) (4*PixelIntensityToQuantum(p+MagickMin(i,2))/QuantumRange) & 0x03) << 4) |           (((size_t) (4*PixelIntensityToQuantum(p+MagickMin(i,1))/QuantumRange) & 0x03) << 2) |           (((size_t) (4*PixelIntensityToQuantum(p+MagickMin(i,0))/QuantumRange) & 0x03) << 0));        (void) FormatLocaleString(buffer,MaxTextExtent,"%02x",~byte);        (void) WriteBlobString(image,buffer);      }    status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,      image->rows);    if (status == MagickFalse)      break;  }  (void) WriteBlobString(image,"</Data>/n");//.........这里部分代码省略.........

//.........这里部分代码省略.........    {      quantum_type=CyanQuantum;      if (image->colorspace == CMYKColorspace)        break;      ThrowWriterException(ImageError,"ColorSeparatedImageRequired");    }    case 'g':    case 'G':    {      quantum_type=GreenQuantum;      break;    }    case 'I':    case 'i':    {      quantum_type=IndexQuantum;      break;    }    case 'K':    case 'k':    {      quantum_type=BlackQuantum;      if (image->colorspace == CMYKColorspace)        break;      ThrowWriterException(ImageError,"ColorSeparatedImageRequired");    }    case 'M':    case 'm':    {      quantum_type=MagentaQuantum;      if (image->colorspace == CMYKColorspace)        break;      ThrowWriterException(ImageError,"ColorSeparatedImageRequired");    }    case 'o':    case 'O':    {      quantum_type=OpacityQuantum;      break;    }    case 'R':    case 'r':    {      quantum_type=RedQuantum;      break;    }    case 'Y':    case 'y':    {      quantum_type=YellowQuantum;      if (image->colorspace == CMYKColorspace)        break;      ThrowWriterException(ImageError,"ColorSeparatedImageRequired");    }    default:    {      quantum_type=GrayQuantum;      break;    }  }  scene=0;  do  {    /*      Convert image to RAW raster pixels.    */    quantum_info=AcquireQuantumInfo(image_info,image);    if (quantum_info == (QuantumInfo *) NULL)      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");    pixels=GetQuantumPixels(quantum_info);    for (y=0; y < (ssize_t) image->rows; y++)    {      p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);      if (p == (const PixelPacket *) NULL)        break;      length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,        quantum_type,pixels,&image->exception);      count=WriteBlob(image,length,pixels);      if (count != (ssize_t) length)        break;      if (image->previous == (Image *) NULL)        {          status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,            image->rows);          if (status == MagickFalse)            break;        }    }    quantum_info=DestroyQuantumInfo(quantum_info);    if (GetNextImageInList(image) == (Image *) NULL)      break;    image=SyncNextImageInList(image);    status=SetImageProgress(image,SaveImagesTag,scene++,      GetImageListLength(image));    if (status == MagickFalse)      break;  } while (image_info->adjoin != MagickFalse);  (void) CloseBlob(image);  return(MagickTrue);}