← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/imagemagick/oneiric-updates

« back to all changes in this revision

Viewing changes to coders/cut.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson
  • Date: 2011-06-15 11:05:28 UTC
  • mfrom: (6.2.11 sid)
  • Revision ID: james.westby@ubuntu.com-20110615110528-08jgo07a4846xh8d
Tags: 8:6.6.0.4-3ubuntu1
https://launchpad.net/bugs/797595
* Resynchronise with Debian (LP: #797595).  Remaining changes:
  - Make ufraw-batch (universe) a suggestion instead of a recommendation.
  - Make debian/rules install target depend on check; they cannot reliably
    be run in parallel.
  - Don't set MAKEFLAGS in debian/rules; just pass it to the build.

Show diffs side-by-side

added added

removed removed

Lines of Context:
coders/cut.c
52
52
#include "magick/blob-private.h"
53
53
#include "magick/cache.h"
54
54
#include "magick/color.h"
 
55
#include "magick/colormap-private.h"
55
56
#include "magick/color-private.h"
56
 
#include "magick/colormap.h"
57
 
#include "magick/colormap-private.h"
58
57
#include "magick/exception.h"
59
58
#include "magick/exception-private.h"
60
59
#include "magick/image.h"
92
91
} CUTPalHeader;
93
92
 
94
93
 
95
 
static void InsertRow(ssize_t depth,unsigned char *p,ssize_t y,Image *image)
 
94
static void InsertRow(long depth,unsigned char *p,long y,Image *image)
96
95
{
97
96
  ExceptionInfo
98
97
    *exception;
99
98
 
100
 
  size_t bit; ssize_t x;
 
99
  unsigned long bit; long x;
101
100
  register PixelPacket *q;
102
101
  IndexPacket index;
103
102
  register IndexPacket *indexes;
113
112
        if (q == (PixelPacket *) NULL)
114
113
          break;
115
114
        indexes=GetAuthenticIndexQueue(image);
116
 
        for (x=0; x < ((ssize_t) image->columns-7); x+=8)
 
115
        for (x=0; x < ((long) image->columns-7); x+=8)
117
116
          {
118
117
            for (bit=0; bit < 8; bit++)
119
118
              {
120
119
                index=(IndexPacket) ((((*p) & (0x80 >> bit)) != 0) ? 0x01 : 0x00);
121
120
                indexes[x+bit]=index;
122
 
                *q++=image->colormap[(ssize_t) index];
 
121
                *q++=image->colormap[(long) index];
123
122
              }
124
123
            p++;
125
124
          }
129
128
              {
130
129
                index=(IndexPacket) ((((*p) & (0x80 >> bit)) != 0) ? 0x01 : 0x00);
131
130
                indexes[x+bit]=index;
132
 
                *q++=image->colormap[(ssize_t) index];
 
131
                *q++=image->colormap[(long) index];
133
132
              }
134
133
            p++;
135
134
          }
143
142
        if (q == (PixelPacket *) NULL)
144
143
          break;
145
144
        indexes=GetAuthenticIndexQueue(image);
146
 
        for (x=0; x < ((ssize_t) image->columns-1); x+=2)
 
145
        for (x=0; x < ((long) image->columns-1); x+=2)
147
146
          {
148
147
            index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
149
148
            indexes[x]=index;
150
 
            *q++=image->colormap[(ssize_t) index];
 
149
            *q++=image->colormap[(long) index];
151
150
            index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
152
151
            indexes[x]=index;
153
 
            *q++=image->colormap[(ssize_t) index];
 
152
            *q++=image->colormap[(long) index];
154
153
            index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
155
154
            indexes[x]=index;
156
 
            *q++=image->colormap[(ssize_t) index];
 
155
            *q++=image->colormap[(long) index];
157
156
            index=ConstrainColormapIndex(image,(*p) & 0x3);
158
157
            indexes[x+1]=index;
159
 
            *q++=image->colormap[(ssize_t) index];
 
158
            *q++=image->colormap[(long) index];
160
159
            p++;
161
160
          }
162
161
        if ((image->columns % 4) != 0)
163
162
          {
164
163
            index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
165
164
            indexes[x]=index;
166
 
            *q++=image->colormap[(ssize_t) index];
 
165
            *q++=image->colormap[(long) index];
167
166
            if ((image->columns % 4) >= 1)
168
167
 
169
168
              {
170
169
                index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
171
170
                indexes[x]=index;
172
 
                *q++=image->colormap[(ssize_t) index];
 
171
                *q++=image->colormap[(long) index];
173
172
                if ((image->columns % 4) >= 2)
174
173
 
175
174
                  {
176
175
                    index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
177
176
                    indexes[x]=index;
178
 
                    *q++=image->colormap[(ssize_t) index];
 
177
                    *q++=image->colormap[(long) index];
179
178
                  }
180
179
              }
181
180
            p++;
191
190
        if (q == (PixelPacket *) NULL)
192
191
          break;
193
192
        indexes=GetAuthenticIndexQueue(image);
194
 
        for (x=0; x < ((ssize_t) image->columns-1); x+=2)
 
193
        for (x=0; x < ((long) image->columns-1); x+=2)
195
194
          {
196
195
            index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
197
196
            indexes[x]=index;
198
 
            *q++=image->colormap[(ssize_t) index];
 
197
            *q++=image->colormap[(long) index];
199
198
            index=ConstrainColormapIndex(image,(*p) & 0xf);
200
199
            indexes[x+1]=index;
201
 
            *q++=image->colormap[(ssize_t) index];
 
200
            *q++=image->colormap[(long) index];
202
201
            p++;
203
202
          }
204
203
        if ((image->columns % 2) != 0)
205
204
          {
206
205
            index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
207
206
            indexes[x]=index;
208
 
            *q++=image->colormap[(ssize_t) index];
 
207
            *q++=image->colormap[(long) index];
209
208
            p++;
210
209
          }
211
210
        if (SyncAuthenticPixels(image,exception) == MagickFalse)
218
217
        if (q == (PixelPacket *) NULL) break;
219
218
        indexes=GetAuthenticIndexQueue(image);
220
219
 
221
 
        for (x=0; x < (ssize_t) image->columns; x++)
 
220
        for (x=0; x < (long) image->columns; x++)
222
221
          {
223
222
            index=ConstrainColormapIndex(image,*p);
224
223
            indexes[x]=index;
225
 
            *q++=image->colormap[(ssize_t) index];
 
224
            *q++=image->colormap[(long) index];
226
225
            p++;
227
226
          }
228
227
        if (SyncAuthenticPixels(image,exception) == MagickFalse)
241
240
  ExceptionInfo
242
241
    *exception;
243
242
 
244
 
  ssize_t
 
243
  long
245
244
    x,
246
245
    y;
247
246
 
255
254
  exception=(&image->exception);
256
255
  intensity=0;
257
256
  scale_intensity=ScaleCharToQuantum(16);
258
 
  for (y=0; y < (ssize_t) image->rows; y++)
 
257
  for (y=0; y < (long) image->rows; y++)
259
258
  {
260
259
    q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
261
 
    for (x=0; x < (ssize_t) image->columns; x++)
 
260
    for (x=0; x < (long) image->columns; x++)
262
261
    {
263
262
      if (intensity < q->red)
264
263
        intensity=q->red;
309
308
  MagickOffsetType
310
309
    offset;
311
310
 
312
 
  size_t EncodedByte;
 
311
  unsigned long EncodedByte;
313
312
  unsigned char RunCount,RunValue,RunCountMasked;
314
313
  CUTHeader  Header;
315
314
  CUTPalHeader PalHeader;
316
 
  ssize_t depth;
317
 
  ssize_t i,j;
318
 
  ssize_t ldblk;
 
315
  long depth;
 
316
  long i,j;
 
317
  long ldblk;
319
318
  unsigned char *BImgBuff=NULL,*ptrB;
320
319
  PixelPacket *q;
321
320
 
359
358
  while((int) RunCountMasked!=0)  /*end of line?*/
360
359
    {
361
360
      i=1;
362
 
      if((int) RunCount<0x80) i=(ssize_t) RunCountMasked;
 
361
      if((int) RunCount<0x80) i=(long) RunCountMasked;
363
362
      offset=SeekBlob(image,TellBlob(image)+i,SEEK_SET);
364
363
      if (offset < 0)
365
364
        ThrowReaderException(CorruptImageError,"ImproperImageHeader");
366
365
      if(EOFBlob(image) != MagickFalse) goto CUT_KO;  /*wrong data*/
367
366
      EncodedByte-=i+1;
368
 
      ldblk+=(ssize_t) RunCountMasked;
 
367
      ldblk+=(long) RunCountMasked;
369
368
 
370
369
      RunCount=(unsigned char) ReadBlobByte(image);
371
370
      if(EOFBlob(image) != MagickFalse)  goto CUT_KO;  /*wrong data: unexpected eof in line*/
382
381
  image->columns=Header.Width;
383
382
  image->rows=Header.Height;
384
383
  image->depth=8;
385
 
  image->colors=(size_t) (GetQuantumRange(1UL*i)+1);
 
384
  image->colors=(unsigned long) (GetQuantumRange(1UL*i)+1);
386
385
 
387
386
  if (image_info->ping) goto Finish;
388
387
 
390
389
  if ((clone_info=CloneImageInfo(image_info)) == NULL) goto NoPalette;
391
390
 
392
391
 
393
 
  i=(ssize_t) strlen(clone_info->filename);
 
392
  i=(long) strlen(clone_info->filename);
394
393
  j=i;
395
394
  while(--i>0)
396
395
    {
461
460
 
462
461
      for(i=0;i<=(int) PalHeader.MaxIndex;i++)
463
462
        {      /*this may be wrong- I don't know why is palette such strange*/
464
 
          j=(ssize_t) TellBlob(palette);
 
463
          j=(long) TellBlob(palette);
465
464
          if((j % 512)>512-6)
466
465
            {
467
466
              j=((j / 512)+1)*512;
505
504
          ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
506
505
            }
507
506
 
508
 
      for (i=0; i < (ssize_t)image->colors; i++)
 
507
      for (i=0; i < (long)image->colors; i++)
509
508
        {
510
509
          image->colormap[i].red=ScaleCharToQuantum((unsigned char) i);
511
510
          image->colormap[i].green=ScaleCharToQuantum((unsigned char) i);
534
533
 
535
534
      while((int) RunCountMasked!=0)
536
535
        {
537
 
          if((ssize_t) RunCountMasked>j)
 
536
          if((long) RunCountMasked>j)
538
537
            {    /*Wrong Data*/
539
538
              RunCountMasked=(unsigned char) j;
540
539
              if(j==0)
573
572
        {
574
573
          if(GetCutColors(image)==2)
575
574
            {
576
 
              for (i=0; i < (ssize_t)image->colors; i++)
 
575
              for (i=0; i < (long)image->colors; i++)
577
576
                {
578
577
                  register Quantum
579
578
                    sample;
584
583
                }
585
584
 
586
585
              image->colormap[1].red=image->colormap[1].green=image->colormap[1].blue=(Quantum) QuantumRange;
587
 
              for (i=0; i < (ssize_t)image->rows; i++)
 
586
              for (i=0; i < (long)image->rows; i++)
588
587
                {
589
588
                  q=QueueAuthenticPixels(image,0,i,image->columns,1,exception);
590
 
                  for (j=0; j < (ssize_t)image->columns; j++)
 
589
                  for (j=0; j < (long)image->columns; j++)
591
590
                    {
592
591
                      if(q->red==ScaleCharToQuantum(1))
593
592
                        {
635
634
%
636
635
%  The format of the RegisterCUTImage method is:
637
636
%
638
 
%      size_t RegisterCUTImage(void)
 
637
%      unsigned long RegisterCUTImage(void)
639
638
%
640
639
*/
641
 
ModuleExport size_t RegisterCUTImage(void)
 
640
ModuleExport unsigned long RegisterCUTImage(void)
642
641
{
643
642
  MagickInfo
644
643
    *entry;