← Back to branch summary

~ubuntu-branches/ubuntu/natty/imagemagick/natty-security

« back to all changes in this revision

Viewing changes to PerlMagick/Magick.xs

  • Committer: Bazaar Package Importer
  • Author(s): Luke Yelavich
  • Date: 2009-11-27 09:32:04 UTC
  • mfrom: (6.2.4 squeeze)
  • Revision ID: james.westby@ubuntu.com-20091127093204-m038t8kmxk6uvc25
Tags: 7:6.5.7.8-1ubuntu1
* Merge from debian testing.  Remaining changes:
  - Don't build-dep on librsvg, it brings in excessive dependencies
  - Don't build-dep on liblqr-1-0-dev, it is in universe

Show diffs side-by-side

added added

removed removed

Lines of Context:
PerlMagick/Magick.xs
79
79
#define DegreesToRadians(x)  (MagickPI*(x)/180.0)
80
80
#define EndOf(array)  (&array[NumberOf(array)])
81
81
#define MagickPI  3.14159265358979323846264338327950288419716939937510
82
 
#define MaxArguments  31
 
82
#define MaxArguments  32
83
83
#ifndef na
84
84
#define na  PL_na
85
85
#endif
286
286
      {"encoding", StringReference}, {"affine", ArrayReference},
287
287
      {"fill-pattern", ImageReference}, {"stroke-pattern", ImageReference},
288
288
      {"tile", ImageReference}, {"kerning", RealReference},
 
289
      {"interline-spacing", RealReference},
289
290
      {"interword-spacing", RealReference} } },
290
291
    { "ColorFloodfill", { {"geometry", StringReference},
291
292
      {"x", IntegerReference}, {"y", IntegerReference},
319
320
      {"origin", StringReference}, {"text", StringReference},
320
321
      {"fill-pattern", ImageReference}, {"stroke-pattern", ImageReference},
321
322
      {"vector-graphics", StringReference}, {"kerning", RealReference},
 
323
      {"interline-spacing", RealReference},
322
324
      {"interword-spacing", RealReference} } },
323
325
    { "Equalize", { {"channel", MagickChannelOptions} } },
324
326
    { "Gamma", { {"gamma", StringReference}, {"channel", MagickChannelOptions},
331
333
      {"fuzz", StringReference}, {"invert", MagickBooleanOptions} } },
332
334
    { "Modulate", { {"factor", StringReference}, {"hue", RealReference},
333
335
      {"saturation", RealReference}, {"whiteness", RealReference},
334
 
      {"brightness", RealReference}, {"luminosity", RealReference},
 
336
      {"brightness", RealReference}, {"lightness", RealReference},
335
337
      {"blackness", RealReference} } },
336
338
    { "Negate", { {"gray", MagickBooleanOptions},
337
339
      {"channel", MagickChannelOptions} } },
514
516
      {"color-correction-collection", StringReference} } },
515
517
    { "AutoGamma", { {"channel", MagickChannelOptions} } },
516
518
    { "AutoLevel", { {"channel", MagickChannelOptions} } },
 
519
    { "LevelColors", { {"invert", MagickBooleanOptions},
 
520
      {"black-point", RealReference}, {"white-point", RealReference},
 
521
      {"channel", MagickChannelOptions}, {"invert", MagickBooleanOptions} } },
 
522
    { "Clamp", { {"channel", MagickChannelOptions} } },
517
523
  };
518
524
 
519
525
static SplayTreeInfo
1515
1521
            x=0;
1516
1522
            y=0;
1517
1523
            items=sscanf(attribute,"%*[^[][%ld%*[,/]%ld",&x,&y);
1518
 
            image_view=OpenCacheView(image);
1519
 
            p=GetCacheViewPixels(image_view,x,y,1,1);
 
1524
            image_view=AcquireCacheView(image);
 
1525
            p=GetCacheViewAuthenticPixels(image_view,x,y,1,1,exception);
1520
1526
            if (p != (PixelPacket *) NULL)
1521
1527
              {
1522
 
                indexes=GetCacheViewIndexes(image_view);
 
1528
                indexes=GetCacheViewAuthenticIndexQueue(image_view);
1523
1529
                items=sscanf(SvPV(sval,na),"%ld",&index);
1524
1530
                if ((index >= 0) && (index < (long) image->colors))
1525
1531
                  *indexes=(IndexPacket) index;
1526
1532
                (void) SyncCacheViewAuthenticPixels(image_view,exception);
1527
1533
              }
1528
 
            image_view=CloseCacheView(image_view);
 
1534
            image_view=DestroyCacheView(image_view);
1529
1535
          }
1530
1536
          break;
1531
1537
        }
1745
1751
            x=0;
1746
1752
            y=0;
1747
1753
            items=sscanf(attribute,"%*[^[][%ld%*[,/]%ld",&x,&y);
1748
 
            image_view=OpenCacheView(image);
1749
 
            p=GetCacheViewPixels(image_view,x,y,1,1);
1750
 
            indexes=GetCacheViewIndexes(image_view);
 
1754
            image_view=AcquireCacheView(image);
 
1755
            p=GetCacheViewAuthenticPixels(image_view,x,y,1,1,exception);
 
1756
            indexes=GetCacheViewAuthenticIndexQueue(image_view);
1751
1757
            if (p != (PixelPacket *) NULL)
1752
1758
              {
1753
1759
                if ((strchr(SvPV(sval,na),',') == 0) ||
1777
1783
                  *indexes=RoundToQuantum(pixel.index);
1778
1784
                (void) SyncCacheViewAuthenticPixels(image_view,exception);
1779
1785
              }
1780
 
            image_view=CloseCacheView(image_view);
 
1786
            image_view=DestroyCacheView(image_view);
1781
1787
          }
1782
1788
          break;
1783
1789
        }
4361
4367
          if (LocaleCompare(attribute,"id") == 0)
4362
4368
            {
4363
4369
              if (image != (Image *) NULL)
4364
 
                s=newSViv(SetMagickRegistry(ImageRegistryType,image,0,
4365
 
                  &image->exception));
 
4370
                {
 
4371
                  char
 
4372
                    key[MaxTextExtent];
 
4373
 
 
4374
                  MagickBooleanType
 
4375
                    status;
 
4376
 
 
4377
                  static long
 
4378
                    id = 0;
 
4379
 
 
4380
                  (void) FormatMagickString(key,MaxTextExtent,"%ld\n",id);
 
4381
                  status=SetImageRegistry(ImageRegistryType,key,image,
 
4382
                    &image->exception);
 
4383
                  s=newSViv(id++);
 
4384
                }
4366
4385
              PUSHs(s ? sv_2mortal(s) : &sv_undef);
4367
4386
              continue;
4368
4387
            }
4394
4413
              x=0;
4395
4414
              y=0;
4396
4415
              items=sscanf(attribute,"%*[^[][%ld%*[,/]%ld",&x,&y);
4397
 
              image_view=OpenCacheView(image);
4398
 
              p=AcquireCacheViewPixels(image_view,x,y,1,1,&image->exception);
 
4416
              image_view=AcquireCacheView(image);
 
4417
              p=GetCacheViewVirtualPixels(image_view,x,y,1,1,&image->exception);
4399
4418
              if (p != (const PixelPacket *) NULL)
4400
4419
                {
4401
 
                  indexes=AcquireCacheViewIndexes(image_view);
 
4420
                  indexes=GetCacheViewVirtualIndexQueue(image_view);
4402
4421
                  (void) FormatMagickString(name,MaxTextExtent,QuantumFormat,
4403
4422
                    *indexes);
4404
4423
                  s=newSVpv(name,0);
4405
4424
                  PUSHs(s ? sv_2mortal(s) : &sv_undef);
4406
4425
                }
4407
 
              image_view=CloseCacheView(image_view);
 
4426
              image_view=DestroyCacheView(image_view);
4408
4427
              continue;
4409
4428
            }
4410
4429
          if (LocaleCompare(attribute,"iptc") == 0)
4654
4673
              y=0;
4655
4674
              items=sscanf(attribute,"%*[^[][%ld%*[,/]%ld",&x,&y);
4656
4675
              p=GetVirtualPixels(image,x,y,1,1,exception);
4657
 
              indexes=AcquireIndexes(image);
 
4676
              indexes=GetVirtualIndexQueue(image);
4658
4677
              if (image->colorspace != CMYKColorspace)
4659
4678
                (void) FormatMagickString(tuple,MaxTextExtent,QuantumFormat ","
4660
4679
                  QuantumFormat "," QuantumFormat "," QuantumFormat,
5761
5780
        double
5762
5781
          scale;
5763
5782
 
5764
 
        indexes=AcquireIndexes(image);
 
5783
        indexes=GetVirtualIndexQueue(image);
5765
5784
        scale=1.0;
5766
5785
        if (normalize != MagickFalse)
5767
5786
          scale=1.0/QuantumRange;
6757
6776
    AutoGammaImage     = 254
6758
6777
    AutoLevel          = 255
6759
6778
    AutoLevelImage     = 256
 
6779
    LevelColors        = 257
 
6780
    LevelColorsImage   = 258
 
6781
    Clamp              = 259
 
6782
    ClampImage         = 260
6760
6783
    MogrifyRegion      = 666
6761
6784
  PPCODE:
6762
6785
  {
7644
7667
          if (attribute_flag[29] != 0)
7645
7668
            draw_info->kerning=argument_list[29].real_reference;
7646
7669
          if (attribute_flag[30] != 0)
7647
 
            draw_info->interword_spacing=argument_list[30].real_reference;
 
7670
            draw_info->interline_spacing=argument_list[30].real_reference;
 
7671
          if (attribute_flag[31] != 0)
 
7672
            draw_info->interword_spacing=argument_list[31].real_reference;
7648
7673
          (void) AnnotateImage(image,draw_info);
7649
7674
          draw_info=DestroyDrawInfo(draw_info);
7650
7675
          break;
7750
7775
                    argument_list[6].string_reference,QuantumRange));
7751
7776
                  if (composite_image->matte != MagickTrue)
7752
7777
                    (void) SetImageOpacity(composite_image,OpaqueOpacity);
7753
 
                  composite_view=OpenCacheView(composite_image);
 
7778
                  composite_view=AcquireCacheView(composite_image);
7754
7779
                  for (y=0; y < (long) composite_image->rows ; y++)
7755
7780
                  {
7756
 
                    q=GetCacheViewPixels(composite_view,0,y,(long)
7757
 
                      composite_image->columns,1);
 
7781
                    q=GetCacheViewAuthenticPixels(composite_view,0,y,(long)
 
7782
                      composite_image->columns,1,exception);
7758
7783
                    for (x=0; x < (long) composite_image->columns; x++)
7759
7784
                    {
7760
7785
                      if (q->opacity == OpaqueOpacity)
7765
7790
                    if (sync == MagickFalse)
7766
7791
                      break;
7767
7792
                  }
7768
 
                  composite_view=CloseCacheView(composite_view);
 
7793
                  composite_view=DestroyCacheView(composite_view);
7769
7794
                }
7770
7795
            }
7771
7796
          if (attribute_flag[9] != 0)    /* "color=>" */
8142
8167
          if (attribute_flag[29] != 0)
8143
8168
            draw_info->kerning=argument_list[29].real_reference;
8144
8169
          if (attribute_flag[30] != 0)
8145
 
            draw_info->interword_spacing=argument_list[30].real_reference;
 
8170
            draw_info->interline_spacing=argument_list[30].real_reference;
 
8171
          if (attribute_flag[31] != 0)
 
8172
            draw_info->interword_spacing=argument_list[31].real_reference;
8146
8173
          DrawImage(image,draw_info);
8147
8174
          draw_info=DestroyDrawInfo(draw_info);
8148
8175
          break;
9232
9259
        }
9233
9260
        case 93:  /* Extent */
9234
9261
        {
9235
 
          GravityType
9236
 
            gravity;
9237
 
 
9238
 
          gravity=image->gravity;
9239
9262
          if (attribute_flag[7] != 0)
9240
 
            gravity=(GravityType) argument_list[7].long_reference;
 
9263
            image->gravity=(GravityType) argument_list[7].long_reference;
9241
9264
          if (attribute_flag[0] != 0)
9242
9265
            {
9243
 
              SetGeometry(image,&geometry);
9244
 
              (void) ParseAbsoluteGeometry(argument_list[0].string_reference,
9245
 
                &geometry);
9246
 
              GravityAdjustGeometry(image->columns,image->rows,image->gravity,
9247
 
                &geometry);
 
9266
              int
 
9267
                flags;
 
9268
 
 
9269
              flags=ParseGravityGeometry(image,
 
9270
                argument_list[0].string_reference,&geometry,exception);
 
9271
              if ((geometry.width != 0) || (geometry.height != 0))
 
9272
                {
 
9273
                  geometry.x=(-geometry.x);
 
9274
                  geometry.y=(-geometry.y);
 
9275
                }
9248
9276
            }
9249
9277
          if (attribute_flag[1] != 0)
9250
9278
            geometry.width=argument_list[1].long_reference;
9260
9288
          if (attribute_flag[6] != 0)
9261
9289
            (void) QueryColorDatabase(argument_list[6].string_reference,
9262
9290
              &image->background_color,exception);
9263
 
          GravityAdjustGeometry(image->columns,image->rows,gravity,&geometry);
9264
9291
          image=ExtentImage(image,&geometry,exception);
9265
9292
          break;
9266
9293
        }
9906
9933
        }
9907
9934
        case 125:  /* InverseFourierTransformImage */
9908
9935
        {
9909
 
          image=InverseFourierTransformImage(image,
 
9936
          image=InverseFourierTransformImage(image,image->next,
9910
9937
            argument_list[0].long_reference != 0 ? MagickTrue : MagickFalse,
9911
9938
            exception);
9912
9939
          break;
9933
9960
          (void) AutoLevelImageChannel(image,channel);
9934
9961
          break;
9935
9962
        }
 
9963
        case 129:  /* LevelColors */
 
9964
        {
 
9965
          MagickPixelPacket
 
9966
            black_point,
 
9967
            white_point;
 
9968
 
 
9969
          (void) QueryMagickColor("#000000",&black_point,exception);
 
9970
          (void) QueryMagickColor("#ffffff",&black_point,exception);
 
9971
          if (attribute_flag[1] != 0)
 
9972
             (void) QueryMagickColor(argument_list[1].string_reference,
 
9973
               &black_point,exception);
 
9974
          if (attribute_flag[2] != 0)
 
9975
             (void) QueryMagickColor(argument_list[2].string_reference,
 
9976
               &white_point,exception);
 
9977
          if (attribute_flag[3] != 0)
 
9978
            channel=(ChannelType) argument_list[3].long_reference;
 
9979
          (void) LevelColorsImageChannel(image,channel,&black_point,
 
9980
            &white_point,argument_list[0].long_reference != 0 ? MagickTrue :
 
9981
            MagickFalse);
 
9982
          break;
 
9983
        }
 
9984
        case 130:  /* Clamp */
 
9985
        {
 
9986
          if (attribute_flag[0] != 0)
 
9987
            channel=(ChannelType) argument_list[0].long_reference;
 
9988
          (void) ClampImageChannel(image,channel);
 
9989
          break;
 
9990
        }
9936
9991
      }
9937
9992
      if (next != (Image *) NULL)
9938
9993
        (void) CatchImageException(next);
11354
11409
        case 'i':
11355
11410
        case 'I':
11356
11411
        {
 
11412
          if (LocaleCompare(attribute,"interline-spacing") == 0)
 
11413
            {
 
11414
              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);
 
11415
              draw_info->interline_spacing=geometry_info.rho;
 
11416
              break;
 
11417
            }
11357
11418
          if (LocaleCompare(attribute,"interword-spacing") == 0)
11358
11419
            {
11359
11420
              flags=ParseGeometry(SvPV(ST(i),na),&geometry_info);