← Back to branch summary

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

« back to all changes in this revision

Viewing changes to magick/colorspace.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:
magick/colorspace.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  %
62
62
#include "magick/utility.h"
63
63
 
64
64
/*
65
 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
65
  Typedef declarations.
 
66
*/
 
67
typedef struct _TransformPacket
 
68
{
 
69
  MagickRealType
 
70
    x,
 
71
    y,
 
72
    z;
 
73
} TransformPacket;
 
74
 
 
75
/*
 
76
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
66
77
%                                                                             %
67
78
%                                                                             %
68
79
%                                                                             %
145
156
{
146
157
#define RGBTransformImageTag  "RGBTransform/Image"
147
158
 
 
159
  ExceptionInfo
 
160
    *exception;
 
161
 
148
162
  long
 
163
    progress,
149
164
    y;
150
165
 
151
166
  MagickBooleanType
152
 
    proceed,
153
 
    status;
 
167
    status,
 
168
    sync;
154
169
 
155
170
  PrimaryInfo
156
 
    primary_info,
 
171
    primary_info;
 
172
 
 
173
  register long
 
174
    i;
 
175
 
 
176
  TransformPacket
157
177
    *x_map,
158
178
    *y_map,
159
179
    *z_map;
160
180
 
161
 
  register long
162
 
    i;
163
 
 
164
181
  ViewInfo
165
 
    **image_view;
 
182
    *image_view;
166
183
 
167
184
  assert(image != (Image *) NULL);
168
185
  assert(image->signature == MagickSignature);
187
204
  }
188
205
  image->colorspace=colorspace;
189
206
  status=MagickTrue;
 
207
  progress=0;
 
208
  exception=(&image->exception);
190
209
  switch (colorspace)
191
210
  {
192
211
    case CMYColorspace:
201
220
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
202
221
            return(MagickFalse);
203
222
        }
204
 
      image_view=AcquireCacheViewThreadSet(image);
 
223
      image_view=AcquireCacheView(image);
205
224
#if defined(MAGICKCORE_OPENMP_SUPPORT)
206
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
225
  #pragma omp parallel for schedule(dynamic,4) shared(status)
207
226
#endif
208
227
      for (y=0; y < (long) image->rows; y++)
209
228
      {
210
229
        register long
211
 
          id,
212
230
          x;
213
231
 
214
232
        register PixelPacket
216
234
 
217
235
        if (status == MagickFalse)
218
236
          continue;
219
 
        id=GetCacheViewThreadId();
220
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
237
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
238
          exception);
221
239
        if (q == (PixelPacket *) NULL)
222
240
          {
223
241
            status=MagickFalse;
230
248
          q->blue=RoundToQuantum((MagickRealType) (QuantumRange-q->blue));
231
249
          q++;
232
250
        }
233
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
 
251
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
252
        if (sync == MagickFalse)
234
253
          status=MagickFalse;
235
254
      }
236
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
255
      image_view=DestroyCacheView(image_view);
237
256
      image->type=image->matte == MagickFalse ? ColorSeparationType :
238
257
        ColorSeparationMatteType;
239
258
      return(status);
254
273
            return(MagickFalse);
255
274
        }
256
275
      GetMagickPixelPacket(image,&zero);
257
 
      image_view=AcquireCacheViewThreadSet(image);
 
276
      image_view=AcquireCacheView(image);
258
277
#if defined(MAGICKCORE_OPENMP_SUPPORT)
259
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
278
  #pragma omp parallel for schedule(dynamic,4) shared(status)
260
279
#endif
261
280
      for (y=0; y < (long) image->rows; y++)
262
281
      {
267
286
          *indexes;
268
287
 
269
288
        register long
270
 
          id,
271
289
          x;
272
290
 
273
291
        register PixelPacket
275
293
 
276
294
        if (status == MagickFalse)
277
295
          continue;
278
 
        id=GetCacheViewThreadId();
279
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
296
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
297
          exception);
280
298
        if (q == (PixelPacket *) NULL)
281
299
          {
282
300
            status=MagickFalse;
283
301
            continue;
284
302
          }
285
 
        indexes=GetCacheViewIndexes(image_view[id]);
 
303
        indexes=GetCacheViewAuthenticIndexQueue(image_view);
286
304
        pixel=zero;
287
305
        for (x=0; x < (long) image->columns; x++)
288
306
        {
291
309
          SetPixelPacket(image,&pixel,q,indexes+x);
292
310
          q++;
293
311
        }
294
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
 
312
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
313
        if (sync == MagickFalse)
295
314
          status=MagickFalse;
296
315
      }
297
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
316
      image_view=DestroyCacheView(image_view);
298
317
      image->type=image->matte == MagickFalse ? ColorSeparationType :
299
318
        ColorSeparationMatteType;
300
319
      return(status);
311
330
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
312
331
            return(MagickFalse);
313
332
        }
314
 
      image_view=AcquireCacheViewThreadSet(image);
 
333
      image_view=AcquireCacheView(image);
315
334
#if defined(MAGICKCORE_OPENMP_SUPPORT)
316
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
335
  #pragma omp parallel for schedule(dynamic,4) shared(status)
317
336
#endif
318
337
      for (y=0; y < (long) image->rows; y++)
319
338
      {
323
342
          saturation;
324
343
 
325
344
        register long
326
 
          id,
327
345
          x;
328
346
 
329
347
        register PixelPacket
331
349
 
332
350
        if (status == MagickFalse)
333
351
          continue;
334
 
        id=GetCacheViewThreadId();
335
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
352
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
353
          exception);
336
354
        if (q == (PixelPacket *) NULL)
337
355
          {
338
356
            status=MagickFalse;
349
367
          q->blue=RoundToQuantum((MagickRealType) QuantumRange*brightness);
350
368
          q++;
351
369
        }
352
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
 
370
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
371
        if (sync == MagickFalse)
353
372
          status=MagickFalse;
354
373
      }
355
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
374
      image_view=DestroyCacheView(image_view);
356
375
      return(status);
357
376
    }
358
377
    case HSLColorspace:
367
386
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
368
387
            return(MagickFalse);
369
388
        }
370
 
      image_view=AcquireCacheViewThreadSet(image);
 
389
      image_view=AcquireCacheView(image);
371
390
#if defined(MAGICKCORE_OPENMP_SUPPORT)
372
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
391
  #pragma omp parallel for schedule(dynamic,4) shared(status)
373
392
#endif
374
393
      for (y=0; y < (long) image->rows; y++)
375
394
      {
379
398
          saturation;
380
399
 
381
400
        register long
382
 
          id,
383
401
          x;
384
402
 
385
403
        register PixelPacket
387
405
 
388
406
        if (status == MagickFalse)
389
407
          continue;
390
 
        id=GetCacheViewThreadId();
391
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
408
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
409
          exception);
392
410
        if (q == (PixelPacket *) NULL)
393
411
          {
394
412
            status=MagickFalse;
405
423
          q->blue=RoundToQuantum((MagickRealType) QuantumRange*lightness);
406
424
          q++;
407
425
        }
408
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
 
426
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
427
        if (sync == MagickFalse)
409
428
          status=MagickFalse;
410
429
      }
411
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
430
      image_view=DestroyCacheView(image_view);
412
431
      return(status);
413
432
    }
414
433
    case HWBColorspace:
423
442
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
424
443
            return(MagickFalse);
425
444
        }
426
 
      image_view=AcquireCacheViewThreadSet(image);
 
445
      image_view=AcquireCacheView(image);
427
446
#if defined(MAGICKCORE_OPENMP_SUPPORT)
428
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
447
  #pragma omp parallel for schedule(dynamic,4) shared(status)
429
448
#endif
430
449
      for (y=0; y < (long) image->rows; y++)
431
450
      {
435
454
          whiteness;
436
455
 
437
456
        register long
438
 
          id,
439
457
          x;
440
458
 
441
459
        register PixelPacket
443
461
 
444
462
        if (status == MagickFalse)
445
463
          continue;
446
 
        id=GetCacheViewThreadId();
447
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
464
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
465
          exception);
448
466
        if (q == (PixelPacket *) NULL)
449
467
          {
450
468
            status=MagickFalse;
461
479
          q->blue=RoundToQuantum((MagickRealType) QuantumRange*blackness);
462
480
          q++;
463
481
        }
464
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
 
482
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
483
        if (sync == MagickFalse)
465
484
          status=MagickFalse;
466
485
      }
467
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
486
      image_view=DestroyCacheView(image_view);
468
487
      return(status);
469
488
    }
470
489
    case LabColorspace:
479
498
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
480
499
            return(MagickFalse);
481
500
        }
482
 
      image_view=AcquireCacheViewThreadSet(image);
 
501
      image_view=AcquireCacheView(image);
483
502
#if defined(MAGICKCORE_OPENMP_SUPPORT)
484
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
503
  #pragma omp parallel for schedule(dynamic,4) shared(status)
485
504
#endif
486
505
      for (y=0; y < (long) image->rows; y++)
487
506
      {
494
513
          Z;
495
514
 
496
515
        register long
497
 
          id,
498
516
          x;
499
517
 
500
518
        register PixelPacket
502
520
 
503
521
        if (status == MagickFalse)
504
522
          continue;
505
 
        id=GetCacheViewThreadId();
506
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
523
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
524
          exception);
507
525
        if (q == (PixelPacket *) NULL)
508
526
          {
509
527
            status=MagickFalse;
524
542
          q->blue=RoundToQuantum((MagickRealType) QuantumRange*b);
525
543
          q++;
526
544
        }
527
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
 
545
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
546
        if (sync == MagickFalse)
528
547
          status=MagickFalse;
529
548
      }
530
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
549
      image_view=DestroyCacheView(image_view);
531
550
      return(status);
532
551
    }
533
552
    case LogColorspace:
572
591
          image->filename);
573
592
      black=pow(10.0,(reference_black-reference_white)*(gamma/density)*
574
593
        0.002/0.6);
 
594
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
595
  #pragma omp parallel for schedule(dynamic,4)
 
596
#endif
575
597
      for (i=0; i <= (long) MaxMap; i++)
576
598
        logmap[i]=ScaleMapToQuantum((MagickRealType) (MaxMap*(reference_white+
577
 
          log10(black+((double) i/MaxMap)*(1.0-black))/((gamma/density)*
 
599
          log10(black+((MagickRealType) i/MaxMap)*(1.0-black))/((gamma/density)*
578
600
          0.002/0.6))/1024.0+0.5));
579
 
      image_view=AcquireCacheViewThreadSet(image);
 
601
      image_view=AcquireCacheView(image);
580
602
#if defined(MAGICKCORE_OPENMP_SUPPORT)
581
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
603
  #pragma omp parallel for schedule(dynamic,4) shared(status)
582
604
#endif
583
605
      for (y=0; y < (long) image->rows; y++)
584
606
      {
585
607
        register long
586
 
          id,
587
608
          x;
588
609
 
589
610
        register PixelPacket
591
612
 
592
613
        if (status == MagickFalse)
593
614
          continue;
594
 
        id=GetCacheViewThreadId();
595
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
615
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
616
          exception);
596
617
        if (q == (PixelPacket *) NULL)
597
618
          {
598
619
            status=MagickFalse;
605
626
          q->blue=logmap[ScaleQuantumToMap(q->blue)];
606
627
          q++;
607
628
        }
608
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
 
629
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
630
        if (sync == MagickFalse)
609
631
          status=MagickFalse;
610
632
      }
611
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
633
      image_view=DestroyCacheView(image_view);
612
634
      logmap=(Quantum *) RelinquishMagickMemory(logmap);
613
635
      return(status);
614
636
    }
618
640
  /*
619
641
    Allocate the tables.
620
642
  */
621
 
  x_map=(PrimaryInfo *) AcquireQuantumMemory((size_t) MaxMap+1UL,
 
643
  x_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
622
644
    sizeof(*x_map));
623
 
  y_map=(PrimaryInfo *) AcquireQuantumMemory((size_t) MaxMap+1UL,
 
645
  y_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
624
646
    sizeof(*y_map));
625
 
  z_map=(PrimaryInfo *) AcquireQuantumMemory((size_t) MaxMap+1UL,
 
647
  z_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
626
648
    sizeof(*z_map));
627
 
  if ((x_map == (PrimaryInfo *) NULL) || (y_map == (PrimaryInfo *) NULL) ||
628
 
      (z_map == (PrimaryInfo *) NULL))
 
649
  if ((x_map == (TransformPacket *) NULL) ||
 
650
      (y_map == (TransformPacket *) NULL) ||
 
651
      (z_map == (TransformPacket *) NULL))
629
652
    ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
630
653
      image->filename);
631
654
  (void) ResetMagickMemory(&primary_info,0,sizeof(primary_info));
645
668
      */
646
669
      primary_info.y=(double) (MaxMap+1.0)/2.0;
647
670
      primary_info.z=(double) (MaxMap+1.0)/2.0;
 
671
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
672
  #pragma omp parallel for schedule(dynamic,4)
 
673
#endif
648
674
      for (i=0; i <= (long) MaxMap; i++)
649
675
      {
650
 
        x_map[i].x=0.33333*i;
651
 
        y_map[i].x=0.33334*i;
652
 
        z_map[i].x=0.33333*i;
653
 
        x_map[i].y=0.50000*i;
654
 
        y_map[i].y=0.00000*i;
655
 
        z_map[i].y=(-0.50000)*i;
656
 
        x_map[i].z=(-0.25000)*i;
657
 
        y_map[i].z=0.50000*i;
658
 
        z_map[i].z=(-0.25000)*i;
 
676
        x_map[i].x=0.33333f*(MagickRealType) i;
 
677
        y_map[i].x=0.33334f*(MagickRealType) i;
 
678
        z_map[i].x=0.33333f*(MagickRealType) i;
 
679
        x_map[i].y=0.50000f*(MagickRealType) i;
 
680
        y_map[i].y=0.00000f*(MagickRealType) i;
 
681
        z_map[i].y=(-0.50000f)*(MagickRealType) i;
 
682
        x_map[i].z=(-0.25000f)*(MagickRealType) i;
 
683
        y_map[i].z=0.50000f*(MagickRealType) i;
 
684
        z_map[i].z=(-0.25000f)*(MagickRealType) i;
659
685
      }
660
686
      break;
661
687
    }
667
693
 
668
694
          G = 0.29900*R+0.58700*G+0.11400*B
669
695
      */
 
696
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
697
  #pragma omp parallel for schedule(dynamic,4)
 
698
#endif
670
699
      for (i=0; i <= (long) MaxMap; i++)
671
700
      {
672
 
        x_map[i].x=0.29900*i;
673
 
        y_map[i].x=0.58700*i;
674
 
        z_map[i].x=0.11400*i;
675
 
        x_map[i].y=0.29900*i;
676
 
        y_map[i].y=0.58700*i;
677
 
        z_map[i].y=0.11400*i;
678
 
        x_map[i].z=0.29900*i;
679
 
        y_map[i].z=0.58700*i;
680
 
        z_map[i].z=0.11400*i;
 
701
        x_map[i].x=0.29900f*(MagickRealType) i;
 
702
        y_map[i].x=0.58700f*(MagickRealType) i;
 
703
        z_map[i].x=0.11400f*(MagickRealType) i;
 
704
        x_map[i].y=0.29900f*(MagickRealType) i;
 
705
        y_map[i].y=0.58700f*(MagickRealType) i;
 
706
        z_map[i].y=0.11400f*(MagickRealType) i;
 
707
        x_map[i].z=0.29900f*(MagickRealType) i;
 
708
        y_map[i].z=0.58700f*(MagickRealType) i;
 
709
        z_map[i].z=0.11400f*(MagickRealType) i;
681
710
      }
682
711
      image->type=GrayscaleType;
683
712
      break;
697
726
      */
698
727
      primary_info.y=(double) (MaxMap+1.0)/2.0;
699
728
      primary_info.z=(double) (MaxMap+1.0)/2.0;
 
729
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
730
  #pragma omp parallel for schedule(dynamic,4)
 
731
#endif
700
732
      for (i=0; i <= (long) MaxMap; i++)
701
733
      {
702
 
        x_map[i].x=0.299000*i;
703
 
        y_map[i].x=0.587000*i;
704
 
        z_map[i].x=0.114000*i;
705
 
        x_map[i].y=(-0.168730)*i;
706
 
        y_map[i].y=(-0.331264)*i;
707
 
        z_map[i].y=0.500000*i;
708
 
        x_map[i].z=0.500000*i;
709
 
        y_map[i].z=(-0.418688)*i;
710
 
        z_map[i].z=(-0.081312)*i;
 
734
        x_map[i].x=0.299000f*(MagickRealType) i;
 
735
        y_map[i].x=0.587000f*(MagickRealType) i;
 
736
        z_map[i].x=0.114000f*(MagickRealType) i;
 
737
        x_map[i].y=(-0.168730f)*(MagickRealType) i;
 
738
        y_map[i].y=(-0.331264f)*(MagickRealType) i;
 
739
        z_map[i].y=0.500000f*(MagickRealType) i;
 
740
        x_map[i].z=0.500000f*(MagickRealType) i;
 
741
        y_map[i].z=(-0.418688f)*(MagickRealType) i;
 
742
        z_map[i].z=(-0.081312f)*(MagickRealType) i;
711
743
      }
712
744
      break;
713
745
    }
718
750
 
719
751
          G = 0.21260*R+0.71520*G+0.07220*B
720
752
      */
 
753
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
754
  #pragma omp parallel for schedule(dynamic,4)
 
755
#endif
721
756
      for (i=0; i <= (long) MaxMap; i++)
722
757
      {
723
 
        x_map[i].x=0.21260*i;
724
 
        y_map[i].x=0.71520*i;
725
 
        z_map[i].x=0.07220*i;
726
 
        x_map[i].y=0.21260*i;
727
 
        y_map[i].y=0.71520*i;
728
 
        z_map[i].y=0.07220*i;
729
 
        x_map[i].z=0.21260*i;
730
 
        y_map[i].z=0.71520*i;
731
 
        z_map[i].z=0.07220*i;
 
758
        x_map[i].x=0.21260f*(MagickRealType) i;
 
759
        y_map[i].x=0.71520f*(MagickRealType) i;
 
760
        z_map[i].x=0.07220f*(MagickRealType) i;
 
761
        x_map[i].y=0.21260f*(MagickRealType) i;
 
762
        y_map[i].y=0.71520f*(MagickRealType) i;
 
763
        z_map[i].y=0.07220f*(MagickRealType) i;
 
764
        x_map[i].z=0.21260f*(MagickRealType) i;
 
765
        y_map[i].z=0.71520f*(MagickRealType) i;
 
766
        z_map[i].z=0.07220f*(MagickRealType) i;
732
767
      }
733
768
      break;
734
769
    }
746
781
      */
747
782
      primary_info.y=(double) (MaxMap+1.0)/2.0;
748
783
      primary_info.z=(double) (MaxMap+1.0)/2.0;
 
784
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
785
  #pragma omp parallel for schedule(dynamic,4)
 
786
#endif
749
787
      for (i=0; i <= (long) MaxMap; i++)
750
788
      {
751
 
        x_map[i].x=0.212600*i;
752
 
        y_map[i].x=0.715200*i;
753
 
        z_map[i].x=0.072200*i;
754
 
        x_map[i].y=(-0.114572)*i;
755
 
        y_map[i].y=(-0.385428)*i;
756
 
        z_map[i].y=0.500000*i;
757
 
        x_map[i].z=0.500000*i;
758
 
        y_map[i].z=(-0.454153)*i;
759
 
        z_map[i].z=(-0.045847)*i;
 
789
        x_map[i].x=0.212600f*(MagickRealType) i;
 
790
        y_map[i].x=0.715200f*(MagickRealType) i;
 
791
        z_map[i].x=0.072200f*(MagickRealType) i;
 
792
        x_map[i].y=(-0.114572f)*(MagickRealType) i;
 
793
        y_map[i].y=(-0.385428f)*(MagickRealType) i;
 
794
        z_map[i].y=0.500000f*(MagickRealType) i;
 
795
        x_map[i].z=0.500000f*(MagickRealType) i;
 
796
        y_map[i].z=(-0.454153f)*(MagickRealType) i;
 
797
        z_map[i].z=(-0.045847f)*(MagickRealType) i;
760
798
      }
761
799
      break;
762
800
    }
769
807
          G = 0.0*R+0.1*G+0.0*B
770
808
          B = 0.0*R+0.0*G+1.0*B
771
809
      */
 
810
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
811
  #pragma omp parallel for schedule(dynamic,4)
 
812
#endif
772
813
      for (i=0; i <= (long) MaxMap; i++)
773
814
      {
774
 
        double
 
815
        MagickRealType
775
816
          v;
776
817
 
777
 
        v=(double) i/MaxMap;
778
 
        if (((double) i/MaxMap) <= 0.03928)
779
 
          v/=12.92;
 
818
        v=(MagickRealType) i/(MagickRealType) MaxMap;
 
819
        if (((MagickRealType) i/(MagickRealType) MaxMap) <= 0.03928f)
 
820
          v/=12.92f;
780
821
        else
781
 
          v=(double) MaxMap*pow((((double) i/MaxMap)+0.055)/1.055,2.4);
782
 
        x_map[i].x=1.0*v;
783
 
        y_map[i].x=0.0*v;
784
 
        z_map[i].x=0.0*v;
785
 
        x_map[i].y=0.0*v;
786
 
        y_map[i].y=1.0*v;
787
 
        z_map[i].y=0.0*v;
788
 
        x_map[i].z=0.0*v;
789
 
        y_map[i].z=0.0*v;
790
 
        z_map[i].z=1.0*v;
 
822
          v=(MagickRealType) MaxMap*pow((((double) i/MaxMap)+0.055)/1.055,2.4);
 
823
        x_map[i].x=1.0f*v;
 
824
        y_map[i].x=0.0f*v;
 
825
        z_map[i].x=0.0f*v;
 
826
        x_map[i].y=0.0f*v;
 
827
        y_map[i].y=1.0f*v;
 
828
        z_map[i].y=0.0f*v;
 
829
        x_map[i].z=0.0f*v;
 
830
        y_map[i].z=0.0f*v;
 
831
        z_map[i].z=1.0f*v;
791
832
      }
792
833
      break;
793
834
    }
800
841
          Y = 0.2126560*R+0.7151580*G+0.0721856*B
801
842
          Z = 0.0193324*R+0.1191930*G+0.9504440*B
802
843
      */
 
844
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
845
  #pragma omp parallel for schedule(dynamic,4)
 
846
#endif
803
847
      for (i=0; i <= (long) MaxMap; i++)
804
848
      {
805
 
        x_map[i].x=0.4124240*i;
806
 
        y_map[i].x=0.3575790*i;
807
 
        z_map[i].x=0.1804640*i;
808
 
        x_map[i].y=0.2126560*i;
809
 
        y_map[i].y=0.7151580*i;
810
 
        z_map[i].y=0.0721856*i;
811
 
        x_map[i].z=0.0193324*i;
812
 
        y_map[i].z=0.1191930*i;
813
 
        z_map[i].z=0.9504440*i;
 
849
        x_map[i].x=0.4124240f*(MagickRealType) i;
 
850
        y_map[i].x=0.3575790f*(MagickRealType) i;
 
851
        z_map[i].x=0.1804640f*(MagickRealType) i;
 
852
        x_map[i].y=0.2126560f*(MagickRealType) i;
 
853
        y_map[i].y=0.7151580f*(MagickRealType) i;
 
854
        z_map[i].y=0.0721856f*(MagickRealType) i;
 
855
        x_map[i].z=0.0193324f*(MagickRealType) i;
 
856
        y_map[i].z=0.1191930f*(MagickRealType) i;
 
857
        z_map[i].z=0.9504440f*(MagickRealType) i;
814
858
      }
815
859
      break;
816
860
    }
829
873
      primary_info.z=(double) ScaleQuantumToMap(ScaleCharToQuantum(137));
830
874
      for (i=0; i <= (long) (0.018*MaxMap); i++)
831
875
      {
832
 
        x_map[i].x=0.003962014134275617*i;
833
 
        y_map[i].x=0.007778268551236748*i;
834
 
        z_map[i].x=0.001510600706713781*i;
835
 
        x_map[i].y=(-0.002426619775463276)*i;
836
 
        y_map[i].y=(-0.004763965913702149)*i;
837
 
        z_map[i].y=0.007190585689165425*i;
838
 
        x_map[i].z=0.006927257754597858*i;
839
 
        y_map[i].z=(-0.005800713697502058)*i;
840
 
        z_map[i].z=(-0.0011265440570958)*i;
 
876
        x_map[i].x=0.003962014134275617f*(MagickRealType) i;
 
877
        y_map[i].x=0.007778268551236748f*(MagickRealType) i;
 
878
        z_map[i].x=0.001510600706713781f*(MagickRealType) i;
 
879
        x_map[i].y=(-0.002426619775463276f)*(MagickRealType) i;
 
880
        y_map[i].y=(-0.004763965913702149f)*(MagickRealType) i;
 
881
        z_map[i].y=0.007190585689165425f*(MagickRealType) i;
 
882
        x_map[i].z=0.006927257754597858f*(MagickRealType) i;
 
883
        y_map[i].z=(-0.005800713697502058f)*(MagickRealType) i;
 
884
        z_map[i].z=(-0.0011265440570958f)*(MagickRealType) i;
841
885
      }
842
886
      for ( ; i <= (long) MaxMap; i++)
843
887
      {
844
 
        x_map[i].x=0.2201118963486454*(1.099*i-0.099);
845
 
        y_map[i].x=0.4321260306242638*(1.099*i-0.099);
846
 
        z_map[i].x=0.08392226148409894*(1.099*i-0.099);
847
 
        x_map[i].y=(-0.1348122097479598)*(1.099*i-0.099);
848
 
        y_map[i].y=(-0.2646647729834528)*(1.099*i-0.099);
849
 
        z_map[i].y=0.3994769827314126*(1.099*i-0.099);
850
 
        x_map[i].z=0.3848476530332144*(1.099*i-0.099);
851
 
        y_map[i].z=(-0.3222618720834477)*(1.099*i-0.099);
852
 
        z_map[i].z=(-0.06258578094976668)*(1.099*i-0.099);
 
888
        x_map[i].x=0.2201118963486454*(1.099f*(MagickRealType) i-0.099f);
 
889
        y_map[i].x=0.4321260306242638*(1.099f*(MagickRealType) i-0.099f);
 
890
        z_map[i].x=0.08392226148409894*(1.099f*(MagickRealType) i-0.099f);
 
891
        x_map[i].y=(-0.1348122097479598)*(1.099f*(MagickRealType) i-0.099f);
 
892
        y_map[i].y=(-0.2646647729834528)*(1.099f*(MagickRealType) i-0.099f);
 
893
        z_map[i].y=0.3994769827314126*(1.099f*(MagickRealType) i-0.099f);
 
894
        x_map[i].z=0.3848476530332144*(1.099f*(MagickRealType) i-0.099f);
 
895
        y_map[i].z=(-0.3222618720834477)*(1.099f*(MagickRealType) i-0.099f);
 
896
        z_map[i].z=(-0.06258578094976668)*(1.099f*(MagickRealType) i-0.099f);
853
897
      }
854
898
      break;
855
899
    }
867
911
      */
868
912
      primary_info.y=(double) (MaxMap+1.0)/2.0;
869
913
      primary_info.z=(double) (MaxMap+1.0)/2.0;
 
914
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
915
  #pragma omp parallel for schedule(dynamic,4)
 
916
#endif
870
917
      for (i=0; i <= (long) MaxMap; i++)
871
918
      {
872
 
        x_map[i].x=0.29900*i;
873
 
        y_map[i].x=0.58700*i;
874
 
        z_map[i].x=0.11400*i;
875
 
        x_map[i].y=0.59600*i;
876
 
        y_map[i].y=(-0.27400)*i;
877
 
        z_map[i].y=(-0.32200)*i;
878
 
        x_map[i].z=0.21100*i;
879
 
        y_map[i].z=(-0.52300)*i;
880
 
        z_map[i].z=0.31200*i;
 
919
        x_map[i].x=0.29900f*(MagickRealType) i;
 
920
        y_map[i].x=0.58700f*(MagickRealType) i;
 
921
        z_map[i].x=0.11400f*(MagickRealType) i;
 
922
        x_map[i].y=0.59600f*(MagickRealType) i;
 
923
        y_map[i].y=(-0.27400f)*(MagickRealType) i;
 
924
        z_map[i].y=(-0.32200f)*(MagickRealType) i;
 
925
        x_map[i].z=0.21100f*(MagickRealType) i;
 
926
        y_map[i].z=(-0.52300f)*(MagickRealType) i;
 
927
        z_map[i].z=0.31200f*(MagickRealType) i;
881
928
      }
882
929
      break;
883
930
    }
895
942
      */
896
943
      primary_info.y=(double) (MaxMap+1.0)/2.0;
897
944
      primary_info.z=(double) (MaxMap+1.0)/2.0;
 
945
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
946
  #pragma omp parallel for schedule(dynamic,4)
 
947
#endif
898
948
      for (i=0; i <= (long) MaxMap; i++)
899
949
      {
900
 
        x_map[i].x=0.299000*i;
901
 
        y_map[i].x=0.587000*i;
902
 
        z_map[i].x=0.114000*i;
903
 
        x_map[i].y=(-0.168736)*i;
904
 
        y_map[i].y=(-0.331264)*i;
905
 
        z_map[i].y=0.500000*i;
906
 
        x_map[i].z=0.500000*i;
907
 
        y_map[i].z=(-0.418688)*i;
908
 
        z_map[i].z=(-0.081312)*i;
 
950
        x_map[i].x=0.299000f*(MagickRealType) i;
 
951
        y_map[i].x=0.587000f*(MagickRealType) i;
 
952
        z_map[i].x=0.114000f*(MagickRealType) i;
 
953
        x_map[i].y=(-0.168736f)*(MagickRealType) i;
 
954
        y_map[i].y=(-0.331264f)*(MagickRealType) i;
 
955
        z_map[i].y=0.500000f*(MagickRealType) i;
 
956
        x_map[i].z=0.500000f*(MagickRealType) i;
 
957
        y_map[i].z=(-0.418688f)*(MagickRealType) i;
 
958
        z_map[i].z=(-0.081312f)*(MagickRealType) i;
909
959
      }
910
960
      break;
911
961
    }
924
974
      */
925
975
      primary_info.y=(double) (MaxMap+1.0)/2.0;
926
976
      primary_info.z=(double) (MaxMap+1.0)/2.0;
 
977
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
978
  #pragma omp parallel for schedule(dynamic,4)
 
979
#endif
927
980
      for (i=0; i <= (long) MaxMap; i++)
928
981
      {
929
 
        x_map[i].x=0.29900*i;
930
 
        y_map[i].x=0.58700*i;
931
 
        z_map[i].x=0.11400*i;
932
 
        x_map[i].y=(-0.14740)*i;
933
 
        y_map[i].y=(-0.28950)*i;
934
 
        z_map[i].y=0.43690*i;
935
 
        x_map[i].z=0.61500*i;
936
 
        y_map[i].z=(-0.51500)*i;
937
 
        z_map[i].z=(-0.10000)*i;
 
982
        x_map[i].x=0.29900f*(MagickRealType) i;
 
983
        y_map[i].x=0.58700f*(MagickRealType) i;
 
984
        z_map[i].x=0.11400f*(MagickRealType) i;
 
985
        x_map[i].y=(-0.14740f)*(MagickRealType) i;
 
986
        y_map[i].y=(-0.28950f)*(MagickRealType) i;
 
987
        z_map[i].y=0.43690f*(MagickRealType) i;
 
988
        x_map[i].z=0.61500f*(MagickRealType) i;
 
989
        y_map[i].z=(-0.51500f)*(MagickRealType) i;
 
990
        z_map[i].z=(-0.10000f)*(MagickRealType) i;
938
991
      }
939
992
      break;
940
993
    }
947
1000
    case DirectClass:
948
1001
    default:
949
1002
    {
950
 
      MagickPixelPacket
951
 
        zero;
952
 
 
953
1003
      /*
954
1004
        Convert DirectClass image.
955
1005
      */
956
 
      GetMagickPixelPacket(image,&zero);
957
 
      image_view=AcquireCacheViewThreadSet(image);
 
1006
      image_view=AcquireCacheView(image);
958
1007
#if defined(MAGICKCORE_OPENMP_SUPPORT)
959
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
1008
  #pragma omp parallel for schedule(dynamic,4) shared(status)
960
1009
#endif
961
1010
      for (y=0; y < (long) image->rows; y++)
962
1011
      {
964
1013
          pixel;
965
1014
 
966
1015
        register long
967
 
          id,
968
1016
          x;
969
1017
 
970
1018
        register PixelPacket
971
1019
          *q;
972
1020
 
 
1021
        register unsigned long
 
1022
          blue,
 
1023
          green,
 
1024
          red;
 
1025
 
973
1026
        if (status == MagickFalse)
974
1027
          continue;
975
 
        id=GetCacheViewThreadId();
976
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
1028
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
1029
          exception);
977
1030
        if (q == (PixelPacket *) NULL)
978
1031
          {
979
1032
            status=MagickFalse;
980
1033
            continue;
981
1034
          }
982
 
        pixel=zero;
983
1035
        for (x=0; x < (long) image->columns; x++)
984
1036
        {
985
 
          pixel.red=x_map[ScaleQuantumToMap(q->red)].x+
986
 
            y_map[ScaleQuantumToMap(q->green)].x+
987
 
            z_map[ScaleQuantumToMap(q->blue)].x+primary_info.x;
988
 
          pixel.green=x_map[ScaleQuantumToMap(q->red)].y+
989
 
            y_map[ScaleQuantumToMap(q->green)].y+
990
 
            z_map[ScaleQuantumToMap(q->blue)].y+primary_info.y;
991
 
          pixel.blue=x_map[ScaleQuantumToMap(q->red)].z+
992
 
            y_map[ScaleQuantumToMap(q->green)].z+
993
 
            z_map[ScaleQuantumToMap(q->blue)].z+primary_info.z;
 
1037
          red=ScaleQuantumToMap(q->red);
 
1038
          green=ScaleQuantumToMap(q->green);
 
1039
          blue=ScaleQuantumToMap(q->blue);
 
1040
          pixel.red=(x_map[red].x+y_map[green].x+z_map[blue].x)+
 
1041
            (MagickRealType) primary_info.x;
 
1042
          pixel.green=(x_map[red].y+y_map[green].y+z_map[blue].y)+
 
1043
            (MagickRealType) primary_info.y;
 
1044
          pixel.blue=(x_map[red].z+y_map[green].z+z_map[blue].z)+
 
1045
            (MagickRealType) primary_info.z;
994
1046
          q->red=ScaleMapToQuantum(pixel.red);
995
1047
          q->green=ScaleMapToQuantum(pixel.green);
996
1048
          q->blue=ScaleMapToQuantum(pixel.blue);
997
1049
          q++;
998
1050
        }
999
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
1000
 
          status=MagickFalse;
1001
 
        proceed=SetImageProgress(image,RGBTransformImageTag,y,image->rows);
1002
 
        if (proceed == MagickFalse)
1003
 
          status=MagickFalse;
 
1051
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
1052
        if (sync == MagickFalse)
 
1053
          status=MagickFalse;
 
1054
        if (image->progress_monitor != (MagickProgressMonitor) NULL)
 
1055
          {
 
1056
            MagickBooleanType
 
1057
              proceed;
 
1058
 
 
1059
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
1060
  #pragma omp critical (MagickCore_RGBTransformImage)
 
1061
#endif
 
1062
            proceed=SetImageProgress(image,RGBTransformImageTag,progress++,
 
1063
              image->rows);
 
1064
            if (proceed == MagickFalse)
 
1065
              status=MagickFalse;
 
1066
          }
1004
1067
      }
1005
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
1068
      image_view=DestroyCacheView(image_view);
1006
1069
      break;
1007
1070
    }
1008
1071
    case PseudoClass:
1009
1072
    {
1010
 
      MagickPixelPacket
1011
 
        zero;
 
1073
      register unsigned long
 
1074
        blue,
 
1075
        green,
 
1076
        red;
1012
1077
 
1013
1078
      /*
1014
1079
        Convert PseudoClass image.
1015
1080
      */
1016
 
      GetMagickPixelPacket(image,&zero);
1017
 
      image_view=AcquireCacheViewThreadSet(image);
 
1081
      image_view=AcquireCacheView(image);
1018
1082
      for (i=0; i < (long) image->colors; i++)
1019
1083
      {
1020
1084
        MagickPixelPacket
1021
1085
          pixel;
1022
1086
 
1023
 
        pixel=zero;
1024
 
        pixel.red=x_map[ScaleQuantumToMap(image->colormap[i].red)].x+
1025
 
          y_map[ScaleQuantumToMap(image->colormap[i].green)].x+
1026
 
          z_map[ScaleQuantumToMap(image->colormap[i].blue)].x+primary_info.x;
1027
 
        pixel.green=x_map[ScaleQuantumToMap(image->colormap[i].red)].y+
1028
 
          y_map[ScaleQuantumToMap(image->colormap[i].green)].y+
1029
 
          z_map[ScaleQuantumToMap(image->colormap[i].blue)].y+primary_info.y;
1030
 
        pixel.blue=x_map[ScaleQuantumToMap(image->colormap[i].red)].z+
1031
 
          y_map[ScaleQuantumToMap(image->colormap[i].green)].z+
1032
 
          z_map[ScaleQuantumToMap(image->colormap[i].blue)].z+primary_info.z;
 
1087
        red=ScaleQuantumToMap(image->colormap[i].red);
 
1088
        green=ScaleQuantumToMap(image->colormap[i].green);
 
1089
        blue=ScaleQuantumToMap(image->colormap[i].blue);
 
1090
        pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x+primary_info.x;
 
1091
        pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y+primary_info.y;
 
1092
        pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z+primary_info.z;
1033
1093
        image->colormap[i].red=ScaleMapToQuantum(pixel.red);
1034
1094
        image->colormap[i].green=ScaleMapToQuantum(pixel.green);
1035
1095
        image->colormap[i].blue=ScaleMapToQuantum(pixel.blue);
1036
1096
      }
1037
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
1097
      image_view=DestroyCacheView(image_view);
1038
1098
      (void) SyncImage(image);
1039
1099
      break;
1040
1100
    }
1041
1101
  }
 
1102
  image->colorspace=colorspace;
1042
1103
  /*
1043
1104
    Relinquish resources.
1044
1105
  */
1045
 
  z_map=(PrimaryInfo *) RelinquishMagickMemory(z_map);
1046
 
  y_map=(PrimaryInfo *) RelinquishMagickMemory(y_map);
1047
 
  x_map=(PrimaryInfo *) RelinquishMagickMemory(x_map);
 
1106
  z_map=(TransformPacket *) RelinquishMagickMemory(z_map);
 
1107
  y_map=(TransformPacket *) RelinquishMagickMemory(y_map);
 
1108
  x_map=(TransformPacket *) RelinquishMagickMemory(x_map);
1048
1109
  return(status);
1049
1110
}
1050
1111
 
1244
1305
    };
1245
1306
#endif
1246
1307
 
 
1308
  ExceptionInfo
 
1309
    *exception;
 
1310
 
1247
1311
  long
 
1312
    progress,
1248
1313
    y;
1249
1314
 
1250
1315
  MagickBooleanType
1251
 
    proceed,
1252
1316
    status;
1253
1317
 
1254
 
  PrimaryInfo
 
1318
  register long
 
1319
    i;
 
1320
 
 
1321
  TransformPacket
1255
1322
    *y_map,
1256
1323
    *x_map,
1257
1324
    *z_map;
1258
1325
 
1259
 
  register long
1260
 
    i;
1261
 
 
1262
1326
  ViewInfo
1263
 
    **image_view;
 
1327
    *image_view;
1264
1328
 
1265
1329
  assert(image != (Image *) NULL);
1266
1330
  assert(image->signature == MagickSignature);
1279
1343
      break;
1280
1344
  }
1281
1345
  status=MagickTrue;
 
1346
  progress=0;
 
1347
  exception=(&image->exception);
1282
1348
  switch (colorspace)
1283
1349
  {
1284
1350
    case CMYColorspace:
1293
1359
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1294
1360
            return(MagickFalse);
1295
1361
        }
1296
 
      image_view=AcquireCacheViewThreadSet(image);
 
1362
      image_view=AcquireCacheView(image);
1297
1363
#if defined(MAGICKCORE_OPENMP_SUPPORT)
1298
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
1364
  #pragma omp parallel for schedule(dynamic,4) shared(status)
1299
1365
#endif
1300
1366
      for (y=0; y < (long) image->rows; y++)
1301
1367
      {
 
1368
        MagickBooleanType
 
1369
          sync;
 
1370
 
1302
1371
        register long
1303
 
          id,
1304
1372
          x;
1305
1373
 
1306
1374
        register PixelPacket
1308
1376
 
1309
1377
        if (status == MagickFalse)
1310
1378
          continue;
1311
 
        id=GetCacheViewThreadId();
1312
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
1379
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
1380
          exception);
1313
1381
        if (q == (PixelPacket *) NULL)
1314
1382
          {
1315
1383
            status=MagickFalse;
1322
1390
          q->blue=RoundToQuantum((MagickRealType) (QuantumRange-q->blue));
1323
1391
          q++;
1324
1392
        }
1325
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
 
1393
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
1394
        if (sync == MagickFalse)
1326
1395
          status=MagickFalse;
1327
1396
      }
1328
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
1397
      image_view=DestroyCacheView(image_view);
1329
1398
      image->colorspace=RGBColorspace;
1330
1399
      return(status);
1331
1400
    }
1345
1414
            return(MagickFalse);
1346
1415
        }
1347
1416
      GetMagickPixelPacket(image,&zero);
1348
 
      image_view=AcquireCacheViewThreadSet(image);
 
1417
      image_view=AcquireCacheView(image);
1349
1418
#if defined(MAGICKCORE_OPENMP_SUPPORT)
1350
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
1419
  #pragma omp parallel for schedule(dynamic,4) shared(status)
1351
1420
#endif
1352
1421
      for (y=0; y < (long) image->rows; y++)
1353
1422
      {
 
1423
        MagickBooleanType
 
1424
          sync;
 
1425
 
1354
1426
        MagickPixelPacket
1355
1427
          pixel;
1356
1428
 
1358
1430
          *indexes;
1359
1431
 
1360
1432
        register long
1361
 
          id,
1362
1433
          x;
1363
1434
 
1364
1435
        register PixelPacket
1366
1437
 
1367
1438
        if (status == MagickFalse)
1368
1439
          continue;
1369
 
        id=GetCacheViewThreadId();
1370
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
1440
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
1441
          exception);
1371
1442
        if (q == (PixelPacket *) NULL)
1372
1443
          {
1373
1444
            status=MagickFalse;
1374
1445
            continue;
1375
1446
          }
1376
 
        indexes=GetCacheViewIndexes(image_view[id]);
 
1447
        indexes=GetCacheViewAuthenticIndexQueue(image_view);
1377
1448
        pixel=zero;
1378
1449
        for (x=0; x < (long) image->columns; x++)
1379
1450
        {
1382
1453
          SetPixelPacket(image,&pixel,q,indexes+x);
1383
1454
          q++;
1384
1455
        }
1385
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
 
1456
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
1457
        if (sync == MagickFalse)
1386
1458
          status=MagickFalse;
1387
1459
      }
1388
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
1460
      image_view=DestroyCacheView(image_view);
1389
1461
      image->colorspace=RGBColorspace;
1390
1462
      return(status);
1391
1463
    }
1401
1473
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1402
1474
            return(MagickFalse);
1403
1475
        }
1404
 
      image_view=AcquireCacheViewThreadSet(image);
 
1476
      image_view=AcquireCacheView(image);
1405
1477
#if defined(MAGICKCORE_OPENMP_SUPPORT)
1406
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
1478
  #pragma omp parallel for schedule(dynamic,4) shared(status)
1407
1479
#endif
1408
1480
      for (y=0; y < (long) image->rows; y++)
1409
1481
      {
1412
1484
          hue,
1413
1485
          saturation;
1414
1486
 
 
1487
        MagickBooleanType
 
1488
          sync;
 
1489
 
1415
1490
        register long
1416
 
          id,
1417
1491
          x;
1418
1492
 
1419
1493
        register PixelPacket
1421
1495
 
1422
1496
        if (status == MagickFalse)
1423
1497
          continue;
1424
 
        id=GetCacheViewThreadId();
1425
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
1498
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
1499
          exception);
1426
1500
        if (q == (PixelPacket *) NULL)
1427
1501
          {
1428
1502
            status=MagickFalse;
1436
1510
          ConvertHSBToRGB(hue,saturation,brightness,&q->red,&q->green,&q->blue);
1437
1511
          q++;
1438
1512
        }
1439
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
 
1513
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
1514
        if (sync == MagickFalse)
1440
1515
          status=MagickFalse;
1441
1516
      }
1442
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
1517
      image_view=DestroyCacheView(image_view);
1443
1518
      image->colorspace=RGBColorspace;
1444
1519
      return(status);
1445
1520
    }
1455
1530
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1456
1531
            return(MagickFalse);
1457
1532
        }
1458
 
      image_view=AcquireCacheViewThreadSet(image);
 
1533
      image_view=AcquireCacheView(image);
1459
1534
#if defined(MAGICKCORE_OPENMP_SUPPORT)
1460
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
1535
  #pragma omp parallel for schedule(dynamic,4) shared(status)
1461
1536
#endif
1462
1537
      for (y=0; y < (long) image->rows; y++)
1463
1538
      {
1466
1541
          lightness,
1467
1542
          saturation;
1468
1543
 
 
1544
        MagickBooleanType
 
1545
          sync;
 
1546
 
1469
1547
        register long
1470
 
          id,
1471
1548
          x;
1472
1549
 
1473
1550
        register PixelPacket
1475
1552
 
1476
1553
        if (status == MagickFalse)
1477
1554
          continue;
1478
 
        id=GetCacheViewThreadId();
1479
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
1555
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
1556
          exception);
1480
1557
        if (q == (PixelPacket *) NULL)
1481
1558
          {
1482
1559
            status=MagickFalse;
1490
1567
          ConvertHSLToRGB(hue,saturation,lightness,&q->red,&q->green,&q->blue);
1491
1568
          q++;
1492
1569
        }
1493
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
 
1570
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
1571
        if (sync == MagickFalse)
1494
1572
          status=MagickFalse;
1495
1573
      }
1496
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
1574
      image_view=DestroyCacheView(image_view);
1497
1575
      image->colorspace=RGBColorspace;
1498
1576
      return(status);
1499
1577
    }
1509
1587
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1510
1588
            return(MagickFalse);
1511
1589
        }
1512
 
      image_view=AcquireCacheViewThreadSet(image);
 
1590
      image_view=AcquireCacheView(image);
1513
1591
#if defined(MAGICKCORE_OPENMP_SUPPORT)
1514
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
1592
  #pragma omp parallel for schedule(dynamic,4) shared(status)
1515
1593
#endif
1516
1594
      for (y=0; y < (long) image->rows; y++)
1517
1595
      {
1520
1598
          hue,
1521
1599
          whiteness;
1522
1600
 
 
1601
        MagickBooleanType
 
1602
          sync;
 
1603
 
1523
1604
        register long
1524
 
          id,
1525
1605
          x;
1526
1606
 
1527
1607
        register PixelPacket
1529
1609
 
1530
1610
        if (status == MagickFalse)
1531
1611
          continue;
1532
 
        id=GetCacheViewThreadId();
1533
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
1612
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
1613
          exception);
1534
1614
        if (q == (PixelPacket *) NULL)
1535
1615
          {
1536
1616
            status=MagickFalse;
1544
1624
          ConvertHWBToRGB(hue,whiteness,blackness,&q->red,&q->green,&q->blue);
1545
1625
          q++;
1546
1626
        }
1547
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
 
1627
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
1628
        if (sync == MagickFalse)
1548
1629
          status=MagickFalse;
1549
1630
      }
1550
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
1631
      image_view=DestroyCacheView(image_view);
1551
1632
      image->colorspace=RGBColorspace;
1552
1633
      return(status);
1553
1634
    }
1563
1644
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1564
1645
            return(MagickFalse);
1565
1646
        }
1566
 
      image_view=AcquireCacheViewThreadSet(image);
 
1647
      image_view=AcquireCacheView(image);
1567
1648
#if defined(MAGICKCORE_OPENMP_SUPPORT)
1568
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
1649
  #pragma omp parallel for schedule(dynamic,4) shared(status)
1569
1650
#endif
1570
1651
      for (y=0; y < (long) image->rows; y++)
1571
1652
      {
1577
1658
          Y,
1578
1659
          Z;
1579
1660
 
 
1661
        MagickBooleanType
 
1662
          sync;
 
1663
 
1580
1664
        register long
1581
 
          id,
1582
1665
          x;
1583
1666
 
1584
1667
        register PixelPacket
1586
1669
 
1587
1670
        if (status == MagickFalse)
1588
1671
          continue;
1589
 
        id=GetCacheViewThreadId();
1590
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
1672
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
1673
          exception);
1591
1674
        if (q == (PixelPacket *) NULL)
1592
1675
          {
1593
1676
            status=MagickFalse;
1605
1688
          ConvertXYZToRGB(X,Y,Z,&q->red,&q->green,&q->blue);
1606
1689
          q++;
1607
1690
        }
1608
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
 
1691
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
1692
        if (sync == MagickFalse)
1609
1693
          status=MagickFalse;
1610
1694
      }
1611
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
1695
      image_view=DestroyCacheView(image_view);
1612
1696
      image->colorspace=RGBColorspace;
1613
1697
      return(status);
1614
1698
    }
1660
1744
        logmap[i]=(Quantum) QuantumRange;
1661
1745
      if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1662
1746
        return(MagickFalse);
1663
 
      image_view=AcquireCacheViewThreadSet(image);
 
1747
      image_view=AcquireCacheView(image);
1664
1748
#if defined(MAGICKCORE_OPENMP_SUPPORT)
1665
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
1749
  #pragma omp parallel for schedule(dynamic,4) shared(status)
1666
1750
#endif
1667
1751
      for (y=0; y < (long) image->rows; y++)
1668
1752
      {
 
1753
        MagickBooleanType
 
1754
          sync;
 
1755
 
1669
1756
        register long
1670
 
          id,
1671
1757
          x;
1672
1758
 
1673
1759
        register PixelPacket
1675
1761
 
1676
1762
        if (status == MagickFalse)
1677
1763
          continue;
1678
 
        id=GetCacheViewThreadId();
1679
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
1764
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
1765
          exception);
1680
1766
        if (q == (PixelPacket *) NULL)
1681
1767
          {
1682
1768
            status=MagickFalse;
1689
1775
          q->blue=logmap[ScaleQuantumToMap(q->blue)];
1690
1776
          q++;
1691
1777
        }
1692
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
 
1778
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
1779
        if (sync == MagickFalse)
1693
1780
          status=MagickFalse;
1694
1781
      }
1695
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
1782
      image_view=DestroyCacheView(image_view);
1696
1783
      logmap=(Quantum *) RelinquishMagickMemory(logmap);
1697
1784
      image->colorspace=RGBColorspace;
1698
1785
      return(status);
1703
1790
  /*
1704
1791
    Allocate the tables.
1705
1792
  */
1706
 
  x_map=(PrimaryInfo *) AcquireQuantumMemory((size_t) MaxMap+1UL,
 
1793
  x_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
1707
1794
    sizeof(*x_map));
1708
 
  y_map=(PrimaryInfo *) AcquireQuantumMemory((size_t) MaxMap+1UL,
 
1795
  y_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
1709
1796
    sizeof(*y_map));
1710
 
  z_map=(PrimaryInfo *) AcquireQuantumMemory((size_t) MaxMap+1UL,
 
1797
  z_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
1711
1798
    sizeof(*z_map));
1712
 
  if ((x_map == (PrimaryInfo *) NULL) || (y_map == (PrimaryInfo *) NULL) ||
1713
 
      (z_map == (PrimaryInfo *) NULL))
 
1799
  if ((x_map == (TransformPacket *) NULL) ||
 
1800
      (y_map == (TransformPacket *) NULL) ||
 
1801
      (z_map == (TransformPacket *) NULL))
1714
1802
    {
1715
 
      if (z_map != (PrimaryInfo *) NULL)
1716
 
        z_map=(PrimaryInfo *) RelinquishMagickMemory(z_map);
1717
 
      if (y_map != (PrimaryInfo *) NULL)
1718
 
        y_map=(PrimaryInfo *) RelinquishMagickMemory(y_map);
1719
 
      if (x_map != (PrimaryInfo *) NULL)
1720
 
        x_map=(PrimaryInfo *) RelinquishMagickMemory(x_map);
 
1803
      if (z_map != (TransformPacket *) NULL)
 
1804
        z_map=(TransformPacket *) RelinquishMagickMemory(z_map);
 
1805
      if (y_map != (TransformPacket *) NULL)
 
1806
        y_map=(TransformPacket *) RelinquishMagickMemory(y_map);
 
1807
      if (x_map != (TransformPacket *) NULL)
 
1808
        x_map=(TransformPacket *) RelinquishMagickMemory(x_map);
1721
1809
      ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1722
1810
        image->filename);
1723
1811
    }
1735
1823
        I and Q, normally -0.5 through 0.5, must be normalized to the range 0
1736
1824
        through QuantumRange.
1737
1825
      */
 
1826
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
1827
  #pragma omp parallel for schedule(dynamic,4)
 
1828
#endif
1738
1829
      for (i=0; i <= (long) MaxMap; i++)
1739
1830
      {
1740
 
        x_map[i].x=(double) i;
1741
 
        y_map[i].x=0.500000*(2.000000*i-MaxMap);
1742
 
        z_map[i].x=(-0.333340)*(2.000000*i-MaxMap);
1743
 
        x_map[i].y=(double) i;
1744
 
        y_map[i].y=0.000000;
1745
 
        z_map[i].y=0.666665*(2.000000*i-MaxMap);
1746
 
        x_map[i].z=(double) i;
1747
 
        y_map[i].z=(-0.500000)*(2.000000*i-MaxMap);
1748
 
        z_map[i].z=(-0.333340)*(2.000000*i-MaxMap);
 
1831
        x_map[i].x=(MagickRealType) i;
 
1832
        y_map[i].x=0.500000f*(2.000000*(MagickRealType) i-(MagickRealType)
 
1833
          MaxMap);
 
1834
        z_map[i].x=(-0.333340f)*(2.000000f*(MagickRealType) i-(MagickRealType)
 
1835
          MaxMap);
 
1836
        x_map[i].y=(MagickRealType) i;
 
1837
        y_map[i].y=0.000000f;
 
1838
        z_map[i].y=0.666665f*(2.000000f*(MagickRealType) i-(MagickRealType)
 
1839
          MaxMap);
 
1840
        x_map[i].z=(MagickRealType) i;
 
1841
        y_map[i].z=(-0.500000f)*(2.000000f*(MagickRealType) i-(MagickRealType)
 
1842
          MaxMap);
 
1843
        z_map[i].z=(-0.333340f)*(2.000000f*(MagickRealType) i-(MagickRealType)
 
1844
          MaxMap);
1749
1845
      }
1750
1846
      break;
1751
1847
    }
1762
1858
        Cb and Cr, normally -0.5 through 0.5, must be normalized to the range 0
1763
1859
        through QuantumRange.
1764
1860
      */
 
1861
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
1862
  #pragma omp parallel for schedule(dynamic,4)
 
1863
#endif
1765
1864
      for (i=0; i <= (long) MaxMap; i++)
1766
1865
      {
1767
 
        x_map[i].x=(double) i;
1768
 
        y_map[i].x=0.000000;
1769
 
        z_map[i].x=(1.402000*0.500000)*(2.000000*i-MaxMap);
1770
 
        x_map[i].y=(double) i;
1771
 
        y_map[i].y=(-0.344136*0.500000)*(2.000000*i-MaxMap);
1772
 
        z_map[i].y=(-0.714136*0.500000)*(2.000000*i-MaxMap);
1773
 
        x_map[i].z=(double) i;
1774
 
        y_map[i].z=(1.772000*0.500000)*(2.000000*i-MaxMap);
1775
 
        z_map[i].z=0.000000;
 
1866
        x_map[i].x=(MagickRealType) i;
 
1867
        y_map[i].x=0.000000f;
 
1868
        z_map[i].x=(1.402000f*0.500000f)*(2.000000f*(MagickRealType) i-
 
1869
          (MagickRealType) MaxMap);
 
1870
        x_map[i].y=(MagickRealType) i;
 
1871
        y_map[i].y=(-0.344136f*0.500000f)*(2.000000f*(MagickRealType) i-
 
1872
          (MagickRealType) MaxMap);
 
1873
        z_map[i].y=(-0.714136f*0.500000f)*(2.000000f*(MagickRealType) i-
 
1874
          (MagickRealType) MaxMap);
 
1875
        x_map[i].z=(MagickRealType) i;
 
1876
        y_map[i].z=(1.772000f*0.500000f)*(2.000000f*(MagickRealType) i-
 
1877
          (MagickRealType) MaxMap);
 
1878
        z_map[i].z=0.000000f;
1776
1879
      }
1777
1880
      break;
1778
1881
    }
1788
1891
        Cb and Cr, normally -0.5 through 0.5, must be normalized to the range 0
1789
1892
        through QuantumRange.
1790
1893
      */
 
1894
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
1895
  #pragma omp parallel for schedule(dynamic,4)
 
1896
#endif
1791
1897
      for (i=0; i <= (long) MaxMap; i++)
1792
1898
      {
1793
 
        x_map[i].x=(double) i;
1794
 
        y_map[i].x=0.000000;
1795
 
        z_map[i].x=(1.574800*0.50000)*(2.00000*i-MaxMap);
1796
 
        x_map[i].y=(double) i;
1797
 
        y_map[i].y=(-0.187324*0.50000)*(2.00000*i-MaxMap);
1798
 
        z_map[i].y=(-0.468124*0.50000)*(2.00000*i-MaxMap);
1799
 
        x_map[i].z=(double) i;
1800
 
        y_map[i].z=(1.855600*0.50000)*(2.00000*i-MaxMap);
1801
 
        z_map[i].z=0.00000;
 
1899
        x_map[i].x=(MagickRealType) i;
 
1900
        y_map[i].x=0.000000f;
 
1901
        z_map[i].x=(1.574800f*0.50000f)*(2.00000f*(MagickRealType) i-
 
1902
          (MagickRealType) MaxMap);
 
1903
        x_map[i].y=(MagickRealType) i;
 
1904
        y_map[i].y=(-0.187324f*0.50000f)*(2.00000f*(MagickRealType) i-
 
1905
          (MagickRealType) MaxMap);
 
1906
        z_map[i].y=(-0.468124f*0.50000f)*(2.00000f*(MagickRealType) i-
 
1907
          (MagickRealType) MaxMap);
 
1908
        x_map[i].z=(MagickRealType) i;
 
1909
        y_map[i].z=(1.855600f*0.50000f)*(2.00000f*(MagickRealType) i-
 
1910
          (MagickRealType) MaxMap);
 
1911
        z_map[i].z=0.00000f;
1802
1912
      }
1803
1913
      break;
1804
1914
    }
1811
1921
          G = 0.0*R+1.0*G+0.0*B
1812
1922
          B = 0.0*R+0.0*G+1.0*B
1813
1923
      */
 
1924
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
1925
  #pragma omp parallel for schedule(dynamic,4)
 
1926
#endif
1814
1927
      for (i=0; i <= (long) MaxMap; i++)
1815
1928
      {
1816
 
        x_map[i].x=1.0*i;
1817
 
        y_map[i].x=0.0*i;
1818
 
        z_map[i].x=0.0*i;
1819
 
        x_map[i].y=0.0*i;
1820
 
        y_map[i].y=1.0*i;
1821
 
        z_map[i].y=0.0*i;
1822
 
        x_map[i].z=0.0*i;
1823
 
        y_map[i].z=0.0*i;
1824
 
        z_map[i].z=1.0*i;
 
1929
        x_map[i].x=1.0f*(MagickRealType) i;
 
1930
        y_map[i].x=0.0f*(MagickRealType) i;
 
1931
        z_map[i].x=0.0f*(MagickRealType) i;
 
1932
        x_map[i].y=0.0f*(MagickRealType) i;
 
1933
        y_map[i].y=1.0f*(MagickRealType) i;
 
1934
        z_map[i].y=0.0f*(MagickRealType) i;
 
1935
        x_map[i].z=0.0f*(MagickRealType) i;
 
1936
        y_map[i].z=0.0f*(MagickRealType) i;
 
1937
        z_map[i].z=1.0f*(MagickRealType) i;
1825
1938
      }
1826
1939
      break;
1827
1940
    }
1834
1947
          G = -0.9692580*X+1.8759900*Y+0.0415557*Z
1835
1948
          B =  0.0556352*X-0.2039960*Y+1.0570700*Z
1836
1949
      */
 
1950
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
1951
  #pragma omp parallel for schedule(dynamic,4)
 
1952
#endif
1837
1953
      for (i=0; i <= (long) MaxMap; i++)
1838
1954
      {
1839
 
        x_map[i].x=3.2407100*i;
1840
 
        x_map[i].y=(-0.9692580)*i;
1841
 
        x_map[i].z=0.0556352*i;
1842
 
        y_map[i].x=(-1.5372600)*i;
1843
 
        y_map[i].y=1.8759900*i;
1844
 
        y_map[i].z=(-0.2039960)*i;
1845
 
        z_map[i].x=(-0.4985710)*i;
1846
 
        z_map[i].y=0.0415557*i;
1847
 
        z_map[i].z=1.0570700*i;
 
1955
        x_map[i].x=3.2407100f*(MagickRealType) i;
 
1956
        x_map[i].y=(-0.9692580f)*(MagickRealType) i;
 
1957
        x_map[i].z=0.0556352f*(MagickRealType) i;
 
1958
        y_map[i].x=(-1.5372600f)*(MagickRealType) i;
 
1959
        y_map[i].y=1.8759900f*(MagickRealType) i;
 
1960
        y_map[i].z=(-0.2039960f)*(MagickRealType) i;
 
1961
        z_map[i].x=(-0.4985710f)*(MagickRealType) i;
 
1962
        z_map[i].y=0.0415557f*(MagickRealType) i;
 
1963
        z_map[i].z=1.0570700f*(MagickRealType) i;
1848
1964
      }
1849
1965
      break;
1850
1966
    }
1859
1975
 
1860
1976
        YCC is scaled by 1.3584.  C1 zero is 156 and C2 is at 137.
1861
1977
      */
 
1978
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
1979
  #pragma omp parallel for schedule(dynamic,4)
 
1980
#endif
1862
1981
      for (i=0; i <= (long) MaxMap; i++)
1863
1982
      {
1864
 
        x_map[i].x=1.3584000*i;
1865
 
        y_map[i].x=0.0000000;
1866
 
        z_map[i].x=1.8215000*(i-(double) ScaleQuantumToMap(
1867
 
          ScaleCharToQuantum(137)));
1868
 
        x_map[i].y=1.3584000*i;
1869
 
        y_map[i].y=(-0.4302726)*(i-(double) ScaleQuantumToMap(
1870
 
          ScaleCharToQuantum(156)));
1871
 
        z_map[i].y=(-0.9271435)*(i-(double) ScaleQuantumToMap(
1872
 
          ScaleCharToQuantum(137)));
1873
 
        x_map[i].z=1.3584000*i;
1874
 
        y_map[i].z=2.2179000*(i-(double) ScaleQuantumToMap(
1875
 
          ScaleCharToQuantum(156)));
1876
 
        z_map[i].z=0.0000000;
 
1983
        x_map[i].x=1.3584000f*(MagickRealType) i;
 
1984
        y_map[i].x=0.0000000f;
 
1985
        z_map[i].x=1.8215000f*((MagickRealType) i-(MagickRealType)
 
1986
          ScaleQuantumToMap(ScaleCharToQuantum(137)));
 
1987
        x_map[i].y=1.3584000f*(MagickRealType) i;
 
1988
        y_map[i].y=(-0.4302726f)*((MagickRealType) i-(MagickRealType)
 
1989
          ScaleQuantumToMap(ScaleCharToQuantum(156)));
 
1990
        z_map[i].y=(-0.9271435f)*((MagickRealType) i-(MagickRealType)
 
1991
          ScaleQuantumToMap(ScaleCharToQuantum(137)));
 
1992
        x_map[i].z=1.3584000f*(MagickRealType) i;
 
1993
        y_map[i].z=2.2179000f*((MagickRealType) i-(MagickRealType)
 
1994
          ScaleQuantumToMap(ScaleCharToQuantum(156)));
 
1995
        z_map[i].z=0.0000000f;
1877
1996
      }
1878
1997
      break;
1879
1998
    }
1889
2008
        I and Q, normally -0.5 through 0.5, must be normalized to the range 0
1890
2009
        through QuantumRange.
1891
2010
      */
 
2011
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
2012
  #pragma omp parallel for schedule(dynamic,4)
 
2013
#endif
1892
2014
      for (i=0; i <= (long) MaxMap; i++)
1893
2015
      {
1894
 
        x_map[i].x=(double) i;
1895
 
        y_map[i].x=0.47810*(2.00000*i-MaxMap);
1896
 
        z_map[i].x=0.31070*(2.00000*i-MaxMap);
1897
 
        x_map[i].y=(double) i;
1898
 
        y_map[i].y=(-0.13635)*(2.00000*i-MaxMap);
1899
 
        z_map[i].y=(-0.32340)*(2.00000*i-MaxMap);
1900
 
        x_map[i].z=(double) i;
1901
 
        y_map[i].z=(-0.55185)*(2.00000*i-MaxMap);
1902
 
        z_map[i].z=0.85030*(2.00000*i-MaxMap);
 
2016
        x_map[i].x=(MagickRealType) i;
 
2017
        y_map[i].x=0.47810f*(2.00000f*(MagickRealType) i-(MagickRealType)
 
2018
          MaxMap);
 
2019
        z_map[i].x=0.31070f*(2.00000f*(MagickRealType) i-(MagickRealType)
 
2020
          MaxMap);
 
2021
        x_map[i].y=(MagickRealType) i;
 
2022
        y_map[i].y=(-0.13635f)*(2.00000f*(MagickRealType) i-(MagickRealType)
 
2023
          MaxMap);
 
2024
        z_map[i].y=(-0.32340f)*(2.00000f*(MagickRealType) i-(MagickRealType)
 
2025
          MaxMap);
 
2026
        x_map[i].z=(MagickRealType) i;
 
2027
        y_map[i].z=(-0.55185f)*(2.00000f*(MagickRealType) i-(MagickRealType)
 
2028
          MaxMap);
 
2029
        z_map[i].z=0.85030f*(2.00000f*(MagickRealType) i-(MagickRealType)
 
2030
          MaxMap);
1903
2031
      }
1904
2032
      break;
1905
2033
    }
1915
2043
        Pb and Pr, normally -0.5 through 0.5, must be normalized to the range 0
1916
2044
        through QuantumRange.
1917
2045
      */
 
2046
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
2047
  #pragma omp parallel for schedule(dynamic,4)
 
2048
#endif
1918
2049
      for (i=0; i <= (long) MaxMap; i++)
1919
2050
      {
1920
 
        x_map[i].x=(double) i;
1921
 
        y_map[i].x=0.000000;
1922
 
        z_map[i].x=0.701000*(2.00000*i-MaxMap);
1923
 
        x_map[i].y=(double) i;
1924
 
        y_map[i].y=(-0.172068)*(2.00000*i-MaxMap);
1925
 
        z_map[i].y=0.357068*(2.00000*i-MaxMap);
1926
 
        x_map[i].z=(double) i;
1927
 
        y_map[i].z=0.88600*(2.00000*i-MaxMap);
1928
 
        z_map[i].z=0.00000;
 
2051
        x_map[i].x=(MagickRealType) i;
 
2052
        y_map[i].x=0.000000f;
 
2053
        z_map[i].x=0.701000f*(2.00000f*(MagickRealType) i-(MagickRealType)
 
2054
          MaxMap);
 
2055
        x_map[i].y=(MagickRealType) i;
 
2056
        y_map[i].y=(-0.172068f)*(2.00000f*(MagickRealType) i-(MagickRealType)
 
2057
          MaxMap);
 
2058
        z_map[i].y=0.357068f*(2.00000f*(MagickRealType) i-(MagickRealType)
 
2059
          MaxMap);
 
2060
        x_map[i].z=(MagickRealType) i;
 
2061
        y_map[i].z=0.88600f*(2.00000f*(MagickRealType) i-(MagickRealType)
 
2062
          MaxMap);
 
2063
        z_map[i].z=0.00000f;
1929
2064
      }
1930
2065
      break;
1931
2066
    }
1942
2077
        U and V, normally -0.5 through 0.5, must be normalized to the range 0
1943
2078
        through QuantumRange.
1944
2079
      */
 
2080
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
2081
  #pragma omp parallel for schedule(dynamic,4)
 
2082
#endif
1945
2083
      for (i=0; i <= (long) MaxMap; i++)
1946
2084
      {
1947
 
        x_map[i].x=(double) i;
1948
 
        y_map[i].x=0.00000;
1949
 
        z_map[i].x=0.56990*(2.0000*i-MaxMap);
1950
 
        x_map[i].y=(double) i;
1951
 
        y_map[i].y=(-0.19690)*(2.00000*i-MaxMap);
1952
 
        z_map[i].y=(-0.29025)*(2.00000*i-MaxMap);
1953
 
        x_map[i].z=(double) i;
1954
 
        y_map[i].z=1.01395*(2.00000*i-MaxMap);
1955
 
        z_map[i].z=0.00000;
 
2085
        x_map[i].x=(MagickRealType) i;
 
2086
        y_map[i].x=0.00000f;
 
2087
        z_map[i].x=0.56990f*(2.0000f*(MagickRealType) i-(MagickRealType)
 
2088
          MaxMap);
 
2089
        x_map[i].y=(MagickRealType) i;
 
2090
        y_map[i].y=(-0.19690f)*(2.00000f*(MagickRealType) i-(MagickRealType)
 
2091
          MaxMap);
 
2092
        z_map[i].y=(-0.29025f)*(2.00000f*(MagickRealType) i-(MagickRealType)
 
2093
          MaxMap);
 
2094
        x_map[i].z=(MagickRealType) i;
 
2095
        y_map[i].z=1.01395f*(2.00000f*(MagickRealType) i-(MagickRealType)
 
2096
          MaxMap);
 
2097
        z_map[i].z=0.00000f;
1956
2098
      }
1957
2099
      break;
1958
2100
    }
1965
2107
    case DirectClass:
1966
2108
    default:
1967
2109
    {
1968
 
      MagickPixelPacket
1969
 
        zero;
1970
 
 
1971
2110
      /*
1972
2111
        Convert DirectClass image.
1973
2112
      */
1974
 
      GetMagickPixelPacket(image,&zero);
1975
 
      image_view=AcquireCacheViewThreadSet(image);
 
2113
      image_view=AcquireCacheView(image);
1976
2114
#if defined(MAGICKCORE_OPENMP_SUPPORT)
1977
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
2115
  #pragma omp parallel for schedule(dynamic,4) shared(status)
1978
2116
#endif
1979
2117
      for (y=0; y < (long) image->rows; y++)
1980
2118
      {
 
2119
        MagickBooleanType
 
2120
          sync;
 
2121
 
1981
2122
        MagickPixelPacket
1982
2123
          pixel;
1983
2124
 
1984
2125
        register long
1985
 
          id,
1986
2126
          x;
1987
2127
 
1988
2128
        register PixelPacket
1990
2130
 
1991
2131
        if (status == MagickFalse)
1992
2132
          continue;
1993
 
        id=GetCacheViewThreadId();
1994
 
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
 
2133
        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 
2134
          exception);
1995
2135
        if (q == (PixelPacket *) NULL)
1996
2136
          {
1997
2137
            status=MagickFalse;
1998
2138
            continue;
1999
2139
          }
2000
 
        pixel=zero;
2001
2140
        for (x=0; x < (long) image->columns; x++)
2002
2141
        {
2003
 
          pixel.red=x_map[ScaleQuantumToMap(q->red)].x+
2004
 
            y_map[ScaleQuantumToMap(q->green)].x+
2005
 
            z_map[ScaleQuantumToMap(q->blue)].x;
2006
 
          pixel.green=x_map[ScaleQuantumToMap(q->red)].y+
2007
 
            y_map[ScaleQuantumToMap(q->green)].y+
2008
 
            z_map[ScaleQuantumToMap(q->blue)].y;
2009
 
          pixel.blue=x_map[ScaleQuantumToMap(q->red)].z+
2010
 
            y_map[ScaleQuantumToMap(q->green)].z+
2011
 
            z_map[ScaleQuantumToMap(q->blue)].z;
 
2142
          register unsigned long
 
2143
            blue,
 
2144
            green,
 
2145
            red;
 
2146
 
 
2147
          red=ScaleQuantumToMap(q->red);
 
2148
          green=ScaleQuantumToMap(q->green);
 
2149
          blue=ScaleQuantumToMap(q->blue);
 
2150
          pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
 
2151
          pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
 
2152
          pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
2012
2153
          switch (colorspace)
2013
2154
          {
2014
2155
            case YCCColorspace:
2053
2194
            pixel.blue);
2054
2195
          q++;
2055
2196
        }
2056
 
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
2057
 
          status=MagickFalse;
2058
 
        proceed=SetImageProgress(image,TransformRGBImageTag,y,image->rows);
2059
 
        if (proceed == MagickFalse)
2060
 
          status=MagickFalse;
 
2197
        sync=SyncCacheViewAuthenticPixels(image_view,exception);
 
2198
        if (sync == MagickFalse)
 
2199
          status=MagickFalse;
 
2200
        if (image->progress_monitor != (MagickProgressMonitor) NULL)
 
2201
          {
 
2202
            MagickBooleanType
 
2203
              proceed;
 
2204
 
 
2205
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
2206
  #pragma omp critical (MagickCore_TransformRGBImage)
 
2207
#endif
 
2208
            proceed=SetImageProgress(image,TransformRGBImageTag,progress++,
 
2209
              image->rows);
 
2210
            if (proceed == MagickFalse)
 
2211
              status=MagickFalse;
 
2212
          }
2061
2213
      }
2062
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
2214
      image_view=DestroyCacheView(image_view);
2063
2215
      break;
2064
2216
    }
2065
2217
    case PseudoClass:
2066
2218
    {
2067
 
      MagickPixelPacket
2068
 
        zero;
2069
 
 
2070
2219
      /*
2071
2220
        Convert PseudoClass image.
2072
2221
      */
2073
 
      GetMagickPixelPacket(image,&zero);
2074
 
      image_view=AcquireCacheViewThreadSet(image);
 
2222
      image_view=AcquireCacheView(image);
2075
2223
#if defined(MAGICKCORE_OPENMP_SUPPORT)
2076
 
      #pragma omp parallel for schedule(static,64) shared(status)
 
2224
  #pragma omp parallel for schedule(dynamic,4) shared(status)
2077
2225
#endif
2078
2226
      for (i=0; i < (long) image->colors; i++)
2079
2227
      {
2080
2228
        MagickPixelPacket
2081
2229
          pixel;
2082
2230
 
2083
 
        pixel=zero;
2084
 
        pixel.red=x_map[ScaleQuantumToMap(image->colormap[i].red)].x+
2085
 
          y_map[ScaleQuantumToMap(image->colormap[i].green)].x+
2086
 
          z_map[ScaleQuantumToMap(image->colormap[i].blue)].x;
2087
 
        pixel.green=x_map[ScaleQuantumToMap(image->colormap[i].red)].y+
2088
 
          y_map[ScaleQuantumToMap(image->colormap[i].green)].y+
2089
 
          z_map[ScaleQuantumToMap(image->colormap[i].blue)].y;
2090
 
        pixel.blue=x_map[ScaleQuantumToMap(image->colormap[i].red)].z+
2091
 
          y_map[ScaleQuantumToMap(image->colormap[i].green)].z+
2092
 
          z_map[ScaleQuantumToMap(image->colormap[i].blue)].z;
 
2231
        register unsigned long
 
2232
          blue,
 
2233
          green,
 
2234
          red;
 
2235
 
 
2236
        red=ScaleQuantumToMap(image->colormap[i].red);
 
2237
        green=ScaleQuantumToMap(image->colormap[i].green);
 
2238
        blue=ScaleQuantumToMap(image->colormap[i].blue);
 
2239
        pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
 
2240
        pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
 
2241
        pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
2093
2242
        switch (colorspace)
2094
2243
        {
2095
2244
          case YCCColorspace:
2134
2283
          }
2135
2284
        }
2136
2285
      }
2137
 
      image_view=DestroyCacheViewThreadSet(image_view);
 
2286
      image_view=DestroyCacheView(image_view);
2138
2287
      (void) SyncImage(image);
2139
2288
      break;
2140
2289
    }
2142
2291
  /*
2143
2292
    Relinquish resources.
2144
2293
  */
2145
 
  z_map=(PrimaryInfo *) RelinquishMagickMemory(z_map);
2146
 
  y_map=(PrimaryInfo *) RelinquishMagickMemory(y_map);
2147
 
  x_map=(PrimaryInfo *) RelinquishMagickMemory(x_map);
 
2294
  z_map=(TransformPacket *) RelinquishMagickMemory(z_map);
 
2295
  y_map=(TransformPacket *) RelinquishMagickMemory(y_map);
 
2296
  x_map=(TransformPacket *) RelinquishMagickMemory(x_map);
2148
2297
  image->colorspace=RGBColorspace;
2149
2298
  return(MagickTrue);
2150
2299
}