← Back to branch summary

~ubuntu-branches/ubuntu/quantal/imagemagick/quantal

« back to all changes in this revision

Viewing changes to coders/ycbcr.c

  • Committer: Bazaar Package Importer
  • Author(s): Muharem Hrnjadovic
  • Date: 2009-06-04 13:01:13 UTC
  • mfrom: (1.1.5 upstream) (6.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20090604130113-my9114jxmafpwew3
Tags: 7:6.5.1.0-1.1ubuntu1
* Merge from debian unstable, remaining changes:
  - (Build-)depend on libltdl7-dev instead of libltdl3-dev (the armel buildds
    currently have both available).
  - Don't build-dep on librsvg, it brings in excessive dependencies

Show diffs side-by-side

added added

removed removed

Lines of Context:
coders/ycbcr.c
17
17
%                                 July 1992                                   %
18
18
%                                                                             %
19
19
%                                                                             %
20
 
%  Copyright 1999-2008 ImageMagick Studio LLC, a non-profit organization      %
 
20
%  Copyright 1999-2009 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  %
42
42
#include "magick/studio.h"
43
43
#include "magick/blob.h"
44
44
#include "magick/blob-private.h"
 
45
#include "magick/cache.h"
45
46
#include "magick/colorspace.h"
46
47
#include "magick/constitute.h"
47
48
#include "magick/exception.h"
172
173
    exception);
173
174
  (void) SetImageVirtualPixelMethod(canvas_image,BlackVirtualPixelMethod);
174
175
  quantum_info=AcquireQuantumInfo(image_info,canvas_image);
 
176
  if (quantum_info == (QuantumInfo *) NULL)
 
177
    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
175
178
  pixels=GetQuantumPixels(quantum_info);
176
179
  quantum_type=RGBQuantum;
177
180
  if (LocaleCompare(image_info->magick,"YCbCrA") == 0)
206
209
      if (image->scene >= (image_info->scene+image_info->number_scenes-1))
207
210
        break;
208
211
    image->colorspace=YCbCrColorspace;
209
 
    if ((SetImageExtent(image,0,0) == MagickFalse) ||
210
 
        (SetImageExtent(canvas_image,0,0) == MagickFalse))
211
 
      break;
212
212
    switch (image_info->interlace)
213
213
    {
214
214
      case NoInterlace:
226
226
          }
227
227
        for (y=0; y < (long) image->extract_info.height; y++)
228
228
        {
229
 
          q=GetImagePixels(canvas_image,0,0,canvas_image->columns,1);
 
229
          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 
230
            exception);
230
231
          if (q == (PixelPacket *) NULL)
231
232
            break;
232
 
          length=ImportQuantumPixels(canvas_image,quantum_info,quantum_type,
233
 
            pixels);
234
 
          if (SyncImagePixels(canvas_image) == MagickFalse)
 
233
          length=ImportQuantumPixels(canvas_image,(ViewInfo *) NULL,
 
234
            quantum_info,quantum_type,pixels,exception);
 
235
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
235
236
            break;
236
237
          if (((y-image->extract_info.y) >= 0) && 
237
238
              ((y-image->extract_info.y) < (long) image->rows))
238
239
            {
239
 
              p=AcquireImagePixels(canvas_image,canvas_image->extract_info.x,0,
 
240
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
240
241
                canvas_image->columns,1,exception);
241
 
              q=SetImagePixels(image,0,y-image->extract_info.y,image->columns,
242
 
                1);
 
242
              q=QueueAuthenticPixels(image,0,y-image->extract_info.y,
 
243
                image->columns,1,exception);
243
244
              if ((p == (const PixelPacket *) NULL) ||
244
245
                  (q == (PixelPacket *) NULL))
245
246
                break;
253
254
                p++;
254
255
                q++;
255
256
              }
256
 
              if (SyncImagePixels(image) == MagickFalse)
 
257
              if (SyncAuthenticPixels(image,exception) == MagickFalse)
257
258
                break;
258
259
            }
259
260
          if (image->previous == (Image *) NULL)
294
295
          for (i=0; i < (image->matte != MagickFalse ? 4 : 3); i++)
295
296
          {
296
297
            quantum_type=quantum_types[i];
297
 
            q=GetImagePixels(canvas_image,0,0,canvas_image->columns,1);
 
298
            q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 
299
              exception);
298
300
            if (q == (PixelPacket *) NULL)
299
301
              break;
300
 
            length=ImportQuantumPixels(canvas_image,quantum_info,quantum_type,
301
 
              pixels);
302
 
            if (SyncImagePixels(canvas_image) == MagickFalse)
 
302
            length=ImportQuantumPixels(canvas_image,(ViewInfo *) NULL,
 
303
              quantum_info,quantum_type,pixels,exception);
 
304
            if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
303
305
              break;
304
306
            if (((y-image->extract_info.y) >= 0) && 
305
307
                ((y-image->extract_info.y) < (long) image->rows))
306
308
              {
307
 
                p=AcquireImagePixels(canvas_image,canvas_image->extract_info.x,
 
309
                p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,
308
310
                  0,canvas_image->columns,1,exception);
309
 
                q=GetImagePixels(image,0,y-image->extract_info.y,image->columns,
310
 
                  1);
 
311
                q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 
312
                  image->columns,1,exception);
311
313
                if ((p == (const PixelPacket *) NULL) ||
312
314
                    (q == (PixelPacket *) NULL))
313
315
                  break;
324
326
                  p++;
325
327
                  q++;
326
328
                }
327
 
                if (SyncImagePixels(image) == MagickFalse)
 
329
                if (SyncAuthenticPixels(image,exception) == MagickFalse)
328
330
                  break;
329
331
              }
330
332
            count=ReadBlob(image,length,pixels);
354
356
          }
355
357
        for (y=0; y < (long) image->extract_info.height; y++)
356
358
        {
357
 
          q=GetImagePixels(canvas_image,0,0,canvas_image->columns,1);
 
359
          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 
360
            exception);
358
361
          if (q == (PixelPacket *) NULL)
359
362
            break;
360
 
          length=ImportQuantumPixels(canvas_image,quantum_info,RedQuantum,
361
 
            pixels);
362
 
          if (SyncImagePixels(canvas_image) == MagickFalse)
 
363
          length=ImportQuantumPixels(canvas_image,(ViewInfo *) NULL,
 
364
            quantum_info,RedQuantum,pixels,exception);
 
365
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
363
366
            break;
364
367
          if (((y-image->extract_info.y) >= 0) && 
365
368
              ((y-image->extract_info.y) < (long) image->rows))
366
369
            {
367
 
              p=AcquireImagePixels(canvas_image,canvas_image->extract_info.x,0,
 
370
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
368
371
                canvas_image->columns,1,exception);
369
 
              q=GetImagePixels(image,0,y-image->extract_info.y,image->columns,
370
 
                1);
 
372
              q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 
373
                image->columns,1,exception);
371
374
              if ((p == (const PixelPacket *) NULL) ||
372
375
                  (q == (PixelPacket *) NULL))
373
376
                break;
377
380
                p++;
378
381
                q++;
379
382
              }
380
 
              if (SyncImagePixels(image) == MagickFalse)
 
383
              if (SyncAuthenticPixels(image,exception) == MagickFalse)
381
384
                break;
382
385
            }
383
386
          count=ReadBlob(image,length,pixels);
392
395
          }
393
396
        for (y=0; y < (long) image->extract_info.height; y++)
394
397
        {
395
 
          q=GetImagePixels(canvas_image,0,0,canvas_image->columns,1);
 
398
          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 
399
            exception);
396
400
          if (q == (PixelPacket *) NULL)
397
401
            break;
398
 
          length=ImportQuantumPixels(canvas_image,quantum_info,GreenQuantum,
399
 
            pixels);
400
 
          if (SyncImagePixels(canvas_image) == MagickFalse)
 
402
          length=ImportQuantumPixels(canvas_image,(ViewInfo *) NULL,
 
403
            quantum_info,GreenQuantum,pixels,exception);
 
404
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
401
405
            break;
402
406
          if (((y-image->extract_info.y) >= 0) && 
403
407
              ((y-image->extract_info.y) < (long) image->rows))
404
408
            {
405
 
              p=AcquireImagePixels(canvas_image,canvas_image->extract_info.x,0,
 
409
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
406
410
                canvas_image->columns,1,exception);
407
 
              q=GetImagePixels(image,0,y-image->extract_info.y,image->columns,
408
 
                1);
 
411
              q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 
412
                image->columns,1,exception);
409
413
              if ((p == (const PixelPacket *) NULL) ||
410
414
                  (q == (PixelPacket *) NULL))
411
415
                break;
415
419
                p++;
416
420
                q++;
417
421
              }
418
 
              if (SyncImagePixels(image) == MagickFalse)
 
422
              if (SyncAuthenticPixels(image,exception) == MagickFalse)
419
423
                break;
420
424
           }
421
425
          count=ReadBlob(image,length,pixels);
430
434
          }
431
435
        for (y=0; y < (long) image->extract_info.height; y++)
432
436
        {
433
 
          q=GetImagePixels(canvas_image,0,0,canvas_image->columns,1);
 
437
          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 
438
            exception);
434
439
          if (q == (PixelPacket *) NULL)
435
440
            break;
436
 
          length=ImportQuantumPixels(canvas_image,quantum_info,BlueQuantum,
437
 
            pixels);
438
 
          if (SyncImagePixels(canvas_image) == MagickFalse)
 
441
          length=ImportQuantumPixels(canvas_image,(ViewInfo *) NULL,
 
442
            quantum_info,BlueQuantum,pixels,exception);
 
443
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
439
444
            break;
440
445
          if (((y-image->extract_info.y) >= 0) && 
441
446
              ((y-image->extract_info.y) < (long) image->rows))
442
447
            {
443
 
              p=AcquireImagePixels(canvas_image,canvas_image->extract_info.x,0,
 
448
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
444
449
                canvas_image->columns,1,exception);
445
 
              q=GetImagePixels(image,0,y-image->extract_info.y,image->columns,
446
 
                1);
 
450
              q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 
451
                image->columns,1,exception);
447
452
              if ((p == (const PixelPacket *) NULL) ||
448
453
                  (q == (PixelPacket *) NULL))
449
454
                break;
453
458
                p++;
454
459
                q++;
455
460
              }
456
 
              if (SyncImagePixels(image) == MagickFalse)
 
461
              if (SyncAuthenticPixels(image,exception) == MagickFalse)
457
462
                break;
458
463
            }
459
464
          count=ReadBlob(image,length,pixels);
470
475
          {
471
476
            for (y=0; y < (long) image->extract_info.height; y++)
472
477
            {
473
 
              q=GetImagePixels(canvas_image,0,0,canvas_image->columns,1);
 
478
              q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 
479
                exception);
474
480
              if (q == (PixelPacket *) NULL)
475
481
                break;
476
 
              length=ImportQuantumPixels(canvas_image,quantum_info,AlphaQuantum,
477
 
                pixels);
478
 
              if (SyncImagePixels(canvas_image) == MagickFalse)
 
482
              length=ImportQuantumPixels(canvas_image,(ViewInfo *) NULL,
 
483
                quantum_info,AlphaQuantum,pixels,exception);
 
484
              if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
479
485
                break;
480
486
              if (((y-image->extract_info.y) >= 0) && 
481
487
                  ((y-image->extract_info.y) < (long) image->rows))
482
488
                {
483
 
                  p=AcquireImagePixels(canvas_image,
 
489
                  p=GetVirtualPixels(canvas_image,
484
490
                    canvas_image->extract_info.x,0,canvas_image->columns,1,
485
491
                    exception);
486
 
                  q=GetImagePixels(image,0,y-image->extract_info.y,
487
 
                    image->columns,1);
 
492
                  q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 
493
                    image->columns,1,exception);
488
494
                  if ((p == (const PixelPacket *) NULL) ||
489
495
                      (q == (PixelPacket *) NULL))
490
496
                    break;
494
500
                    p++;
495
501
                    q++;
496
502
                  }
497
 
                  if (SyncImagePixels(image) == MagickFalse)
 
503
                  if (SyncAuthenticPixels(image,exception) == MagickFalse)
498
504
                    break;
499
505
                }
500
506
              count=ReadBlob(image,length,pixels);
550
556
          break;
551
557
        for (y=0; y < (long) image->extract_info.height; y++)
552
558
        {
553
 
          q=GetImagePixels(canvas_image,0,0,canvas_image->columns,1);
 
559
          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 
560
            exception);
554
561
          if (q == (PixelPacket *) NULL)
555
562
            break;
556
 
          length=ImportQuantumPixels(canvas_image,quantum_info,RedQuantum,
557
 
            pixels);
558
 
          if (SyncImagePixels(canvas_image) == MagickFalse)
 
563
          length=ImportQuantumPixels(canvas_image,(ViewInfo *) NULL,
 
564
            quantum_info,RedQuantum,pixels,exception);
 
565
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
559
566
            break;
560
567
          if (((y-image->extract_info.y) >= 0) && 
561
568
              ((y-image->extract_info.y) < (long) image->rows))
562
569
            {
563
 
              p=AcquireImagePixels(canvas_image,canvas_image->extract_info.x,0,
 
570
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
564
571
                canvas_image->columns,1,exception);
565
 
              q=GetImagePixels(image,0,y-image->extract_info.y,image->columns,
566
 
                1);
 
572
              q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 
573
                image->columns,1,exception);
567
574
              if ((p == (const PixelPacket *) NULL) ||
568
575
                  (q == (PixelPacket *) NULL))
569
576
                break;
573
580
                p++;
574
581
                q++;
575
582
              }
576
 
              if (SyncImagePixels(image) == MagickFalse)
 
583
              if (SyncAuthenticPixels(image,exception) == MagickFalse)
577
584
                break;
578
585
            }
579
586
          count=ReadBlob(image,length,pixels);
609
616
          break;
610
617
        for (y=0; y < (long) image->extract_info.height; y++)
611
618
        {
612
 
          q=GetImagePixels(canvas_image,0,0,canvas_image->columns,1);
 
619
          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 
620
            exception);
613
621
          if (q == (PixelPacket *) NULL)
614
622
            break;
615
 
          length=ImportQuantumPixels(canvas_image,quantum_info,GreenQuantum,
616
 
            pixels);
617
 
          if (SyncImagePixels(canvas_image) == MagickFalse)
 
623
          length=ImportQuantumPixels(canvas_image,(ViewInfo *) NULL,
 
624
            quantum_info,GreenQuantum,pixels,exception);
 
625
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
618
626
            break;
619
627
          if (((y-image->extract_info.y) >= 0) && 
620
628
              ((y-image->extract_info.y) < (long) image->rows))
621
629
            {
622
 
              p=AcquireImagePixels(canvas_image,canvas_image->extract_info.x,0,
 
630
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
623
631
                canvas_image->columns,1,exception);
624
 
              q=GetImagePixels(image,0,y-image->extract_info.y,image->columns,
625
 
                1);
 
632
              q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 
633
                image->columns,1,exception);
626
634
              if ((p == (const PixelPacket *) NULL) ||
627
635
                  (q == (PixelPacket *) NULL))
628
636
                break;
632
640
                p++;
633
641
                q++;
634
642
              }
635
 
              if (SyncImagePixels(image) == MagickFalse)
 
643
              if (SyncAuthenticPixels(image,exception) == MagickFalse)
636
644
                break;
637
645
           }
638
646
          count=ReadBlob(image,length,pixels);
668
676
          break;
669
677
        for (y=0; y < (long) image->extract_info.height; y++)
670
678
        {
671
 
          q=GetImagePixels(canvas_image,0,0,canvas_image->columns,1);
 
679
          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 
680
            exception);
672
681
          if (q == (PixelPacket *) NULL)
673
682
            break;
674
 
          length=ImportQuantumPixels(canvas_image,quantum_info,BlueQuantum,
675
 
            pixels);
676
 
          if (SyncImagePixels(canvas_image) == MagickFalse)
 
683
          length=ImportQuantumPixels(canvas_image,(ViewInfo *) NULL,
 
684
            quantum_info,BlueQuantum,pixels,exception);
 
685
          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
677
686
            break;
678
687
          if (((y-image->extract_info.y) >= 0) && 
679
688
              ((y-image->extract_info.y) < (long) image->rows))
680
689
            {
681
 
              p=AcquireImagePixels(canvas_image,canvas_image->extract_info.x,0,
 
690
              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
682
691
                canvas_image->columns,1,exception);
683
 
              q=GetImagePixels(image,0,y-image->extract_info.y,image->columns,
684
 
                1);
 
692
              q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 
693
                image->columns,1,exception);
685
694
              if ((p == (const PixelPacket *) NULL) ||
686
695
                  (q == (PixelPacket *) NULL))
687
696
                break;
691
700
                p++;
692
701
                q++;
693
702
              }
694
 
              if (SyncImagePixels(image) == MagickFalse)
 
703
              if (SyncAuthenticPixels(image,exception) == MagickFalse)
695
704
                break;
696
705
           }
697
706
          count=ReadBlob(image,length,pixels);
729
738
              break;
730
739
            for (y=0; y < (long) image->extract_info.height; y++)
731
740
            {
732
 
              q=GetImagePixels(canvas_image,0,0,canvas_image->columns,1);
 
741
              q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 
742
                exception);
733
743
              if (q == (PixelPacket *) NULL)
734
744
                break;
735
 
              length=ImportQuantumPixels(canvas_image,quantum_info,BlueQuantum,
736
 
                pixels);
737
 
              if (SyncImagePixels(canvas_image) == MagickFalse)
 
745
              length=ImportQuantumPixels(canvas_image,(ViewInfo *) NULL,
 
746
                quantum_info,BlueQuantum,pixels,exception);
 
747
              if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
738
748
                break;
739
749
              if (((y-image->extract_info.y) >= 0) && 
740
750
                  ((y-image->extract_info.y) < (long) image->rows))
741
751
                {
742
 
                  p=AcquireImagePixels(canvas_image,
 
752
                  p=GetVirtualPixels(canvas_image,
743
753
                    canvas_image->extract_info.x,0,canvas_image->columns,1,
744
754
                    exception);
745
 
                  q=GetImagePixels(image,0,y-image->extract_info.y,
746
 
                    image->columns,1);
 
755
                  q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 
756
                    image->columns,1,exception);
747
757
                  if ((p == (const PixelPacket *) NULL) ||
748
758
                      (q == (PixelPacket *) NULL))
749
759
                    break;
753
763
                    p++;
754
764
                    q++;
755
765
                  }
756
 
                  if (SyncImagePixels(image) == MagickFalse)
 
766
                  if (SyncAuthenticPixels(image,exception) == MagickFalse)
757
767
                    break;
758
768
               }
759
769
              count=ReadBlob(image,length,pixels);
973
983
        (image->matte == MagickFalse))
974
984
      (void) SetImageAlphaChannel(image,ResetAlphaChannel);
975
985
    quantum_info=AcquireQuantumInfo(image_info,image);
 
986
    if (quantum_info == (QuantumInfo *) NULL)
 
987
      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
976
988
    pixels=GetQuantumPixels(quantum_info);
977
989
    switch (image_info->interlace)
978
990
    {
984
996
        */
985
997
        for (y=0; y < (long) image->rows; y++)
986
998
        {
987
 
          p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
 
999
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
988
1000
          if (p == (const PixelPacket *) NULL)
989
1001
            break;
990
 
          length=ExportQuantumPixels(image,quantum_info,quantum_type,pixels);
 
1002
          length=ExportQuantumPixels(image,(const ViewInfo *) NULL,quantum_info,
 
1003
            quantum_type,pixels,&image->exception);
991
1004
          count=WriteBlob(image,length,pixels);
992
1005
          if (count != (ssize_t) length)
993
1006
            break;
1007
1020
        */
1008
1021
        for (y=0; y < (long) image->rows; y++)
1009
1022
        {
1010
 
          p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
 
1023
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1011
1024
          if (p == (const PixelPacket *) NULL)
1012
1025
            break;
1013
 
          length=ExportQuantumPixels(image,quantum_info,RedQuantum,pixels);
1014
 
          count=WriteBlob(image,length,pixels);
1015
 
          if (count != (ssize_t) length)
1016
 
            break;
1017
 
          length=ExportQuantumPixels(image,quantum_info,GreenQuantum,pixels);
1018
 
          count=WriteBlob(image,length,pixels);
1019
 
          if (count != (ssize_t) length)
1020
 
            break;
1021
 
          length=ExportQuantumPixels(image,quantum_info,BlueQuantum,pixels);
 
1026
          length=ExportQuantumPixels(image,(const ViewInfo *) NULL,quantum_info,
 
1027
            RedQuantum,pixels,&image->exception);
 
1028
          count=WriteBlob(image,length,pixels);
 
1029
          if (count != (ssize_t) length)
 
1030
            break;
 
1031
          length=ExportQuantumPixels(image,(const ViewInfo *) NULL,quantum_info,
 
1032
            GreenQuantum,pixels,&image->exception);
 
1033
          count=WriteBlob(image,length,pixels);
 
1034
          if (count != (ssize_t) length)
 
1035
            break;
 
1036
          length=ExportQuantumPixels(image,(const ViewInfo *) NULL,quantum_info,
 
1037
            BlueQuantum,pixels,&image->exception);
1022
1038
          count=WriteBlob(image,length,pixels);
1023
1039
          if (count != (ssize_t) length)
1024
1040
            break;
1025
1041
          if (quantum_type == RGBAQuantum)
1026
1042
            {
1027
 
              length=ExportQuantumPixels(image,quantum_info,AlphaQuantum,
1028
 
                pixels);
 
1043
              length=ExportQuantumPixels(image,(const ViewInfo *) NULL,
 
1044
                quantum_info,AlphaQuantum,pixels,&image->exception);
1029
1045
              count=WriteBlob(image,length,pixels);
1030
1046
              if (count != (ssize_t) length)
1031
1047
                break;
1046
1062
        */
1047
1063
        for (y=0; y < (long) image->rows; y++)
1048
1064
        {
1049
 
          p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
 
1065
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1050
1066
          if (p == (const PixelPacket *) NULL)
1051
1067
            break;
1052
 
          length=ExportQuantumPixels(image,quantum_info,RedQuantum,pixels);
 
1068
          length=ExportQuantumPixels(image,(const ViewInfo *) NULL,quantum_info,
 
1069
            RedQuantum,pixels,&image->exception);
1053
1070
          count=WriteBlob(image,length,pixels);
1054
1071
          if (count != (ssize_t) length)
1055
1072
            break;
1062
1079
          }
1063
1080
        for (y=0; y < (long) image->rows; y++)
1064
1081
        {
1065
 
          p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
 
1082
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1066
1083
          if (p == (const PixelPacket *) NULL)
1067
1084
            break;
1068
 
          length=ExportQuantumPixels(image,quantum_info,GreenQuantum,pixels);
 
1085
          length=ExportQuantumPixels(image,(const ViewInfo *) NULL,quantum_info,
 
1086
            GreenQuantum,pixels,&image->exception);
1069
1087
          count=WriteBlob(image,length,pixels);
1070
1088
          if (count != (ssize_t) length)
1071
1089
            break;
1078
1096
          }
1079
1097
        for (y=0; y < (long) image->rows; y++)
1080
1098
        {
1081
 
          p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
 
1099
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1082
1100
          if (p == (const PixelPacket *) NULL)
1083
1101
            break;
1084
 
          length=ExportQuantumPixels(image,quantum_info,BlueQuantum,pixels);
 
1102
          length=ExportQuantumPixels(image,(const ViewInfo *) NULL,quantum_info,
 
1103
            BlueQuantum,pixels,&image->exception);
1085
1104
          count=WriteBlob(image,length,pixels);
1086
1105
          if (count != (ssize_t) length)
1087
1106
            break;
1096
1115
          {
1097
1116
            for (y=0; y < (long) image->rows; y++)
1098
1117
            {
1099
 
              p=AcquireImagePixels(image,0,y,image->columns,1,
 
1118
              p=GetVirtualPixels(image,0,y,image->columns,1,
1100
1119
                &image->exception);
1101
1120
              if (p == (const PixelPacket *) NULL)
1102
1121
                break;
1103
 
              length=ExportQuantumPixels(image,quantum_info,AlphaQuantum,
1104
 
                pixels);
 
1122
              length=ExportQuantumPixels(image,(const ViewInfo *) NULL,
 
1123
                quantum_info,AlphaQuantum,pixels,&image->exception);
1105
1124
              count=WriteBlob(image,length,pixels);
1106
1125
              if (count != (ssize_t) length)
1107
1126
              break;
1130
1149
          return(status);
1131
1150
        for (y=0; y < (long) image->rows; y++)
1132
1151
        {
1133
 
          p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
 
1152
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1134
1153
          if (p == (const PixelPacket *) NULL)
1135
1154
            break;
1136
 
          length=ExportQuantumPixels(image,quantum_info,RedQuantum,pixels);
 
1155
          length=ExportQuantumPixels(image,(const ViewInfo *) NULL,quantum_info,
 
1156
            RedQuantum,pixels,&image->exception);
1137
1157
          count=WriteBlob(image,length,pixels);
1138
1158
          if (count != (ssize_t) length)
1139
1159
            break;
1152
1172
          return(status);
1153
1173
        for (y=0; y < (long) image->rows; y++)
1154
1174
        {
1155
 
          p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
 
1175
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1156
1176
          if (p == (const PixelPacket *) NULL)
1157
1177
            break;
1158
 
          length=ExportQuantumPixels(image,quantum_info,GreenQuantum,pixels);
 
1178
          length=ExportQuantumPixels(image,(const ViewInfo *) NULL,quantum_info,
 
1179
            GreenQuantum,pixels,&image->exception);
1159
1180
          count=WriteBlob(image,length,pixels);
1160
1181
          if (count != (ssize_t) length)
1161
1182
            break;
1174
1195
          return(status);
1175
1196
        for (y=0; y < (long) image->rows; y++)
1176
1197
        {
1177
 
          p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
 
1198
          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1178
1199
          if (p == (const PixelPacket *) NULL)
1179
1200
            break;
1180
 
          length=ExportQuantumPixels(image,quantum_info,BlueQuantum,pixels);
 
1201
          length=ExportQuantumPixels(image,(const ViewInfo *) NULL,quantum_info,
 
1202
            BlueQuantum,pixels,&image->exception);
1181
1203
          count=WriteBlob(image,length,pixels);
1182
1204
          if (count != (ssize_t) length)
1183
1205
            break;
1198
1220
              return(status);
1199
1221
            for (y=0; y < (long) image->rows; y++)
1200
1222
            {
1201
 
              p=AcquireImagePixels(image,0,y,image->columns,1,
 
1223
              p=GetVirtualPixels(image,0,y,image->columns,1,
1202
1224
                &image->exception);
1203
1225
              if (p == (const PixelPacket *) NULL)
1204
1226
                break;
1205
 
              length=ExportQuantumPixels(image,quantum_info,AlphaQuantum,
1206
 
                pixels);
 
1227
              length=ExportQuantumPixels(image,(const ViewInfo *) NULL,
 
1228
                quantum_info,AlphaQuantum,pixels,&image->exception);
1207
1229
              count=WriteBlob(image,length,pixels);
1208
1230
              if (count != (ssize_t) length)
1209
1231
                break;