granicus.if.org Git - imagemagick/blob - coders/rle.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                            RRRR   L      EEEEE                              %
   7 %                            R   R  L      E                                  %
   8 %                            RRRR   L      EEE                                %
   9 %                            R R    L      E                                  %
  10 %                            R  R   LLLLL  EEEEE                              %
  11 %                                                                             %
  12 %                                                                             %
  13 %                          Read URT RLE Image Format                          %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                John Cristy                                  %
  17 %                                 July 1992                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    http://www.imagemagick.org/script/license.php                            %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %
  37 */
  38 \f
  39 /*
  40   Include declarations.
  41 */
  42 #include "magick/studio.h"
  43 #include "magick/property.h"
  44 #include "magick/blob.h"
  45 #include "magick/blob-private.h"
  46 #include "magick/cache.h"
  47 #include "magick/colormap.h"
  48 #include "magick/exception.h"
  49 #include "magick/exception-private.h"
  50 #include "magick/image.h"
  51 #include "magick/image-private.h"
  52 #include "magick/list.h"
  53 #include "magick/magick.h"
  54 #include "magick/memory_.h"
  55 #include "magick/monitor.h"
  56 #include "magick/monitor-private.h"
  57 #include "magick/quantum-private.h"
  58 #include "magick/static.h"
  59 #include "magick/string_.h"
  60 #include "magick/module.h"
  61 \f
  62 /*
  63 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  64 %                                                                             %
  65 %                                                                             %
  66 %                                                                             %
  67 %   I s R L E                                                                 %
  68 %                                                                             %
  69 %                                                                             %
  70 %                                                                             %
  71 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  72 %
  73 %  IsRLE() returns MagickTrue if the image format type, identified by the
  74 %  magick string, is RLE.
  75 %
  76 %  The format of the ReadRLEImage method is:
  77 %
  78 %      MagickBooleanType IsRLE(const unsigned char *magick,const size_t length)
  79 %
  80 %  A description of each parameter follows:
  81 %
  82 %    o magick: compare image format pattern against these bytes.
  83 %
  84 %    o length: Specifies the length of the magick string.
  85 %
  86 %
  87 */
  88 static MagickBooleanType IsRLE(const unsigned char *magick,const size_t length)
  89 {
  90   if (length < 2)
  91     return(MagickFalse);
  92   if (memcmp(magick,"\122\314",2) == 0)
  93     return(MagickTrue);
  94   return(MagickFalse);
  95 }
  96 \f
  97 /*
  98 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  99 %                                                                             %
 100 %                                                                             %
 101 %                                                                             %
 102 %   R e a d R L E I m a g e                                                   %
 103 %                                                                             %
 104 %                                                                             %
 105 %                                                                             %
 106 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 107 %
 108 %  ReadRLEImage() reads a run-length encoded Utah Raster Toolkit
 109 %  image file and returns it.  It allocates the memory necessary for the new
 110 %  Image structure and returns a pointer to the new image.
 111 %
 112 %  The format of the ReadRLEImage method is:
 113 %
 114 %      Image *ReadRLEImage(const ImageInfo *image_info,ExceptionInfo *exception)
 115 %
 116 %  A description of each parameter follows:
 117 %
 118 %    o image_info: the image info.
 119 %
 120 %    o exception: return any errors or warnings in this structure.
 121 %
 122 %
 123 */
 124 static Image *ReadRLEImage(const ImageInfo *image_info,ExceptionInfo *exception)
 125 {
 126 #define SkipLinesOp  0x01
 127 #define SetColorOp  0x02
 128 #define SkipPixelsOp  0x03
 129 #define ByteDataOp  0x05
 130 #define RunDataOp  0x06
 131 #define EOFOp  0x07
 132
 133   char
 134     magick[12];
 135
 136   Image
 137     *image;
 138
 139   int
 140     opcode,
 141     operand,
 142     status;
 143
 144   MagickStatusType
 145     flags;
 146
 147   MagickSizeType
 148     number_pixels;
 149
 150   register IndexPacket
 151     *indexes;
 152
 153   register ssize_t
 154     x;
 155
 156   register PixelPacket
 157     *q;
 158
 159   register ssize_t
 160     i;
 161
 162   register unsigned char
 163     *p;
 164
 165   size_t
 166     bits_per_pixel,
 167     map_length,
 168     number_colormaps,
 169     number_planes,
 170     one;
 171
 172   ssize_t
 173     count,
 174     y;
 175
 176   unsigned char
 177     background_color[256],
 178     *colormap,
 179     pixel,
 180     plane,
 181     *rle_pixels;
 182
 183   /*
 184     Open image file.
 185   */
 186   assert(image_info != (const ImageInfo *) NULL);
 187   assert(image_info->signature == MagickSignature);
 188   if (image_info->debug != MagickFalse)
 189     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 190       image_info->filename);
 191   assert(exception != (ExceptionInfo *) NULL);
 192   assert(exception->signature == MagickSignature);
 193   image=AcquireImage(image_info);
 194   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 195   if (status == MagickFalse)
 196     {
 197       image=DestroyImageList(image);
 198       return((Image *) NULL);
 199     }
 200   /*
 201     Determine if this a RLE file.
 202   */
 203   count=ReadBlob(image,2,(unsigned char *) magick);
 204   if ((count == 0) || (memcmp(magick,"\122\314",2) != 0))
 205     ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 206   do
 207   {
 208     /*
 209       Read image header.
 210     */
 211     (void) ReadBlobLSBShort(image);
 212     (void) ReadBlobLSBShort(image);
 213     image->columns=ReadBlobLSBShort(image);
 214     image->rows=ReadBlobLSBShort(image);
 215     flags=(MagickStatusType) ReadBlobByte(image);
 216     image->matte=flags & 0x04 ? MagickTrue : MagickFalse;
 217     number_planes=1UL*ReadBlobByte(image);
 218     bits_per_pixel=1UL*ReadBlobByte(image);
 219     number_colormaps=1UL*ReadBlobByte(image);
 220     one=1;
 221     map_length=one << ReadBlobByte(image);
 222     if ((number_planes == 0) || (number_planes == 2) || (bits_per_pixel != 8) ||
 223         (image->columns == 0))
 224       ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 225     if (flags & 0x02)
 226       {
 227         /*
 228           No background color-- initialize to black.
 229         */
 230         for (i=0; i < (ssize_t) number_planes; i++)
 231           background_color[i]=0;
 232         (void) ReadBlobByte(image);
 233       }
 234     else
 235       {
 236         /*
 237           Initialize background color.
 238         */
 239         p=background_color;
 240         for (i=0; i < (ssize_t) number_planes; i++)
 241           *p++=(unsigned char) ReadBlobByte(image);
 242       }
 243     if ((number_planes & 0x01) == 0)
 244       (void) ReadBlobByte(image);
 245     colormap=(unsigned char *) NULL;
 246     if (number_colormaps != 0)
 247       {
 248         /*
 249           Read image colormaps.
 250         */
 251         colormap=(unsigned char *) AcquireQuantumMemory(number_colormaps,
 252           map_length*sizeof(*colormap));
 253         if (colormap == (unsigned char *) NULL)
 254           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 255         p=colormap;
 256         for (i=0; i < (ssize_t) number_colormaps; i++)
 257           for (x=0; x < (ssize_t) map_length; x++)
 258             *p++=(unsigned char) ScaleShortToQuantum(ReadBlobLSBShort(image));
 259       }
 260     if ((flags & 0x08) != 0)
 261       {
 262         char
 263           *comment;
 264
 265         size_t
 266           length;
 267
 268         /*
 269           Read image comment.
 270         */
 271         length=ReadBlobLSBShort(image);
 272         if (length != 0)
 273           {
 274             comment=(char *) AcquireQuantumMemory(length,sizeof(*comment));
 275             if (comment == (char *) NULL)
 276               ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 277             count=ReadBlob(image,length-1,(unsigned char *) comment);
 278             comment[length-1]='\0';
 279             (void) SetImageProperty(image,"comment",comment);
 280             comment=DestroyString(comment);
 281             if ((length & 0x01) == 0)
 282               (void) ReadBlobByte(image);
 283           }
 284       }
 285     if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))
 286       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
 287         break;
 288     /*
 289       Allocate RLE pixels.
 290     */
 291     if (image->matte != MagickFalse)
 292       number_planes++;
 293     number_pixels=(MagickSizeType) image->columns*image->rows;
 294     if ((number_pixels*number_planes) != (size_t) (number_pixels*number_planes))
 295       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 296     rle_pixels=(unsigned char *) AcquireQuantumMemory(image->columns,
 297       image->rows*number_planes*sizeof(*rle_pixels));
 298     if (rle_pixels == (unsigned char *) NULL)
 299       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 300     if ((flags & 0x01) && !(flags & 0x02))
 301       {
 302         ssize_t
 303           j;
 304
 305         /*
 306           Set background color.
 307         */
 308         p=rle_pixels;
 309         for (i=0; i < (ssize_t) number_pixels; i++)
 310         {
 311           if (image->matte == MagickFalse)
 312             for (j=0; j < (ssize_t) number_planes; j++)
 313               *p++=background_color[j];
 314           else
 315             {
 316               for (j=0; j < (ssize_t) (number_planes-1); j++)
 317                 *p++=background_color[j];
 318               *p++=0;  /* initialize matte channel */
 319             }
 320         }
 321       }
 322     /*
 323       Read runlength-encoded image.
 324     */
 325     plane=0;
 326     x=0;
 327     y=0;
 328     opcode=ReadBlobByte(image);
 329     do
 330     {
 331       switch (opcode & 0x3f)
 332       {
 333         case SkipLinesOp:
 334         {
 335           operand=ReadBlobByte(image);
 336           if (opcode & 0x40)
 337             operand=(int) ReadBlobLSBShort(image);
 338           x=0;
 339           y+=operand;
 340           break;
 341         }
 342         case SetColorOp:
 343         {
 344           operand=ReadBlobByte(image);
 345           plane=(unsigned char) operand;
 346           if (plane == 255)
 347             plane=(unsigned char) (number_planes-1);
 348           x=0;
 349           break;
 350         }
 351         case SkipPixelsOp:
 352         {
 353           operand=ReadBlobByte(image);
 354           if (opcode & 0x40)
 355             operand=(int) ReadBlobLSBShort(image);
 356           x+=operand;
 357           break;
 358         }
 359         case ByteDataOp:
 360         {
 361           operand=ReadBlobByte(image);
 362           if (opcode & 0x40)
 363             operand=(int) ReadBlobLSBShort(image);
 364           p=rle_pixels+((image->rows-y-1)*image->columns*number_planes)+
 365             x*number_planes+plane;
 366           operand++;
 367           for (i=0; i < (ssize_t) operand; i++)
 368           {
 369             pixel=(unsigned char) ReadBlobByte(image);
 370             if ((y < (ssize_t) image->rows) &&
 371                 ((x+i) < (ssize_t) image->columns))
 372               *p=pixel;
 373             p+=number_planes;
 374           }
 375           if (operand & 0x01)
 376             (void) ReadBlobByte(image);
 377           x+=operand;
 378           break;
 379         }
 380         case RunDataOp:
 381         {
 382           operand=ReadBlobByte(image);
 383           if (opcode & 0x40)
 384             operand=(int) ReadBlobLSBShort(image);
 385           pixel=(unsigned char) ReadBlobByte(image);
 386           (void) ReadBlobByte(image);
 387           operand++;
 388           p=rle_pixels+((image->rows-y-1)*image->columns*number_planes)+
 389             x*number_planes+plane;
 390           for (i=0; i < (ssize_t) operand; i++)
 391           {
 392             if ((y < (ssize_t) image->rows) &&
 393                 ((x+i) < (ssize_t) image->columns))
 394               *p=pixel;
 395             p+=number_planes;
 396           }
 397           x+=operand;
 398           break;
 399         }
 400         default:
 401           break;
 402       }
 403       opcode=ReadBlobByte(image);
 404     } while (((opcode & 0x3f) != EOFOp) && (opcode != EOF));
 405     if (number_colormaps != 0)
 406       {
 407         MagickStatusType
 408           mask;
 409
 410         /*
 411           Apply colormap affineation to image.
 412         */
 413         mask=(MagickStatusType) (map_length-1);
 414         p=rle_pixels;
 415         if (number_colormaps == 1)
 416           for (i=0; i < (ssize_t) number_pixels; i++)
 417           {
 418             *p=colormap[*p & mask];
 419             p++;
 420           }
 421         else
 422           if ((number_planes >= 3) && (number_colormaps >= 3))
 423             for (i=0; i < (ssize_t) number_pixels; i++)
 424               for (x=0; x < (ssize_t) number_planes; x++)
 425               {
 426                 *p=colormap[x*map_length+(*p & mask)];
 427                 p++;
 428               }
 429       }
 430     /*
 431       Initialize image structure.
 432     */
 433     if (number_planes >= 3)
 434       {
 435         /*
 436           Convert raster image to DirectClass pixel packets.
 437         */
 438         p=rle_pixels;
 439         for (y=0; y < (ssize_t) image->rows; y++)
 440         {
 441           q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
 442           if (q == (PixelPacket *) NULL)
 443             break;
 444           for (x=0; x < (ssize_t) image->columns; x++)
 445           {
 446             SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
 447             SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
 448             SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
 449             if (image->matte != MagickFalse)
 450               SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(*p++));
 451             q++;
 452           }
 453           if (SyncAuthenticPixels(image,exception) == MagickFalse)
 454             break;
 455           if (image->previous == (Image *) NULL)
 456             {
 457               status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
 458                 image->rows);
 459               if (status == MagickFalse)
 460                 break;
 461             }
 462         }
 463       }
 464     else
 465       {
 466         /*
 467           Create colormap.
 468         */
 469         if (number_colormaps == 0)
 470           map_length=256;
 471         if (AcquireImageColormap(image,map_length) == MagickFalse)
 472           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 473         p=colormap;
 474         if (number_colormaps == 1)
 475           for (i=0; i < (ssize_t) image->colors; i++)
 476           {
 477             /*
 478               Pseudocolor.
 479             */
 480             image->colormap[i].red=ScaleCharToQuantum((unsigned char) i);
 481             image->colormap[i].green=ScaleCharToQuantum((unsigned char) i);
 482             image->colormap[i].blue=ScaleCharToQuantum((unsigned char) i);
 483           }
 484         else
 485           if (number_colormaps > 1)
 486             for (i=0; i < (ssize_t) image->colors; i++)
 487             {
 488               image->colormap[i].red=ScaleCharToQuantum(*p);
 489               image->colormap[i].green=ScaleCharToQuantum(*(p+map_length));
 490               image->colormap[i].blue=ScaleCharToQuantum(*(p+map_length*2));
 491               p++;
 492             }
 493         p=rle_pixels;
 494         if (image->matte == MagickFalse)
 495           {
 496             /*
 497               Convert raster image to PseudoClass pixel packets.
 498             */
 499             for (y=0; y < (ssize_t) image->rows; y++)
 500             {
 501               q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
 502               if (q == (PixelPacket *) NULL)
 503                 break;
 504               indexes=GetAuthenticIndexQueue(image);
 505               for (x=0; x < (ssize_t) image->columns; x++)
 506                 SetIndexPixelComponent(indexes+x,*p++);
 507               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 508                 break;
 509               if (image->previous == (Image *) NULL)
 510                 {
 511                   status=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
 512                     y,image->rows);
 513                   if (status == MagickFalse)
 514                     break;
 515                 }
 516             }
 517             (void) SyncImage(image);
 518           }
 519         else
 520           {
 521             /*
 522               Image has a matte channel-- promote to DirectClass.
 523             */
 524             for (y=0; y < (ssize_t) image->rows; y++)
 525             {
 526               q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
 527               if (q == (PixelPacket *) NULL)
 528                 break;
 529               for (x=0; x < (ssize_t) image->columns; x++)
 530               {
 531                 SetRedPixelComponenet(q,image->colormap[*p++].red);
 532                 SetGreenPixelComponenet(q,image->colormap[*p++].green);
 533                 SetBluePixelComponenet(q,image->colormap[*p++].blue);
 534                 SetOpacityPixelComponent(q,QuantumRange-
 535                   ScaleCharToQuantum(*p++));
 536                 q++;
 537               }
 538               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 539                 break;
 540               if (image->previous == (Image *) NULL)
 541                 {
 542                   status=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
 543                     y,image->rows);
 544                   if (status == MagickFalse)
 545                     break;
 546                 }
 547             }
 548             image->colormap=(PixelPacket *)
 549               RelinquishMagickMemory(image->colormap);
 550             image->storage_class=DirectClass;
 551             image->colors=0;
 552           }
 553       }
 554     if (number_colormaps != 0)
 555       colormap=(unsigned char *) RelinquishMagickMemory(colormap);
 556     rle_pixels=(unsigned char *) RelinquishMagickMemory(rle_pixels);
 557     if (EOFBlob(image) != MagickFalse)
 558       {
 559         ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
 560           image->filename);
 561         break;
 562       }
 563     /*
 564       Proceed to next image.
 565     */
 566     if (image_info->number_scenes != 0)
 567       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
 568         break;
 569     (void) ReadBlobByte(image);
 570     count=ReadBlob(image,2,(unsigned char *) magick);
 571     if ((count != 0) && (memcmp(magick,"\122\314",2) == 0))
 572       {
 573         /*
 574           Allocate next image structure.
 575         */
 576         AcquireNextImage(image_info,image);
 577         if (GetNextImageInList(image) == (Image *) NULL)
 578           {
 579             image=DestroyImageList(image);
 580             return((Image *) NULL);
 581           }
 582         image=SyncNextImageInList(image);
 583         status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
 584           GetBlobSize(image));
 585         if (status == MagickFalse)
 586           break;
 587       }
 588   } while ((count != 0) && (memcmp(magick,"\122\314",2) == 0));
 589   (void) CloseBlob(image);
 590   return(GetFirstImageInList(image));
 591 }
 592 \f
 593 /*
 594 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 595 %                                                                             %
 596 %                                                                             %
 597 %                                                                             %
 598 %   R e g i s t e r R L E I m a g e                                           %
 599 %                                                                             %
 600 %                                                                             %
 601 %                                                                             %
 602 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 603 %
 604 %  RegisterRLEImage() adds attributes for the RLE image format to
 605 %  the list of supported formats.  The attributes include the image format
 606 %  tag, a method to read and/or write the format, whether the format
 607 %  supports the saving of more than one frame to the same file or blob,
 608 %  whether the format supports native in-memory I/O, and a brief
 609 %  description of the format.
 610 %
 611 %  The format of the RegisterRLEImage method is:
 612 %
 613 %      size_t RegisterRLEImage(void)
 614 %
 615 */
 616 ModuleExport size_t RegisterRLEImage(void)
 617 {
 618   MagickInfo
 619     *entry;
 620
 621   entry=SetMagickInfo("RLE");
 622   entry->decoder=(DecodeImageHandler *) ReadRLEImage;
 623   entry->magick=(IsImageFormatHandler *) IsRLE;
 624   entry->adjoin=MagickFalse;
 625   entry->description=ConstantString("Utah Run length encoded image");
 626   entry->module=ConstantString("RLE");
 627   (void) RegisterMagickInfo(entry);
 628   return(MagickImageCoderSignature);
 629 }
 630 \f
 631 /*
 632 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 633 %                                                                             %
 634 %                                                                             %
 635 %                                                                             %
 636 %   U n r e g i s t e r R L E I m a g e                                       %
 637 %                                                                             %
 638 %                                                                             %
 639 %                                                                             %
 640 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 641 %
 642 %  UnregisterRLEImage() removes format registrations made by the
 643 %  RLE module from the list of supported formats.
 644 %
 645 %  The format of the UnregisterRLEImage method is:
 646 %
 647 %      UnregisterRLEImage(void)
 648 %
 649 */
 650 ModuleExport void UnregisterRLEImage(void)
 651 {
 652   (void) UnregisterMagickInfo("RLE");
 653 }