← Back to branch summary

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

« back to all changes in this revision

Viewing changes to coders/ycbcr.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/ycbcr.c
102
102
    *canvas_image,
103
103
    *image;
104
104
 
105
 
  ssize_t
 
105
  long
106
106
    y;
107
107
 
108
108
  MagickBooleanType
120
120
  register const PixelPacket
121
121
    *p;
122
122
 
123
 
  register ssize_t
 
123
  register long
124
124
    i,
125
125
    x;
126
126
 
190
190
      */
191
191
      image->scene++;
192
192
      length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);
193
 
      for (y=0; y < (ssize_t) image->rows; y++)
 
193
      for (y=0; y < (long) image->rows; y++)
194
194
      {
195
195
        count=ReadBlob(image,length,pixels);
196
196
        if (count != (ssize_t) length)
222
222
            length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);
223
223
            count=ReadBlob(image,length,pixels);
224
224
          }
225
 
        for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
225
        for (y=0; y < (long) image->extract_info.height; y++)
226
226
        {
227
227
          if (count != (ssize_t) length)
228
228
            {
239
239
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
240
240
            break;
241
241
          if (((y-image->extract_info.y) >= 0) && 
242
 
              ((y-image->extract_info.y) < (ssize_t) image->rows))
 
242
              ((y-image->extract_info.y) < (long) image->rows))
243
243
            {
244
244
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
245
245
                canvas_image->columns,1,exception);
248
248
              if ((p == (const PixelPacket *) NULL) ||
249
249
                  (q == (PixelPacket *) NULL))
250
250
                break;
251
 
              for (x=0; x < (ssize_t) image->columns; x++)
 
251
              for (x=0; x < (long) image->columns; x++)
252
252
              {
253
253
                SetRedPixelComponent(q,GetRedPixelComponent(p));
254
254
                SetGreenPixelComponent(q,GetGreenPixelComponent(p));
263
263
            }
264
264
          if (image->previous == (Image *) NULL)
265
265
            {
266
 
              status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
267
 
                image->rows);
 
266
              status=SetImageProgress(image,LoadImageTag,y,image->rows);
268
267
              if (status == MagickFalse)
269
268
                break;
270
269
            }
291
290
            length=GetQuantumExtent(canvas_image,quantum_info,RedQuantum);
292
291
            count=ReadBlob(image,length,pixels);
293
292
          }
294
 
        for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
293
        for (y=0; y < (long) image->extract_info.height; y++)
295
294
        {
296
295
          for (i=0; i < (image->matte != MagickFalse ? 4 : 3); i++)
297
296
          {
311
310
            if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
312
311
              break;
313
312
            if (((y-image->extract_info.y) >= 0) && 
314
 
                ((y-image->extract_info.y) < (ssize_t) image->rows))
 
313
                ((y-image->extract_info.y) < (long) image->rows))
315
314
              {
316
315
                p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,
317
316
                  0,canvas_image->columns,1,exception);
320
319
                if ((p == (const PixelPacket *) NULL) ||
321
320
                    (q == (PixelPacket *) NULL))
322
321
                  break;
323
 
                for (x=0; x < (ssize_t) image->columns; x++)
 
322
                for (x=0; x < (long) image->columns; x++)
324
323
                {
325
324
                  switch (quantum_type)
326
325
                  {
340
339
          }
341
340
          if (image->previous == (Image *) NULL)
342
341
            {
343
 
              status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
344
 
                image->rows);
 
342
              status=SetImageProgress(image,LoadImageTag,y,image->rows);
345
343
              if (status == MagickFalse)
346
344
                break;
347
345
            }
358
356
            length=GetQuantumExtent(canvas_image,quantum_info,RedQuantum);
359
357
            count=ReadBlob(image,length,pixels);
360
358
          }
361
 
        for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
359
        for (y=0; y < (long) image->extract_info.height; y++)
362
360
        {
363
361
          if (count != (ssize_t) length)
364
362
            {
375
373
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
376
374
            break;
377
375
          if (((y-image->extract_info.y) >= 0) && 
378
 
              ((y-image->extract_info.y) < (ssize_t) image->rows))
 
376
              ((y-image->extract_info.y) < (long) image->rows))
379
377
            {
380
378
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
381
379
                canvas_image->columns,1,exception);
384
382
              if ((p == (const PixelPacket *) NULL) ||
385
383
                  (q == (PixelPacket *) NULL))
386
384
                break;
387
 
              for (x=0; x < (ssize_t) image->columns; x++)
 
385
              for (x=0; x < (long) image->columns; x++)
388
386
              {
389
387
                SetRedPixelComponent(q,GetRedPixelComponent(p));
390
388
                p++;
401
399
            if (status == MagickFalse)
402
400
              break;
403
401
          }
404
 
        for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
402
        for (y=0; y < (long) image->extract_info.height; y++)
405
403
        {
406
404
          if (count != (ssize_t) length)
407
405
            {
418
416
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
419
417
            break;
420
418
          if (((y-image->extract_info.y) >= 0) && 
421
 
              ((y-image->extract_info.y) < (ssize_t) image->rows))
 
419
              ((y-image->extract_info.y) < (long) image->rows))
422
420
            {
423
421
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
424
422
                canvas_image->columns,1,exception);
427
425
              if ((p == (const PixelPacket *) NULL) ||
428
426
                  (q == (PixelPacket *) NULL))
429
427
                break;
430
 
              for (x=0; x < (ssize_t) image->columns; x++)
 
428
              for (x=0; x < (long) image->columns; x++)
431
429
              {
432
430
                SetGreenPixelComponent(q,GetGreenPixelComponent(p));
433
431
                p++;
444
442
            if (status == MagickFalse)
445
443
              break;
446
444
          }
447
 
        for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
445
        for (y=0; y < (long) image->extract_info.height; y++)
448
446
        {
449
447
          if (count != (ssize_t) length)
450
448
            {
461
459
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
462
460
            break;
463
461
          if (((y-image->extract_info.y) >= 0) && 
464
 
              ((y-image->extract_info.y) < (ssize_t) image->rows))
 
462
              ((y-image->extract_info.y) < (long) image->rows))
465
463
            {
466
464
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
467
465
                canvas_image->columns,1,exception);
470
468
              if ((p == (const PixelPacket *) NULL) ||
471
469
                  (q == (PixelPacket *) NULL))
472
470
                break;
473
 
              for (x=0; x < (ssize_t) image->columns; x++)
 
471
              for (x=0; x < (long) image->columns; x++)
474
472
              {
475
473
                SetBluePixelComponent(q,GetBluePixelComponent(p));
476
474
                p++;
489
487
          }
490
488
        if (image->matte != MagickFalse)
491
489
          {
492
 
            for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
490
            for (y=0; y < (long) image->extract_info.height; y++)
493
491
            {
494
492
              if (count != (ssize_t) length)
495
493
                {
506
504
              if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
507
505
                break;
508
506
              if (((y-image->extract_info.y) >= 0) && 
509
 
                  ((y-image->extract_info.y) < (ssize_t) image->rows))
 
507
                  ((y-image->extract_info.y) < (long) image->rows))
510
508
                {
511
509
                  p=GetVirtualPixels(canvas_image,
512
510
                    canvas_image->extract_info.x,0,canvas_image->columns,1,
516
514
                  if ((p == (const PixelPacket *) NULL) ||
517
515
                      (q == (PixelPacket *) NULL))
518
516
                    break;
519
 
                  for (x=0; x < (ssize_t) image->columns; x++)
 
517
                  for (x=0; x < (long) image->columns; x++)
520
518
                  {
521
519
                    SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
522
520
                    p++;
563
561
              break;
564
562
            }
565
563
        length=GetQuantumExtent(canvas_image,quantum_info,RedQuantum);
566
 
        for (i=0; i < (ssize_t) scene; i++)
567
 
          for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
564
        for (i=0; i < (long) scene; i++)
 
565
          for (y=0; y < (long) image->extract_info.height; y++)
568
566
            if (ReadBlob(image,length,pixels) != (ssize_t) length)
569
567
              {
570
568
                ThrowFileException(exception,CorruptImageError,
572
570
                break;
573
571
              }
574
572
        count=ReadBlob(image,length,pixels);
575
 
        for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
573
        for (y=0; y < (long) image->extract_info.height; y++)
576
574
        {
577
575
          if (count != (ssize_t) length)
578
576
            {
589
587
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
590
588
            break;
591
589
          if (((y-image->extract_info.y) >= 0) && 
592
 
              ((y-image->extract_info.y) < (ssize_t) image->rows))
 
590
              ((y-image->extract_info.y) < (long) image->rows))
593
591
            {
594
592
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
595
593
                canvas_image->columns,1,exception);
598
596
              if ((p == (const PixelPacket *) NULL) ||
599
597
                  (q == (PixelPacket *) NULL))
600
598
                break;
601
 
              for (x=0; x < (ssize_t) image->columns; x++)
 
599
              for (x=0; x < (long) image->columns; x++)
602
600
              {
603
601
                SetRedPixelComponent(q,GetRedPixelComponent(p));
604
602
                p++;
625
623
            return((Image *) NULL);
626
624
          }
627
625
        length=GetQuantumExtent(canvas_image,quantum_info,GreenQuantum);
628
 
        for (i=0; i < (ssize_t) scene; i++)
629
 
          for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
626
        for (i=0; i < (long) scene; i++)
 
627
          for (y=0; y < (long) image->extract_info.height; y++)
630
628
            if (ReadBlob(image,length,pixels) != (ssize_t) length)
631
629
              {
632
630
                ThrowFileException(exception,CorruptImageError,
634
632
                break;
635
633
              }
636
634
        count=ReadBlob(image,length,pixels);
637
 
        for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
635
        for (y=0; y < (long) image->extract_info.height; y++)
638
636
        {
639
637
          if (count != (ssize_t) length)
640
638
            {
651
649
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
652
650
            break;
653
651
          if (((y-image->extract_info.y) >= 0) && 
654
 
              ((y-image->extract_info.y) < (ssize_t) image->rows))
 
652
              ((y-image->extract_info.y) < (long) image->rows))
655
653
            {
656
654
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
657
655
                canvas_image->columns,1,exception);
660
658
              if ((p == (const PixelPacket *) NULL) ||
661
659
                  (q == (PixelPacket *) NULL))
662
660
                break;
663
 
              for (x=0; x < (ssize_t) image->columns; x++)
 
661
              for (x=0; x < (long) image->columns; x++)
664
662
              {
665
663
                SetGreenPixelComponent(q,GetGreenPixelComponent(p));
666
664
                p++;
687
685
            return((Image *) NULL);
688
686
          }
689
687
        length=GetQuantumExtent(canvas_image,quantum_info,BlueQuantum);
690
 
        for (i=0; i < (ssize_t) scene; i++)
691
 
          for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
688
        for (i=0; i < (long) scene; i++)
 
689
          for (y=0; y < (long) image->extract_info.height; y++)
692
690
            if (ReadBlob(image,length,pixels) != (ssize_t) length)
693
691
              {
694
692
                ThrowFileException(exception,CorruptImageError,
696
694
                break;
697
695
              }
698
696
        count=ReadBlob(image,length,pixels);
699
 
        for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
697
        for (y=0; y < (long) image->extract_info.height; y++)
700
698
        {
701
699
          if (count != (ssize_t) length)
702
700
            {
713
711
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
714
712
            break;
715
713
          if (((y-image->extract_info.y) >= 0) && 
716
 
              ((y-image->extract_info.y) < (ssize_t) image->rows))
 
714
              ((y-image->extract_info.y) < (long) image->rows))
717
715
            {
718
716
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
719
717
                canvas_image->columns,1,exception);
722
720
              if ((p == (const PixelPacket *) NULL) ||
723
721
                  (q == (PixelPacket *) NULL))
724
722
                break;
725
 
              for (x=0; x < (ssize_t) image->columns; x++)
 
723
              for (x=0; x < (long) image->columns; x++)
726
724
              {
727
725
                SetBluePixelComponent(q,GetBluePixelComponent(p));
728
726
                p++;
751
749
                return((Image *) NULL);
752
750
              }
753
751
            length=GetQuantumExtent(canvas_image,quantum_info,AlphaQuantum);
754
 
            for (i=0; i < (ssize_t) scene; i++)
755
 
              for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
752
            for (i=0; i < (long) scene; i++)
 
753
              for (y=0; y < (long) image->extract_info.height; y++)
756
754
                if (ReadBlob(image,length,pixels) != (ssize_t) length)
757
755
                  {
758
756
                    ThrowFileException(exception,CorruptImageError,
760
758
                    break;
761
759
                  }
762
760
            count=ReadBlob(image,length,pixels);
763
 
            for (y=0; y < (ssize_t) image->extract_info.height; y++)
 
761
            for (y=0; y < (long) image->extract_info.height; y++)
764
762
            {
765
763
              if (count != (ssize_t) length)
766
764
                {
777
775
              if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
778
776
                break;
779
777
              if (((y-image->extract_info.y) >= 0) && 
780
 
                  ((y-image->extract_info.y) < (ssize_t) image->rows))
 
778
                  ((y-image->extract_info.y) < (long) image->rows))
781
779
                {
782
780
                  p=GetVirtualPixels(canvas_image,
783
781
                    canvas_image->extract_info.x,0,canvas_image->columns,1,
787
785
                  if ((p == (const PixelPacket *) NULL) ||
788
786
                      (q == (PixelPacket *) NULL))
789
787
                    break;
790
 
                  for (x=0; x < (ssize_t) image->columns; x++)
 
788
                  for (x=0; x < (long) image->columns; x++)
791
789
                  {
792
790
                    SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
793
791
                    p++;
867
865
%
868
866
%  The format of the RegisterYCBCRImage method is:
869
867
%
870
 
%      size_t RegisterYCBCRImage(void)
 
868
%      unsigned long RegisterYCBCRImage(void)
871
869
%
872
870
*/
873
 
ModuleExport size_t RegisterYCBCRImage(void)
 
871
ModuleExport unsigned long RegisterYCBCRImage(void)
874
872
{
875
873
  MagickInfo
876
874
    *entry;
948
946
static MagickBooleanType WriteYCBCRImage(const ImageInfo *image_info,
949
947
  Image *image)
950
948
{
951
 
  ssize_t
 
949
  long
952
950
    y;
953
951
 
954
952
  MagickBooleanType
1022
1020
        /*
1023
1021
          No interlacing:  YCbCrYCbCrYCbCrYCbCrYCbCrYCbCr...
1024
1022
        */
1025
 
        for (y=0; y < (ssize_t) image->rows; y++)
 
1023
        for (y=0; y < (long) image->rows; y++)
1026
1024
        {
1027
1025
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1028
1026
          if (p == (const PixelPacket *) NULL)
1034
1032
            break;
1035
1033
          if (image->previous == (Image *) NULL)
1036
1034
            {
1037
 
              status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1038
 
                image->rows);
 
1035
              status=SetImageProgress(image,SaveImageTag,y,image->rows);
1039
1036
              if (status == MagickFalse)
1040
1037
                break;
1041
1038
            }
1047
1044
        /*
1048
1045
          Line interlacing:  YYY...CbCbCb...CrCrCr...YYY...CbCbCb...CrCrCr...
1049
1046
        */
1050
 
        for (y=0; y < (ssize_t) image->rows; y++)
 
1047
        for (y=0; y < (long) image->rows; y++)
1051
1048
        {
1052
1049
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1053
1050
          if (p == (const PixelPacket *) NULL)
1077
1074
            }
1078
1075
          if (image->previous == (Image *) NULL)
1079
1076
            {
1080
 
              status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1081
 
                image->rows);
 
1077
              status=SetImageProgress(image,SaveImageTag,y,image->rows);
1082
1078
              if (status == MagickFalse)
1083
1079
                break;
1084
1080
            }
1090
1086
        /*
1091
1087
          Plane interlacing:  YYYYYY...CbCbCbCbCbCb...CrCrCrCrCrCr...
1092
1088
        */
1093
 
        for (y=0; y < (ssize_t) image->rows; y++)
 
1089
        for (y=0; y < (long) image->rows; y++)
1094
1090
        {
1095
1091
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1096
1092
          if (p == (const PixelPacket *) NULL)
1107
1103
            if (status == MagickFalse)
1108
1104
              break;
1109
1105
          }
1110
 
        for (y=0; y < (ssize_t) image->rows; y++)
 
1106
        for (y=0; y < (long) image->rows; y++)
1111
1107
        {
1112
1108
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1113
1109
          if (p == (const PixelPacket *) NULL)
1124
1120
            if (status == MagickFalse)
1125
1121
              break;
1126
1122
          }
1127
 
        for (y=0; y < (ssize_t) image->rows; y++)
 
1123
        for (y=0; y < (long) image->rows; y++)
1128
1124
        {
1129
1125
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1130
1126
          if (p == (const PixelPacket *) NULL)
1143
1139
          }
1144
1140
        if (quantum_type == RGBAQuantum)
1145
1141
          {
1146
 
            for (y=0; y < (ssize_t) image->rows; y++)
 
1142
            for (y=0; y < (long) image->rows; y++)
1147
1143
            {
1148
1144
              p=GetVirtualPixels(image,0,y,image->columns,1,
1149
1145
                &image->exception);
1177
1173
          AppendBinaryBlobMode,&image->exception);
1178
1174
        if (status == MagickFalse)
1179
1175
          return(status);
1180
 
        for (y=0; y < (ssize_t) image->rows; y++)
 
1176
        for (y=0; y < (long) image->rows; y++)
1181
1177
        {
1182
1178
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1183
1179
          if (p == (const PixelPacket *) NULL)
1200
1196
          AppendBinaryBlobMode,&image->exception);
1201
1197
        if (status == MagickFalse)
1202
1198
          return(status);
1203
 
        for (y=0; y < (ssize_t) image->rows; y++)
 
1199
        for (y=0; y < (long) image->rows; y++)
1204
1200
        {
1205
1201
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1206
1202
          if (p == (const PixelPacket *) NULL)
1223
1219
          AppendBinaryBlobMode,&image->exception);
1224
1220
        if (status == MagickFalse)
1225
1221
          return(status);
1226
 
        for (y=0; y < (ssize_t) image->rows; y++)
 
1222
        for (y=0; y < (long) image->rows; y++)
1227
1223
        {
1228
1224
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1229
1225
          if (p == (const PixelPacket *) NULL)
1248
1244
              AppendBinaryBlobMode,&image->exception);
1249
1245
            if (status == MagickFalse)
1250
1246
              return(status);
1251
 
            for (y=0; y < (ssize_t) image->rows; y++)
 
1247
            for (y=0; y < (long) image->rows; y++)
1252
1248
            {
1253
1249
              p=GetVirtualPixels(image,0,y,image->columns,1,
1254
1250
                &image->exception);