← Back to branch summary

~ubuntu-branches/ubuntu/natty/imagemagick/natty-updates

« back to all changes in this revision

Viewing changes to coders/xbm.c

  • Committer: Bazaar Package Importer
  • Author(s): Nelson A. de Oliveira
  • Date: 2010-06-20 19:59:55 UTC
  • mfrom: (6.2.8 sid)
  • Revision ID: james.westby@ubuntu.com-20100620195955-n3eq0yenhycw888i
Tags: 7:6.6.2.6-1
http://bugs.debian.org/579775
http://bugs.debian.org/582073
http://bugs.debian.org/583024
* New upstream release;
* Change Recommends on ufraw to ufraw-batch (Closes: #579775);
* Fix FTBFS when using dash to run the configure script, by setting
  CONFIG_SHELL=/bin/bash (Closes: #582073, #583024). Thank you, Niko Tyni!

Show diffs side-by-side

added added

removed removed

Lines of Context:
coders/xbm.c
17
17
%                                 July 1992                                   %
18
18
%                                                                             %
19
19
%                                                                             %
20
 
%  Copyright 1999-2009 ImageMagick Studio LLC, a non-profit organization      %
 
20
%  Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization      %
21
21
%  dedicated to making software imaging solutions freely available.           %
22
22
%                                                                             %
23
23
%  You may not use this file except in compliance with the License.  You may  %
44
44
#include "magick/blob-private.h"
45
45
#include "magick/cache.h"
46
46
#include "magick/color-private.h"
 
47
#include "magick/colormap.h"
47
48
#include "magick/colorspace.h"
48
49
#include "magick/exception.h"
49
50
#include "magick/exception-private.h"
147
148
    c&=0xff;
148
149
    if (isxdigit(c) != MagickFalse)
149
150
      {
150
 
        value=(int) ((unsigned long) value << 4)+hex_digits[c];
 
151
        value=(int) ((size_t) value << 4)+hex_digits[c];
151
152
        flag++;
152
153
        continue;
153
154
      }
166
167
  Image
167
168
    *image;
168
169
 
169
 
  long
 
170
  ssize_t
170
171
    y;
171
172
 
172
173
  MagickBooleanType
175
176
  register IndexPacket
176
177
    *indexes;
177
178
 
178
 
  register long
 
179
  register ssize_t
179
180
    i,
180
181
    x;
181
182
 
194
195
  unsigned char
195
196
    *data;
196
197
 
197
 
  unsigned long
 
198
  size_t
198
199
    bit,
199
200
    byte,
200
201
    bytes_per_line,
202
203
    value,
203
204
    version;
204
205
 
 
206
  unsigned long
 
207
    height,
 
208
    width;
 
209
 
205
210
  /*
206
211
    Open image file.
207
212
  */
222
227
  /*
223
228
    Read X bitmap header.
224
229
  */
 
230
  width=0;
 
231
  height=0;
225
232
  while (ReadBlobString(image,buffer) != (char *) NULL)
226
 
    if (sscanf(buffer,"#define %s %lu",name,&image->columns) == 2)
 
233
    if (sscanf(buffer,"#define %s %lu",name,&width) == 2)
227
234
      if ((strlen(name) >= 6) &&
228
235
          (LocaleCompare(name+strlen(name)-6,"_width") == 0))
229
 
          break;
 
236
        break;
230
237
  while (ReadBlobString(image,buffer) != (char *) NULL)
231
 
    if (sscanf(buffer,"#define %s %lu",name,&image->rows) == 2)
 
238
    if (sscanf(buffer,"#define %s %lu",name,&height) == 2)
232
239
      if ((strlen(name) >= 7) &&
233
240
          (LocaleCompare(name+strlen(name)-7,"_height") == 0))
234
 
          break;
 
241
        break;
 
242
  image->columns=width;
 
243
  image->rows=width;
235
244
  image->depth=8;
236
245
  image->storage_class=PseudoClass;
237
246
  image->colors=2;
327
336
    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
328
337
  p=data;
329
338
  if (version == 10)
330
 
    for (i=0; i < (long) (bytes_per_line*image->rows); (i+=2))
 
339
    for (i=0; i < (ssize_t) (bytes_per_line*image->rows); (i+=2))
331
340
    {
332
 
      value=(unsigned long) XBMInteger(image,hex_digits);
 
341
      value=(size_t) XBMInteger(image,hex_digits);
333
342
      *p++=(unsigned char) value;
334
343
      if ((padding == 0) || (((i+2) % bytes_per_line) != 0))
335
344
        *p++=(unsigned char) (value >> 8);
336
345
    }
337
346
  else
338
 
    for (i=0; i < (long) (bytes_per_line*image->rows); i++)
 
347
    for (i=0; i < (ssize_t) (bytes_per_line*image->rows); i++)
339
348
    {
340
 
      value=(unsigned long) XBMInteger(image,hex_digits);
 
349
      value=(size_t) XBMInteger(image,hex_digits);
341
350
      *p++=(unsigned char) value;
342
351
    }
343
352
  /*
344
353
    Convert X bitmap image to pixel packets.
345
354
  */
346
355
  p=data;
347
 
  for (y=0; y < (long) image->rows; y++)
 
356
  for (y=0; y < (ssize_t) image->rows; y++)
348
357
  {
349
358
    q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
350
359
    if (q == (PixelPacket *) NULL)
352
361
    indexes=GetAuthenticIndexQueue(image);
353
362
    bit=0;
354
363
    byte=0;
355
 
    for (x=0; x < (long) image->columns; x++)
 
364
    for (x=0; x < (ssize_t) image->columns; x++)
356
365
    {
357
366
      if (bit == 0)
358
 
        byte=(unsigned long) (*p++);
 
367
        byte=(size_t) (*p++);
359
368
      indexes[x]=(IndexPacket) ((byte & 0x01) != 0 ? 0x01 : 0x00);
360
369
      bit++;
361
370
      byte>>=1;
364
373
    }
365
374
    if (SyncAuthenticPixels(image,exception) == MagickFalse)
366
375
      break;
367
 
    status=SetImageProgress(image,LoadImageTag,y,image->rows);
 
376
    status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
 
377
                image->rows);
368
378
    if (status == MagickFalse)
369
379
      break;
370
380
  }
394
404
%
395
405
%  The format of the RegisterXBMImage method is:
396
406
%
397
 
%      unsigned long RegisterXBMImage(void)
 
407
%      size_t RegisterXBMImage(void)
398
408
%
399
409
*/
400
 
ModuleExport unsigned long RegisterXBMImage(void)
 
410
ModuleExport size_t RegisterXBMImage(void)
401
411
{
402
412
  MagickInfo
403
413
    *entry;
469
479
    basename[MaxTextExtent],
470
480
    buffer[MaxTextExtent];
471
481
 
472
 
  long
 
482
  ssize_t
473
483
    y;
474
484
 
475
485
  MagickBooleanType
478
488
  register const PixelPacket
479
489
    *p;
480
490
 
481
 
  register long
 
491
  register ssize_t
482
492
    x;
483
493
 
484
494
  ssize_t
485
495
    count;
486
496
 
487
 
  unsigned long
 
497
  size_t
488
498
    bit,
489
499
    byte;
490
500
 
506
516
    Write X bitmap header.
507
517
  */
508
518
  GetPathComponent(image->filename,BasePath,basename);
509
 
  (void) FormatMagickString(buffer,MaxTextExtent,"#define %s_width %lu\n",
510
 
    basename,image->columns);
 
519
  (void) FormatMagickString(buffer,MaxTextExtent,"#define %s_width %.20g\n",
 
520
    basename,(double) image->columns);
511
521
  (void) WriteBlob(image,strlen(buffer),(unsigned char *) buffer);
512
 
  (void) FormatMagickString(buffer,MaxTextExtent,"#define %s_height %lu\n",
513
 
    basename,image->rows);
 
522
  (void) FormatMagickString(buffer,MaxTextExtent,"#define %s_height %.20g\n",
 
523
    basename,(double) image->rows);
514
524
  (void) WriteBlob(image,strlen(buffer),(unsigned char *) buffer);
515
525
  (void) FormatMagickString(buffer,MaxTextExtent,
516
526
    "static char %s_bits[] = {\n",basename);
528
538
  y=0;
529
539
  (void) CopyMagickString(buffer," ",MaxTextExtent);
530
540
  (void) WriteBlob(image,strlen(buffer),(unsigned char *) buffer);
531
 
  for (y=0; y < (long) image->rows; y++)
 
541
  for (y=0; y < (ssize_t) image->rows; y++)
532
542
  {
533
543
    p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
534
544
    if (p == (const PixelPacket *) NULL)
535
545
      break;
536
 
    for (x=0; x < (long) image->columns; x++)
 
546
    for (x=0; x < (ssize_t) image->columns; x++)
537
547
    {
538
548
      byte>>=1;
539
549
      if (PixelIntensity(p) < ((MagickRealType) QuantumRange/2.0))
578
588
        bit=0;
579
589
        byte=0;
580
590
      };
581
 
    status=SetImageProgress(image,SaveImageTag,y,image->rows);
 
591
    status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
 
592
                image->rows);
582
593
    if (status == MagickFalse)
583
594
      break;
584
595
  }