← Back to branch summary

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

« back to all changes in this revision

Viewing changes to coders/rgb.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/rgb.c
100
100
    *canvas_image,
101
101
    *image;
102
102
 
103
 
  ssize_t
 
103
  long
104
104
    y;
105
105
 
106
106
  MagickBooleanType
115
115
  QuantumType
116
116
    quantum_type;
117
117
 
118
 
  register ssize_t
 
118
  register long
119
119
    i,
120
120
    j;
121
121
 
206
206
      */
207
207
      image->scene++;
208
208
      length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);
209
 
      for (y=0; y < (ssize_t) image->rows; y++)
 
209
      for (y=0; y < (long) image->rows; y++)
210
210
      {
211
211
        count=ReadBlob(image,length,pixels);
212
212
        if (count != (ssize_t) length)
250
250
            if (count != (ssize_t) length)
251
251
              break;
252
252
          }
253
 
        for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
253
        for (y=0; y < (long) image->extract_info.height; y++)
254
254
        {
255
255
          register const PixelPacket
256
256
            *restrict p;
257
257
 
258
 
          register ssize_t
 
258
          register long
259
259
            x;
260
260
 
261
261
          register PixelPacket
276
276
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
277
277
            break;
278
278
          if (((y-image->extract_info.y) >= 0) &&
279
 
              ((y-image->extract_info.y) < (ssize_t) image->rows))
 
279
              ((y-image->extract_info.y) < (long) image->rows))
280
280
            {
281
281
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
282
282
                canvas_image->columns,1,exception);
285
285
              if ((p == (const PixelPacket *) NULL) ||
286
286
                  (q == (PixelPacket *) NULL))
287
287
                break;
288
 
              for (x=0; x < (ssize_t) image->columns; x++)
 
288
              for (x=0; x < (long) image->columns; x++)
289
289
              {
290
290
                qx[0]=GetRedPixelComponent(p);
291
291
                qx[1]=GetGreenPixelComponent(p);
309
309
            }
310
310
          if (image->previous == (Image *) NULL)
311
311
            {
312
 
              status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
313
 
                image->rows);
 
312
              status=SetImageProgress(image,LoadImageTag,y,image->rows);
314
313
              if (status == MagickFalse)
315
314
                break;
316
315
            }
328
327
            length=GetQuantumExtent(canvas_image,quantum_info,quantum_types[0]);
329
328
            count=ReadBlob(image,length,pixels);
330
329
          }
331
 
        for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
330
        for (y=0; y < (long) image->extract_info.height; y++)
332
331
        {
333
332
          register const PixelPacket
334
333
            *restrict p;
335
334
 
336
 
          register ssize_t
 
335
          register long
337
336
            x;
338
337
 
339
338
          register PixelPacket
356
355
            if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
357
356
              break;
358
357
            if (((y-image->extract_info.y) >= 0) &&
359
 
                ((y-image->extract_info.y) < (ssize_t) image->rows))
 
358
                ((y-image->extract_info.y) < (long) image->rows))
360
359
              {
361
360
                p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,
362
361
                  0,canvas_image->columns,1,exception);
366
365
                    (q == (PixelPacket *) NULL))
367
366
                  break;
368
367
                if (i == (channels - 1))
369
 
                  for (x=0; x < (ssize_t) image->columns; x++)
 
368
                  for (x=0; x < (long) image->columns; x++)
370
369
                  {
371
370
                    SetRedPixelComponent(q,GetRedPixelComponent(p));
372
371
                    SetGreenPixelComponent(q,GetGreenPixelComponent(p));
382
381
          }
383
382
          if (image->previous == (Image *) NULL)
384
383
            {
385
 
              status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
386
 
                image->rows);
 
384
              status=SetImageProgress(image,LoadImageTag,y,image->rows);
387
385
              if (status == MagickFalse)
388
386
                break;
389
387
            }
402
400
          }
403
401
        for (i=0; i < channels; i++)
404
402
        {
405
 
          for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
403
          for (y=0; y < (long) image->extract_info.height; y++)
406
404
          {
407
405
            register const PixelPacket
408
406
              *restrict p;
409
407
 
410
 
            register ssize_t
 
408
            register long
411
409
              x;
412
410
 
413
411
            register PixelPacket
428
426
            if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
429
427
              break;
430
428
            if (((y-image->extract_info.y) >= 0) &&
431
 
                ((y-image->extract_info.y) < (ssize_t) image->rows))
 
429
                ((y-image->extract_info.y) < (long) image->rows))
432
430
              {
433
431
                p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
434
432
                  canvas_image->columns,1,exception);
437
435
                if ((p == (const PixelPacket *) NULL) ||
438
436
                    (q == (PixelPacket *) NULL))
439
437
                  break;
440
 
                for (x=0; x < (ssize_t) image->columns; x++)
 
438
                for (x=0; x < (long) image->columns; x++)
441
439
                {
442
440
                  switch(quantum_types[i])
443
441
                  {
496
494
                  break;
497
495
                }
498
496
          length=GetQuantumExtent(canvas_image,quantum_info,quantum_types[i]);
499
 
          for (j=0; j < (ssize_t) scene; j++)
500
 
            for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
497
          for (j=0; j < (long) scene; j++)
 
498
            for (y=0; y < (long) image->extract_info.height; y++)
501
499
              if (ReadBlob(image,length,pixels) != (ssize_t) length)
502
500
                {
503
501
                  ThrowFileException(exception,CorruptImageError,
505
503
                  break;
506
504
                }
507
505
          count=ReadBlob(image,length,pixels);
508
 
          for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
506
          for (y=0; y < (long) image->extract_info.height; y++)
509
507
          {
510
508
            register const PixelPacket
511
509
              *restrict p;
512
510
 
513
 
            register ssize_t
 
511
            register long
514
512
              x;
515
513
 
516
514
            register PixelPacket
531
529
            if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
532
530
              break;
533
531
            if (((y-image->extract_info.y) >= 0) &&
534
 
                ((y-image->extract_info.y) < (ssize_t) image->rows))
 
532
                ((y-image->extract_info.y) < (long) image->rows))
535
533
              {
536
534
                p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
537
535
                  canvas_image->columns,1,exception);
540
538
                if ((p == (const PixelPacket *) NULL) ||
541
539
                    (q == (PixelPacket *) NULL))
542
540
                  break;
543
 
                for (x=0; x < (ssize_t) image->columns; x++)
 
541
                for (x=0; x < (long) image->columns; x++)
544
542
                {
545
543
                  switch(quantum_types[i])
546
544
                  {
630
628
%
631
629
%  The format of the RegisterRGBImage method is:
632
630
%
633
 
%      size_t RegisterRGBImage(void)
 
631
%      unsigned long RegisterRGBImage(void)
634
632
%
635
633
*/
636
 
ModuleExport size_t RegisterRGBImage(void)
 
634
ModuleExport unsigned long RegisterRGBImage(void)
637
635
{
638
636
  MagickInfo
639
637
    *entry;
782
780
*/
783
781
static MagickBooleanType WriteRGBImage(const ImageInfo *image_info,Image *image)
784
782
{
785
 
  ssize_t
 
783
  long
786
784
    y;
787
785
 
788
786
  MagickBooleanType
798
796
    quantum_type,
799
797
    quantum_types[4];
800
798
 
801
 
  register ssize_t
 
799
  register long
802
800
    i;
803
801
 
804
802
  ssize_t
810
808
  unsigned char
811
809
    *pixels;
812
810
 
813
 
  size_t
 
811
  unsigned long
814
812
    channels;
815
813
 
816
814
  /*
845
843
      image->matte=MagickTrue;
846
844
      channels=4;
847
845
    }
848
 
  for (i=0; i < (ssize_t) channels; i++)
 
846
  for (i=0; i < (long) channels; i++)
849
847
  {
850
848
    switch (image_info->magick[i])
851
849
    {
889
887
          No interlacing:  RGBRGBRGBRGBRGBRGB...
890
888
        */
891
889
        image_view=AcquireCacheView(image);
892
 
        for (y=0; y < (ssize_t) image->rows; y++)
 
890
        for (y=0; y < (long) image->rows; y++)
893
891
        {
894
 
          register ssize_t
 
892
          register long
895
893
            x;
896
894
 
897
895
          register PixelPacket
901
899
            &image->exception);
902
900
          if (q == (PixelPacket *) NULL)
903
901
            break;
904
 
          for (x=0; x < (ssize_t) image->columns; x++)
 
902
          for (x=0; x < (long) image->columns; x++)
905
903
          {
906
904
            px=(*q);
907
905
            qx[0]=&(q->red);
924
922
            break;
925
923
          if (image->previous == (Image *) NULL)
926
924
            {
927
 
              status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
928
 
                image->rows);
 
925
              status=SetImageProgress(image,SaveImageTag,y,image->rows);
929
926
              if (status == MagickFalse)
930
927
                break;
931
928
            }
938
935
        /*
939
936
          Line interlacing:  RRR...GGG...BBB...RRR...GGG...BBB...
940
937
        */
941
 
        for (y=0; y < (ssize_t) image->rows; y++)
 
938
        for (y=0; y < (long) image->rows; y++)
942
939
        {
943
940
          register const PixelPacket
944
941
            *restrict p;
946
943
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
947
944
          if (p == (const PixelPacket *) NULL)
948
945
            break;
949
 
          for (i=0; i < (ssize_t) channels; i++)
 
946
          for (i=0; i < (long) channels; i++)
950
947
          {
951
948
            length=ExportQuantumPixels(image,(const CacheView *) NULL,
952
949
              quantum_info,quantum_types[i],pixels,&image->exception);
956
953
          }
957
954
          if (image->previous == (Image *) NULL)
958
955
            {
959
 
              status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
960
 
                image->rows);
 
956
              status=SetImageProgress(image,SaveImageTag,y,image->rows);
961
957
              if (status == MagickFalse)
962
958
                break;
963
959
            }
969
965
        /*
970
966
          Plane interlacing:  RRRRRR...GGGGGG...BBBBBB...
971
967
        */
972
 
        for (i=0; i < (ssize_t) channels; i++)
 
968
        for (i=0; i < (long) channels; i++)
973
969
        {
974
 
          for (y=0; y < (ssize_t) image->rows; y++)
 
970
          for (y=0; y < (long) image->rows; y++)
975
971
          {
976
972
            register const PixelPacket
977
973
              *restrict p;
1008
1004
        /*
1009
1005
          Partition interlacing:  RRRRRR..., GGGGGG..., BBBBBB...
1010
1006
        */
1011
 
        for (i=0; i < (ssize_t) channels; i++)
 
1007
        for (i=0; i < (long) channels; i++)
1012
1008
        {
1013
1009
          sfx[0]=image_info->magick[i];
1014
1010
          AppendImageFormat(sfx,image->filename);
1016
1012
            AppendBinaryBlobMode,&image->exception);
1017
1013
          if (status == MagickFalse)
1018
1014
            return(status);
1019
 
          for (y=0; y < (ssize_t) image->rows; y++)
 
1015
          for (y=0; y < (long) image->rows; y++)
1020
1016
          {
1021
1017
            register const PixelPacket
1022
1018
              *restrict p;