← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/graphicsmagick/intrepid

« back to all changes in this revision

Viewing changes to coders/rle.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Kobras
  • Date: 2006-05-06 16:28:08 UTC
  • Revision ID: james.westby@ubuntu.com-20060506162808-vt2ni3r5nytcszms
Tags: upstream-1.1.7
Import upstream version 1.1.7

Show diffs side-by-side

added added

removed removed

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