/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%                      CCCC   AAA    CCCC  H   H  EEEEE                       %

%                     C      A   A  C      H   H  E                           %

%                     C      AAAAA  C      HHHHH  EEE                         %

%                     C      A   A  C      H   H  E                           %

%                      CCCC  A   A   CCCC  H   H  EEEEE                       %

%                                                                             %

%                                                                             %

%                       MagickCore Pixel Cache Methods                        %

%                                                                             %

%                              Software Design                                %

%                                   Cristy                                    %

%                                 July 1999                                   %

%                                                                             %

%                                                                             %

%  Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization         %

%  dedicated to making software imaging solutions freely available.           %

%                                                                             %

%  You may not use this file except in compliance with the License.  You may  %

%  obtain a copy of the License at                                            %

%                                                                             %

%    https://imagemagick.org/license/                                         %

%                                                                             %

%  Unless required by applicable law or agreed to in writing, software        %

%  distributed under the License is distributed on an "AS IS" BASIS,          %

%  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %

%  See the License for the specific language governing permissions and        %

%  limitations under the License.                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%

%

*/

/*

  Include declarations.

*/

#include "MagickCore/studio.h"

#include "MagickCore/blob.h"

#include "MagickCore/blob-private.h"

#include "MagickCore/cache.h"

#include "MagickCore/cache-private.h"

#include "MagickCore/color-private.h"

#include "MagickCore/colorspace-private.h"

#include "MagickCore/composite-private.h"

#include "MagickCore/distribute-cache-private.h"

#include "MagickCore/exception.h"

#include "MagickCore/exception-private.h"

#include "MagickCore/geometry.h"

#include "MagickCore/list.h"

#include "MagickCore/log.h"

#include "MagickCore/magick.h"

#include "MagickCore/memory_.h"

#include "MagickCore/memory-private.h"

#include "MagickCore/nt-base-private.h"

#include "MagickCore/option.h"

#include "MagickCore/pixel.h"

#include "MagickCore/pixel-accessor.h"

#include "MagickCore/pixel-private.h"

#include "MagickCore/policy.h"

#include "MagickCore/policy-private.h"

#include "MagickCore/quantum.h"

#include "MagickCore/random_.h"

#include "MagickCore/registry.h"

#include "MagickCore/resource_.h"

#include "MagickCore/semaphore.h"

#include "MagickCore/splay-tree.h"

#include "MagickCore/string_.h"

#include "MagickCore/string-private.h"

#include "MagickCore/timer-private.h"

#include "MagickCore/thread-private.h"

#include "MagickCore/utility.h"

#include "MagickCore/utility-private.h"

#if defined(MAGICKCORE_HAVE_ERRNO_H)

#  include <errno.h>

#endif

#if defined(MAGICKCORE_HAVE_SYS_LOADAVG_H)

#  include <sys/loadavg.h>

#endif

#if defined(MAGICKCORE_ZLIB_DELEGATE)

#  include "zlib.h"

#endif

/*

  Define declarations.

*/

#define CacheTick(offset,extent)  QuantumTick((MagickOffsetType) offset,extent)

#define IsFileDescriptorLimitExceeded() (GetMagickResource(FileResource) > \

  GetMagickResourceLimit(FileResource) ? MagickTrue : MagickFalse)

/*

  Typedef declarations.

*/

typedef struct _MagickModulo

{

  ssize_t

    quotient,

    remainder;

} MagickModulo;

/*

  Forward declarations.

*/

#if defined(__cplusplus) || defined(c_plusplus)

extern "C" {

#endif

static Cache

  GetImagePixelCache(Image *,const MagickBooleanType,ExceptionInfo *)

    magick_hot_spot;

static const Quantum

  *GetVirtualPixelCache(const Image *,const VirtualPixelMethod,const ssize_t,

    const ssize_t,const size_t,const size_t,ExceptionInfo *),

  *GetVirtualPixelsCache(const Image *);

static const void

  *GetVirtualMetacontentFromCache(const Image *);

static MagickBooleanType

  GetOneAuthenticPixelFromCache(Image *,const ssize_t,const ssize_t,Quantum *,

    ExceptionInfo *),

  GetOneVirtualPixelFromCache(const Image *,const VirtualPixelMethod,

    const ssize_t,const ssize_t,Quantum *,ExceptionInfo *),

  OpenPixelCache(Image *,const MapMode,ExceptionInfo *),

  OpenPixelCacheOnDisk(CacheInfo *,const MapMode,ExceptionInfo *),

  ReadPixelCachePixels(CacheInfo *magick_restrict,NexusInfo *magick_restrict,

    ExceptionInfo *),

  ReadPixelCacheMetacontent(CacheInfo *magick_restrict,

    NexusInfo *magick_restrict,ExceptionInfo *),

  SyncAuthenticPixelsCache(Image *,ExceptionInfo *),

  WritePixelCachePixels(CacheInfo *magick_restrict,NexusInfo *magick_restrict,

    ExceptionInfo *),

  WritePixelCacheMetacontent(CacheInfo *,NexusInfo *magick_restrict,

    ExceptionInfo *);

static Quantum

  *GetAuthenticPixelsCache(Image *,const ssize_t,const ssize_t,const size_t,

    const size_t,ExceptionInfo *),

  *QueueAuthenticPixelsCache(Image *,const ssize_t,const ssize_t,const size_t,

    const size_t,ExceptionInfo *),

  *QueueAuthenticPixelCacheNexusInternal(Image *,const ssize_t,const ssize_t,

    const size_t,const size_t,const MagickBooleanType,NexusInfo **,

    ExceptionInfo *),

  *SetPixelCacheNexusPixels(const CacheInfo *magick_restrict,const MapMode,

    const ssize_t,const ssize_t,const size_t,const size_t,

    const MagickBooleanType,NexusInfo *magick_restrict,ExceptionInfo *)

    magick_hot_spot;

#if defined(MAGICKCORE_OPENCL_SUPPORT)

static void

  CopyOpenCLBuffer(CacheInfo *magick_restrict);

#endif

#if defined(__cplusplus) || defined(c_plusplus)

}

#endif

/*

  Global declarations.

*/

static SemaphoreInfo

  *cache_semaphore = (SemaphoreInfo *) NULL;

static ssize_t

  cache_anonymous_memory = (-1);

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   A c q u i r e P i x e l C a c h e                                         %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  AcquirePixelCache() acquires a pixel cache.

%

%  The format of the AcquirePixelCache() method is:

%

%      Cache AcquirePixelCache(const size_t number_threads)

%

%  A description of each parameter follows:

%

%    o number_threads: the number of nexus threads.

%

*/

MagickPrivate Cache AcquirePixelCache(const size_t number_threads)

{

  CacheInfo

    *magick_restrict cache_info;

  char

    *value;

  cache_info=(CacheInfo *) AcquireAlignedMemory(1,sizeof(*cache_info));

  if (cache_info == (CacheInfo *) NULL)

    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");

  (void) memset(cache_info,0,sizeof(*cache_info));

  cache_info->type=UndefinedCache;

  cache_info->mode=IOMode;

  cache_info->disk_mode=IOMode;

  cache_info->colorspace=sRGBColorspace;

  cache_info->file=(-1);

  cache_info->id=GetMagickThreadId();

  cache_info->number_threads=number_threads;

  if (GetOpenMPMaximumThreads() > cache_info->number_threads)

    cache_info->number_threads=GetOpenMPMaximumThreads();

  if (cache_info->number_threads == 0)

    cache_info->number_threads=1;

  cache_info->nexus_info=AcquirePixelCacheNexus(cache_info->number_threads);

  value=GetEnvironmentValue("MAGICK_SYNCHRONIZE");

  if (value != (const char *) NULL)

    {

      cache_info->synchronize=IsStringTrue(value);

      value=DestroyString(value);

    }

  value=GetPolicyValue("cache:synchronize");

  if (value != (const char *) NULL)

    {

      cache_info->synchronize=IsStringTrue(value);

      value=DestroyString(value);

    }

  cache_info->width_limit=MagickMin(GetMagickResourceLimit(WidthResource),

    (MagickSizeType) MAGICK_SSIZE_MAX);

  cache_info->height_limit=MagickMin(GetMagickResourceLimit(HeightResource),

    (MagickSizeType) MAGICK_SSIZE_MAX);

  cache_info->semaphore=AcquireSemaphoreInfo();

  cache_info->reference_count=1;

  cache_info->file_semaphore=AcquireSemaphoreInfo();

  cache_info->debug=(GetLogEventMask() & CacheEvent) != 0 ? MagickTrue :

    MagickFalse;

  cache_info->signature=MagickCoreSignature;

  return((Cache ) cache_info);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   A c q u i r e P i x e l C a c h e N e x u s                               %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  AcquirePixelCacheNexus() allocates the NexusInfo structure.

%

%  The format of the AcquirePixelCacheNexus method is:

%

%      NexusInfo **AcquirePixelCacheNexus(const size_t number_threads)

%

%  A description of each parameter follows:

%

%    o number_threads: the number of nexus threads.

%

*/

MagickPrivate NexusInfo **AcquirePixelCacheNexus(const size_t number_threads)

{

  NexusInfo

    **magick_restrict nexus_info;

  ssize_t

    i;

  nexus_info=(NexusInfo **) MagickAssumeAligned(AcquireAlignedMemory(2*

    number_threads,sizeof(*nexus_info)));

  if (nexus_info == (NexusInfo **) NULL)

    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");

  *nexus_info=(NexusInfo *) AcquireQuantumMemory(number_threads,

    2*sizeof(**nexus_info));

  if (*nexus_info == (NexusInfo *) NULL)

    ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");

  (void) memset(*nexus_info,0,2*number_threads*sizeof(**nexus_info));

  for (i=0; i < (ssize_t) (2*number_threads); i++)

  {

    nexus_info[i]=(*nexus_info+i);

    if (i < (ssize_t) number_threads)

      nexus_info[i]->virtual_nexus=(*nexus_info+number_threads+i);

    nexus_info[i]->signature=MagickCoreSignature;

  }

  return(nexus_info);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   A c q u i r e P i x e l C a c h e P i x e l s                             %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  AcquirePixelCachePixels() returns the pixels associated with the specified

%  image.

%

%  The format of the AcquirePixelCachePixels() method is:

%

%      void *AcquirePixelCachePixels(const Image *image,size_t *length,

%        ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o image: the image.

%

%    o length: the pixel cache length.

%

%    o exception: return any errors or warnings in this structure.

%

*/

MagickExport void *AcquirePixelCachePixels(const Image *image,size_t *length,

  ExceptionInfo *exception)

{

  CacheInfo

    *magick_restrict cache_info;

  assert(image != (const Image *) NULL);

  assert(image->signature == MagickCoreSignature);

  assert(exception != (ExceptionInfo *) NULL);

  assert(exception->signature == MagickCoreSignature);

  assert(image->cache != (Cache) NULL);

  (void) exception;

  cache_info=(CacheInfo *) image->cache;

  assert(cache_info->signature == MagickCoreSignature);

  *length=0;

  if ((cache_info->type != MemoryCache) && (cache_info->type != MapCache))

    return((void *) NULL);

  *length=(size_t) cache_info->length;

  return(cache_info->pixels);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   C a c h e C o m p o n e n t G e n e s i s                                 %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  CacheComponentGenesis() instantiates the cache component.

%

%  The format of the CacheComponentGenesis method is:

%

%      MagickBooleanType CacheComponentGenesis(void)

%

*/

MagickPrivate MagickBooleanType CacheComponentGenesis(void)

{

  if (cache_semaphore == (SemaphoreInfo *) NULL)

    cache_semaphore=AcquireSemaphoreInfo();

  return(MagickTrue);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   C a c h e C o m p o n e n t T e r m i n u s                               %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  CacheComponentTerminus() destroys the cache component.

%

%  The format of the CacheComponentTerminus() method is:

%

%      CacheComponentTerminus(void)

%

*/

MagickPrivate void CacheComponentTerminus(void)

{

  if (cache_semaphore == (SemaphoreInfo *) NULL)

    ActivateSemaphoreInfo(&cache_semaphore);

  /* no op-- nothing to destroy */

  RelinquishSemaphoreInfo(&cache_semaphore);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   C l i p P i x e l C a c h e N e x u s                                     %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  ClipPixelCacheNexus() clips the cache nexus as defined by the image clip

%  mask.  The method returns MagickTrue if the pixel region is clipped,

%  otherwise MagickFalse.

%

%  The format of the ClipPixelCacheNexus() method is:

%

%      MagickBooleanType ClipPixelCacheNexus(Image *image,NexusInfo *nexus_info,

%        ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o image: the image.

%

%    o nexus_info: the cache nexus to clip.

%

%    o exception: return any errors or warnings in this structure.

%

*/

static MagickBooleanType ClipPixelCacheNexus(Image *image,

  NexusInfo *nexus_info,ExceptionInfo *exception)

{

  CacheInfo

    *magick_restrict cache_info;

  Quantum

    *magick_restrict p,

    *magick_restrict q;

  ssize_t

    y;

  /*

    Apply clip mask.

  */

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);

  if ((image->channels & WriteMaskChannel) == 0)

    return(MagickTrue);

  if ((nexus_info->region.width == 0) || (nexus_info->region.height == 0))

    return(MagickTrue);

  cache_info=(CacheInfo *) image->cache;

  if (cache_info == (CacheInfo *) NULL)

    return(MagickFalse);

  p=GetAuthenticPixelCacheNexus(image,nexus_info->region.x,nexus_info->region.y,

    nexus_info->region.width,nexus_info->region.height,

    nexus_info->virtual_nexus,exception);

  q=nexus_info->pixels;

  if ((p == (Quantum *) NULL) || (q == (Quantum *) NULL))

    return(MagickFalse);

  for (y=0; y < (ssize_t) nexus_info->region.height; y++)

  {

    ssize_t

      x;

    for (x=0; x < (ssize_t) nexus_info->region.width; x++)

    {

      double

        mask;

      ssize_t

        i;

      mask=(double) GetPixelWriteMask(image,p);

      if (fabs(mask) >= MagickEpsilon)

        {

          double

            mask_alpha,

            dst_alpha;

          Quantum

            src_alpha;

          src_alpha=GetPixelAlpha(image,p);

          mask_alpha=QuantumScale*mask*(double) src_alpha;

          dst_alpha=(double) GetPixelAlpha(image,q);

          for (i=0; i < (ssize_t) image->number_channels; i++)

          {

            PixelTrait

              traits;

            PixelChannel channel = GetPixelChannelChannel(image,i);

            if (channel == AlphaPixelChannel)

              continue;

            traits=GetPixelChannelTraits(image,channel);

            if ((traits & UpdatePixelTrait) == 0)

              continue;

            q[i]=ClampToQuantum(MagickOver_((double) p[i],mask_alpha,

              (double) q[i],dst_alpha));

          }

          SetPixelAlpha(image,src_alpha,q);

        }

      p+=(ptrdiff_t) GetPixelChannels(image);

      q+=(ptrdiff_t) GetPixelChannels(image);

    }

  }

  return(MagickTrue);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   C l o n e P i x e l C a c h e                                             %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  ClonePixelCache() clones a pixel cache.

%

%  The format of the ClonePixelCache() method is:

%

%      Cache ClonePixelCache(const Cache cache)

%

%  A description of each parameter follows:

%

%    o cache: the pixel cache.

%

*/

MagickPrivate Cache ClonePixelCache(const Cache cache)

{

  CacheInfo

    *magick_restrict clone_info;

  const CacheInfo

    *magick_restrict cache_info;

  assert(cache != NULL);

  cache_info=(const CacheInfo *) cache;

  assert(cache_info->signature == MagickCoreSignature);

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",

      cache_info->filename);

  clone_info=(CacheInfo *) AcquirePixelCache(cache_info->number_threads);

  clone_info->virtual_pixel_method=cache_info->virtual_pixel_method;

  return((Cache ) clone_info);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   C l o n e P i x e l C a c h e M e t h o d s                               %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  ClonePixelCacheMethods() clones the pixel cache methods from one cache to

%  another.

%

%  The format of the ClonePixelCacheMethods() method is:

%

%      void ClonePixelCacheMethods(Cache clone,const Cache cache)

%

%  A description of each parameter follows:

%

%    o clone: Specifies a pointer to a Cache structure.

%

%    o cache: the pixel cache.

%

*/

MagickPrivate void ClonePixelCacheMethods(Cache clone,const Cache cache)

{

  CacheInfo

    *magick_restrict cache_info,

    *magick_restrict source_info;

  assert(clone != (Cache) NULL);

  source_info=(CacheInfo *) clone;

  assert(source_info->signature == MagickCoreSignature);

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",

      source_info->filename);

  assert(cache != (Cache) NULL);

  cache_info=(CacheInfo *) cache;

  assert(cache_info->signature == MagickCoreSignature);

  source_info->methods=cache_info->methods;

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   C l o n e P i x e l C a c h e R e p o s i t o r y                         %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  ClonePixelCacheRepository() clones the source pixel cache to the destination

%  cache.

%

%  The format of the ClonePixelCacheRepository() method is:

%

%      MagickBooleanType ClonePixelCacheRepository(CacheInfo *clone_info,

%        CacheInfo *cache_info,ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o clone_info: the pixel cache.

%

%    o cache_info: the source pixel cache.

%

%    o exception: return any errors or warnings in this structure.

%

*/

static MagickBooleanType ClonePixelCacheOnDisk(

  CacheInfo *magick_restrict cache_info,CacheInfo *magick_restrict clone_info,

  ExceptionInfo *exception)

{

  MagickSizeType

    extent;

  size_t

    quantum;

  ssize_t

    count;

  struct stat

    file_stats;

  unsigned char

    *buffer;

  /*

    Clone pixel cache on disk with identical morphology.

  */

  if ((OpenPixelCacheOnDisk(cache_info,ReadMode,exception) == MagickFalse) ||

      (OpenPixelCacheOnDisk(clone_info,IOMode,exception) == MagickFalse))

    return(MagickFalse);

  if ((lseek(cache_info->file,0,SEEK_SET) < 0) ||

      (lseek(clone_info->file,0,SEEK_SET) < 0))

    return(MagickFalse);

  quantum=(size_t) MagickMaxBufferExtent;

  if ((fstat(cache_info->file,&file_stats) == 0) && (file_stats.st_size > 0))

    {

#if defined(MAGICKCORE_HAVE_LINUX_SENDFILE)

      if (cache_info->length < 0x7ffff000)

        {

          do

          {

            count=sendfile(clone_info->file,cache_info->file,(off_t *) NULL,

              (size_t) cache_info->length);

          } while ((count < 0) && (errno == EINTR));

          if (count == (ssize_t) cache_info->length)

            return(MagickTrue);

          if (count < 0)

            return(MagickFalse);

          if ((lseek(cache_info->file,0,SEEK_SET) < 0) ||

              (lseek(clone_info->file,0,SEEK_SET) < 0))

            return(MagickFalse);

        }

#endif

      quantum=(size_t) MagickMin(file_stats.st_size,MagickMaxBufferExtent);

    }

  buffer=(unsigned char *) AcquireQuantumMemory(quantum,sizeof(*buffer));

  if (buffer == (unsigned char *) NULL)

    return(MagickFalse);

  extent=0;

  while (extent < cache_info->length)

  {

    size_t

      length;

    length=(size_t) MagickMin((MagickSizeType) quantum,cache_info->length-

      extent);

    count=MagickRead(cache_info->file,buffer,length);

    if (count <= 0)

      {

        buffer=(unsigned char *) RelinquishMagickMemory(buffer);

        return(MagickFalse);

      }

    {

      ssize_t

        number_bytes,

        offset = 0;

      while (offset < count)

      {

        number_bytes=MagickWrite(clone_info->file,buffer+offset,(size_t) (count-

          offset));

        if (number_bytes <= 0)

          {

            buffer=(unsigned char *) RelinquishMagickMemory(buffer);

            return(MagickFalse);

          }

        offset+=number_bytes;

      }

      extent+=(MagickSizeType) offset;

    }

  }

  buffer=(unsigned char *) RelinquishMagickMemory(buffer);

  return(extent == cache_info->length ? MagickTrue : MagickFalse);

}

#if defined(MAGICKCORE_OPENMP_SUPPORT)

static inline int GetCacheNumberThreads(const CacheInfo *source,

  const CacheInfo *destination,const size_t chunk,const int factor)

{

  size_t

    max_threads = (size_t) GetMagickResourceLimit(ThreadResource),

    number_threads = 1UL,

    workload_factor = 64UL << factor;

  /*

    Determine number of threads based on workload.

  */

  number_threads=(chunk <= workload_factor) ? 1UL :

    (chunk >= (workload_factor << 6)) ? max_threads :

    1UL+(chunk-workload_factor)*(max_threads-1L)/(((workload_factor << 6))-1L);

  /*

    Limit threads for non-memory or non-map cache sources/destinations.

  */

  if (((source->type != MemoryCache) && (source->type != MapCache)) ||

      ((destination->type != MemoryCache) && (destination->type != MapCache)))

    number_threads=MagickMin(number_threads,4);

  return((int) number_threads);

}

#endif

static MagickBooleanType ClonePixelCacheRepository(

  CacheInfo *magick_restrict clone_info,CacheInfo *magick_restrict cache_info,

  ExceptionInfo *exception)

{

#define cache_number_threads(source,destination,chunk,factor) \

  num_threads(GetCacheNumberThreads((source),(destination),(chunk),(factor)))

  MagickBooleanType

    optimize,

    status;

  NexusInfo

    **magick_restrict cache_nexus,

    **magick_restrict clone_nexus;

  size_t

    length;

  ssize_t

    y;

  assert(cache_info != (CacheInfo *) NULL);

  assert(clone_info != (CacheInfo *) NULL);

  assert(exception != (ExceptionInfo *) NULL);

  if (cache_info->type == PingCache)

    return(MagickTrue);

  length=cache_info->number_channels*sizeof(*cache_info->channel_map);

  if ((cache_info->storage_class == clone_info->storage_class) &&

      (cache_info->colorspace == clone_info->colorspace) &&

      (cache_info->alpha_trait == clone_info->alpha_trait) &&

      (cache_info->channels == clone_info->channels) &&

      (cache_info->columns == clone_info->columns) &&

      (cache_info->rows == clone_info->rows) &&

      (cache_info->number_channels == clone_info->number_channels) &&

      (memcmp(cache_info->channel_map,clone_info->channel_map,length) == 0) &&

      (cache_info->metacontent_extent == clone_info->metacontent_extent))

    {

      /*

        Identical pixel cache morphology.

      */

      if (((cache_info->type == MemoryCache) ||

           (cache_info->type == MapCache)) &&

          ((clone_info->type == MemoryCache) || (clone_info->type == MapCache)))

        {

          (void) memcpy(clone_info->pixels,cache_info->pixels,

            cache_info->number_channels*cache_info->columns*cache_info->rows*

            sizeof(*cache_info->pixels));

          if ((cache_info->metacontent_extent != 0) &&

              (clone_info->metacontent_extent != 0))

            (void) memcpy(clone_info->metacontent,cache_info->metacontent,

              cache_info->columns*cache_info->rows*

              clone_info->metacontent_extent*sizeof(unsigned char));

          return(MagickTrue);

        }

      if ((cache_info->type == DiskCache) && (clone_info->type == DiskCache))

        return(ClonePixelCacheOnDisk(cache_info,clone_info,exception));

    }

  /*

    Mismatched pixel cache morphology.

  */

  cache_nexus=AcquirePixelCacheNexus(cache_info->number_threads);

  clone_nexus=AcquirePixelCacheNexus(clone_info->number_threads);

  length=cache_info->number_channels*sizeof(*cache_info->channel_map);

  optimize=(cache_info->number_channels == clone_info->number_channels) &&

    (memcmp(cache_info->channel_map,clone_info->channel_map,length) == 0) ?

    MagickTrue : MagickFalse;

  length=(size_t) MagickMin(cache_info->number_channels*cache_info->columns,

    clone_info->number_channels*clone_info->columns);

  status=MagickTrue;

#if defined(MAGICKCORE_OPENMP_SUPPORT)

  #pragma omp parallel for schedule(static) shared(status) \

    cache_number_threads(cache_info,clone_info,cache_info->rows,3)

#endif

  for (y=0; y < (ssize_t) cache_info->rows; y++)

  {

    const int

      id = GetOpenMPThreadId();

    Quantum

      *pixels;

    ssize_t

      x;

    if (status == MagickFalse)

      continue;

    if (y >= (ssize_t) clone_info->rows)

      continue;

    pixels=SetPixelCacheNexusPixels(cache_info,ReadMode,0,y,

      cache_info->columns,1,MagickFalse,cache_nexus[id],exception);

    if (pixels == (Quantum *) NULL)

      continue;

    status=ReadPixelCachePixels(cache_info,cache_nexus[id],exception);

    if (status == MagickFalse)

      continue;

    pixels=SetPixelCacheNexusPixels(clone_info,WriteMode,0,y,

      clone_info->columns,1,MagickTrue,clone_nexus[id],exception);

    if (pixels == (Quantum *) NULL)

      continue;

    (void) memset(clone_nexus[id]->pixels,0,(size_t) clone_nexus[id]->length);

    if (optimize != MagickFalse)

      (void) memcpy(clone_nexus[id]->pixels,cache_nexus[id]->pixels,length*

        sizeof(Quantum));

    else

      {

        const Quantum

          *magick_restrict p;

        Quantum

          *magick_restrict q;

        /*

          Mismatched pixel channel map.

        */

        p=cache_nexus[id]->pixels;

        q=clone_nexus[id]->pixels;

        for (x=0; x < (ssize_t) cache_info->columns; x++)

        {

          ssize_t

            i;

          if (x == (ssize_t) clone_info->columns)

            break;

          for (i=0; i < (ssize_t) clone_info->number_channels; i++)

          {

            PixelChannel

              channel;

            PixelTrait

              traits;

            channel=clone_info->channel_map[i].channel;

            traits=cache_info->channel_map[channel].traits;

            if (traits != UndefinedPixelTrait)

              *q=(*(p+cache_info->channel_map[channel].offset));

            q++;

          }

          p+=(ptrdiff_t) cache_info->number_channels;

        }

      }

    status=WritePixelCachePixels(clone_info,clone_nexus[id],exception);

  }

  if ((cache_info->metacontent_extent != 0) &&

      (clone_info->metacontent_extent != 0))

    {

      /*

        Clone metacontent.

      */

      length=(size_t) MagickMin(cache_info->metacontent_extent,

        clone_info->metacontent_extent);

#if defined(MAGICKCORE_OPENMP_SUPPORT)

      #pragma omp parallel for schedule(static) shared(status) \

        cache_number_threads(cache_info,clone_info,cache_info->rows,3)

#endif

      for (y=0; y < (ssize_t) cache_info->rows; y++)

      {

        const int

          id = GetOpenMPThreadId();

        Quantum

          *pixels;

        if (status == MagickFalse)

          continue;

        if (y >= (ssize_t) clone_info->rows)

          continue;

        pixels=SetPixelCacheNexusPixels(cache_info,ReadMode,0,y,

          cache_info->columns,1,MagickFalse,cache_nexus[id],exception);

        if (pixels == (Quantum *) NULL)

          continue;

        status=ReadPixelCacheMetacontent(cache_info,cache_nexus[id],exception);

        if (status == MagickFalse)

          continue;

        pixels=SetPixelCacheNexusPixels(clone_info,WriteMode,0,y,

          clone_info->columns,1,MagickTrue,clone_nexus[id],exception);

        if (pixels == (Quantum *) NULL)

          continue;

        if ((clone_nexus[id]->metacontent != (void *) NULL) &&

            (cache_nexus[id]->metacontent != (void *) NULL))

          (void) memcpy(clone_nexus[id]->metacontent,

            cache_nexus[id]->metacontent,length*sizeof(unsigned char));

        status=WritePixelCacheMetacontent(clone_info,clone_nexus[id],exception);

      }

    }

  clone_nexus=DestroyPixelCacheNexus(clone_nexus,clone_info->number_threads);

  cache_nexus=DestroyPixelCacheNexus(cache_nexus,cache_info->number_threads);

  if (cache_info->debug != MagickFalse)

    {

      char

        message[MagickPathExtent];

      (void) FormatLocaleString(message,MagickPathExtent,"%s => %s",

        CommandOptionToMnemonic(MagickCacheOptions,(ssize_t) cache_info->type),

        CommandOptionToMnemonic(MagickCacheOptions,(ssize_t) clone_info->type));

      (void) LogMagickEvent(CacheEvent,GetMagickModule(),"%s",message);

    }

  return(status);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   D e s t r o y I m a g e P i x e l C a c h e                               %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  DestroyImagePixelCache() deallocates memory associated with the pixel cache.

%

%  The format of the DestroyImagePixelCache() method is:

%

%      void DestroyImagePixelCache(Image *image)

%

%  A description of each parameter follows:

%

%    o image: the image.

%

*/

static void DestroyImagePixelCache(Image *image)

{

  assert(image != (Image *) NULL);

  assert(image->signature == MagickCoreSignature);

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);

  if (image->cache != (void *) NULL)

    image->cache=DestroyPixelCache(image->cache);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   D e s t r o y I m a g e P i x e l s                                       %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  DestroyImagePixels() deallocates memory associated with the pixel cache.

%

%  The format of the DestroyImagePixels() method is:

%

%      void DestroyImagePixels(Image *image)

%

%  A description of each parameter follows:

%

%    o image: the image.

%

*/

MagickExport void DestroyImagePixels(Image *image)

{

  CacheInfo

    *magick_restrict cache_info;

  assert(image != (const Image *) NULL);

  assert(image->signature == MagickCoreSignature);

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);

  if (image->cache == (Cache) NULL)

    return;

  cache_info=(CacheInfo *) image->cache;

  assert(cache_info->signature == MagickCoreSignature);

  if (cache_info->methods.destroy_pixel_handler != (DestroyPixelHandler) NULL)

    {

      cache_info->methods.destroy_pixel_handler(image);

      return;

    }

  image->cache=DestroyPixelCache(image->cache);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

+   D e s t r o y P i x e l C a c h e                                         %