(no commit message)

diff --git a/MagickCore/cache.c b/MagickCore/cache.c
index 5e6160b87fd32d5408aa015c760621061e9279d8..498c5ea793ec5574dd9a8fe16d6fb0de2932526a 100644 (file)
--- a/MagickCore/cache.c
+++ b/MagickCore/cache.c
@@ -1049,6 +1049,8 @@ static MagickBooleanType ClonePixelCachePixels(CacheInfo *clone_info,
 
   if (cache_info->type == PingCache)
     return(MagickTrue);
+  if (cache_info->type == DistributedCache)
+    return(PixelCacheCloneUnoptimized(clone_info,cache_info,exception));
   p=cache_info->channel_map;
   q=clone_info->channel_map;
   if ((cache_info->columns == clone_info->columns) &&
@@ -1237,7 +1239,7 @@ static inline void RelinquishPixelCachePixels(CacheInfo *cache_info)
     }
     case DistributedCache:
     {
-      RelinquishDistributePixelCache(cache_info->distribute_cache_info);
+      (void) RelinquishDistributePixelCache(cache_info->distribute_cache_info);
       break;
     }
     default:
@@ -3861,15 +3863,13 @@ static MagickBooleanType OpenPixelCache(Image *image,const MapMode mode,
                 {
                   (void) FormatMagickSize(cache_info->length,MagickFalse,
                     format);
-/*
                   (void) FormatLocaleString(message,MaxTextExtent,
                     "open %s (%d[%d], distribute, %.20gx%.20gx%.20g %s)",
-                    cache_info->distribute_cache_info->hostname,
-                    cache_info->distribute_cache_info->port,
-                    cache_info->distribute_cache_info->file,(double)
-                    cache_info->columns,(double) cache_info->rows,(double)
-                    cache_info->number_channels,format);
-*/
+                    GetDistributeCacheHostname(cache_info->distribute_cache_info),
+                    GetDistributeCachePort(cache_info->distribute_cache_info),
+                    GetDistributeCacheFile(cache_info->distribute_cache_info),
+                    (double) cache_info->columns,(double) cache_info->rows,
+                    (double) cache_info->number_channels,format);
                   (void) LogMagickEvent(CacheEvent,GetMagickModule(),"%s",
                     message);
                 }
@@ -4472,8 +4472,23 @@ static MagickBooleanType ReadPixelCacheMetacontent(CacheInfo *cache_info,
     }
     case DistributedCache:
     {
-      puts("b");
-      abort();
+      MagickBooleanType
+        status;
+
+      /*
+        Read metacontent from distributed cache.
+      */
+      LockSemaphoreInfo(cache_info->file_semaphore);
+      status=ReadDistributePixelCacheMetacontent(
+        cache_info->distribute_cache_info,&nexus_info->region,length,
+        (unsigned char *) nexus_info->pixels);
+      UnlockSemaphoreInfo(cache_info->file_semaphore);
+      if (status == MagickFalse)
+        {
+          ThrowFileException(exception,CacheError,"UnableToReadPixelCache",
+            GetDistributeCacheHostname(cache_info->distribute_cache_info));
+          return(MagickFalse);
+        }
       break;
     }
     default:
@@ -4616,18 +4631,16 @@ static MagickBooleanType ReadPixelCachePixels(CacheInfo *cache_info,
         status;
 
       /*
-        Read pixels to distributed cache.
+        Read pixels from distributed cache.
       */
       LockSemaphoreInfo(cache_info->file_semaphore);
-      status=ReadDistributePixelCache(cache_info->distribute_cache_info,
-        &nexus_info->region,length,nexus_info->pixels);
+      status=ReadDistributePixelCachePixels(cache_info->distribute_cache_info,
+        &nexus_info->region,length,(unsigned char *) nexus_info->pixels);
       UnlockSemaphoreInfo(cache_info->file_semaphore);
       if (status == MagickFalse)
         {
-/*
-          ThrowFileException(exception,CacheError,"UnableToWritePixelCache",
-            cache_info->distribute_cache_info->hostname);
-*/
+          ThrowFileException(exception,CacheError,"UnableToReadPixelCache",
+            GetDistributeCacheHostname(cache_info->distribute_cache_info));
           return(MagickFalse);
         }
       break;
@@ -5394,8 +5407,23 @@ static MagickBooleanType WritePixelCacheMetacontent(CacheInfo *cache_info,
     }
     case DistributedCache:
     {
-      puts("e");
-      abort();
+      MagickBooleanType
+        status;
+
+      /*
+        Write metacontent to distributed cache.
+      */
+      LockSemaphoreInfo(cache_info->file_semaphore);
+      status=WriteDistributePixelCacheMetacontent(
+        cache_info->distribute_cache_info,&nexus_info->region,length,
+        (const unsigned char *) nexus_info->metacontent);
+      UnlockSemaphoreInfo(cache_info->file_semaphore);
+      if (status == MagickFalse)
+        {
+          ThrowFileException(exception,CacheError,"UnableToWritePixelCache",
+            GetDistributeCacheHostname(cache_info->distribute_cache_info));
+          return(MagickFalse);
+        }
       break;
     }
     default:
@@ -5542,15 +5570,13 @@ static MagickBooleanType WritePixelCachePixels(CacheInfo *cache_info,
         Write pixels to distributed cache.
       */
       LockSemaphoreInfo(cache_info->file_semaphore);
-      status=WriteDistributePixelCache(cache_info->distribute_cache_info,
-        &nexus_info->region,length,nexus_info->pixels);
+      status=WriteDistributePixelCachePixels(cache_info->distribute_cache_info,
+        &nexus_info->region,length,(const unsigned char *) nexus_info->pixels);
       UnlockSemaphoreInfo(cache_info->file_semaphore);
       if (status == MagickFalse)
         {
-/*
           ThrowFileException(exception,CacheError,"UnableToWritePixelCache",
-            cache_info->distribute_cache_info->hostname);
-*/
+            GetDistributeCacheHostname(cache_info->distribute_cache_info));
           return(MagickFalse);
         }
       break;

diff --git a/MagickCore/distribute-cache-private.h b/MagickCore/distribute-cache-private.h
index d86e74e96e5c91119ea1431a71528f738464ac4a..0f9e1dc3fa617db021354ad4c6c7b74eb7d3ad6d 100644 (file)
--- a/MagickCore/distribute-cache-private.h
+++ b/MagickCore/distribute-cache-private.h
@@ -43,18 +43,27 @@ typedef struct _DistributeCacheInfo
     signature;
 } DistributeCacheInfo;
 
+extern MagickPrivate const char
+  *GetDistributeCacheHostname(const DistributeCacheInfo *);
+
 extern MagickPrivate DistributeCacheInfo
   *AcquireDistributeCacheInfo(ExceptionInfo *),
   *DestroyDistributeCacheInfo(DistributeCacheInfo *);
 
+extern MagickPrivate int
+  GetDistributeCacheFile(const DistributeCacheInfo *),
+  GetDistributeCachePort(const DistributeCacheInfo *);
+
 extern MagickPrivate MagickBooleanType
   OpenDistributePixelCache(DistributeCacheInfo *,Image *),
-  ReadDistributePixelCache(DistributeCacheInfo *,const RectangleInfo *,
-    const MagickSizeType,Quantum *),
-  WriteDistributePixelCache(DistributeCacheInfo *,const RectangleInfo *,
-    const MagickSizeType,const Quantum *);
-
-extern MagickPrivate void
-  RelinquishDistributePixelCache(DistributeCacheInfo *);
+  ReadDistributePixelCacheMetacontent(DistributeCacheInfo *,
+    const RectangleInfo *,const MagickSizeType,unsigned char *),
+  ReadDistributePixelCachePixels(DistributeCacheInfo *,const RectangleInfo *,
+    const MagickSizeType,unsigned char *),
+  RelinquishDistributePixelCache(DistributeCacheInfo *),
+  WriteDistributePixelCacheMetacontent(DistributeCacheInfo *,
+    const RectangleInfo *,const MagickSizeType,const unsigned char *),
+  WriteDistributePixelCachePixels(DistributeCacheInfo *,const RectangleInfo *,
+    const MagickSizeType,const unsigned char *);
 
 #endif

diff --git a/MagickCore/distribute-cache.c b/MagickCore/distribute-cache.c
index 3683822384beaa8d0ba405421955c24ff1ffe0d7..dfb4061e9d680501e94d50c08fe29c3e0843a42e 100644 (file)
--- a/MagickCore/distribute-cache.c
+++ b/MagickCore/distribute-cache.c
@@ -391,21 +391,33 @@ static MagickBooleanType CreateDistributeCache(SplayTreeInfo *image_registry,
   MagickBooleanType
     status;
 
+  register unsigned char
+    *p;
+
+  size_t
+    length;
+
   ssize_t
     count;
 
+  unsigned char
+    buffer[MaxTextExtent];
+
   exception=AcquireExceptionInfo();
   image=AcquireImage((ImageInfo *) NULL,exception);
   exception=DestroyExceptionInfo(exception);
-  count=read(file,&image->columns,sizeof(image->columns));
-  if (count != (ssize_t) sizeof(image->columns))
-    return(MagickFalse);
-  count=read(file,&image->rows,sizeof(image->rows));
-  if (count != (ssize_t) sizeof(image->rows))
-    return(MagickFalse);
-  count=read(file,&image->number_channels,sizeof(image->number_channels));
-  if (count != (ssize_t) sizeof(image->number_channels))
+  length=sizeof(image->columns)+sizeof(image->rows)+
+    sizeof(image->number_channels);
+  count=read(file,buffer,length);
+  if (count != (ssize_t) length)
     return(MagickFalse);
+  p=buffer;
+  (void) memcpy(&image->columns,p,sizeof(image->columns));
+  p+=sizeof(image->columns);
+  (void) memcpy(&image->rows,p,sizeof(image->rows));
+  p+=sizeof(image->rows);
+  (void) memcpy(&image->number_channels,p,sizeof(image->number_channels));
+  p+=sizeof(image->number_channels);
   status=AddValueToSplayTree(image_registry,(const void *) session_key,image);
   return(status);
 }
@@ -413,15 +425,11 @@ static MagickBooleanType CreateDistributeCache(SplayTreeInfo *image_registry,
 static MagickBooleanType DestroyDistributeCache(SplayTreeInfo *image_registry,
   int file,const MagickSizeType session_key)
 {
-  char
-    key[MaxTextExtent];
-
-  (void) FormatLocaleString(key,MaxTextExtent,"%.20g",(double) session_key);
-  return(DeleteImageRegistry(key));
+  return(DeleteNodeFromSplayTree(image_registry,(const void *) session_key));
 }
 
-static MagickBooleanType ReadDistributeCache(SplayTreeInfo *image_registry,
-  int file,const MagickSizeType session_key)
+static MagickBooleanType ReadDistributeCacheMetacontent(
+  SplayTreeInfo *image_registry,int file,const MagickSizeType session_key)
 {
   ExceptionInfo
     *exception;
@@ -435,31 +443,97 @@ static MagickBooleanType ReadDistributeCache(SplayTreeInfo *image_registry,
   register const Quantum
     *p;
 
+  register unsigned char
+    *q;
+
   size_t
     length;
 
   ssize_t
     count;
 
+  unsigned char
+    buffer[MaxTextExtent];
+
   image=(Image *) GetValueFromSplayTree(image_registry,(const void *)
     session_key);
   if (image == (Image *) NULL)
     return(MagickFalse);
-  count=read(file,&region.width,sizeof(region.width));
-  if (count != (ssize_t) sizeof(region.width))
+  length=sizeof(region.width)+sizeof(region.height)+sizeof(region.x)+
+    sizeof(region.y)+sizeof(length);
+  count=read(file,buffer,length);
+  if (count != (ssize_t) length)
     return(MagickFalse);
-  count=read(file,&region.height,sizeof(region.height));
-  if (count != (ssize_t) sizeof(region.height))
+  q=buffer;
+  (void) memcpy(&region.width,q,sizeof(region.width));
+  q+=sizeof(region.width);
+  (void) memcpy(&region.height,q,sizeof(region.height));
+  q+=sizeof(region.width);
+  (void) memcpy(&region.x,q,sizeof(region.x));
+  q+=sizeof(region.width);
+  (void) memcpy(&region.y,q,sizeof(region.y));
+  q+=sizeof(region.width);
+  (void) memcpy(&length,q,sizeof(length));
+  q+=sizeof(length);
+  exception=AcquireExceptionInfo();
+  p=GetVirtualPixels(image,region.x,region.y,region.width,region.height,
+    exception);
+  exception=DestroyExceptionInfo(exception);
+  if (p == (const Quantum *) NULL)
     return(MagickFalse);
-  count=read(file,&region.x,sizeof(region.x));
-  if (count != (ssize_t) sizeof(region.x))
+  count=write(file,p,length);
+  if (count != (ssize_t) length)
     return(MagickFalse);
-  count=read(file,&region.y,sizeof(region.y));
-  if (count != (ssize_t) sizeof(region.y))
+  return(MagickTrue);
+}
+
+static MagickBooleanType ReadDistributeCachePixels(
+  SplayTreeInfo *image_registry,int file,const MagickSizeType session_key)
+{
+  ExceptionInfo
+    *exception;
+
+  Image
+    *image;
+
+  RectangleInfo
+    region;
+
+  register const Quantum
+    *p;
+
+  register unsigned char
+    *q;
+
+  size_t
+    length;
+
+  ssize_t
+    count;
+
+  unsigned char
+    buffer[MaxTextExtent];
+
+  image=(Image *) GetValueFromSplayTree(image_registry,(const void *)
+    session_key);
+  if (image == (Image *) NULL)
     return(MagickFalse);
-  count=read(file,&length,sizeof(length));
-  if (count != (ssize_t) sizeof(length))
+  length=sizeof(region.width)+sizeof(region.height)+sizeof(region.x)+
+    sizeof(region.y)+sizeof(length);
+  count=read(file,buffer,length);
+  if (count != (ssize_t) length)
     return(MagickFalse);
+  q=buffer;
+  (void) memcpy(&region.width,q,sizeof(region.width));
+  q+=sizeof(region.width);
+  (void) memcpy(&region.height,q,sizeof(region.height));
+  q+=sizeof(region.width);
+  (void) memcpy(&region.x,q,sizeof(region.x));
+  q+=sizeof(region.width);
+  (void) memcpy(&region.y,q,sizeof(region.y));
+  q+=sizeof(region.width);
+  (void) memcpy(&length,q,sizeof(length));
+  q+=sizeof(length);
   exception=AcquireExceptionInfo();
   p=GetVirtualPixels(image,region.x,region.y,region.width,region.height,
     exception);
@@ -472,8 +546,8 @@ static MagickBooleanType ReadDistributeCache(SplayTreeInfo *image_registry,
   return(MagickTrue);
 }
 
-static MagickBooleanType WriteDistributeCache(SplayTreeInfo *image_registry,
-  int file,const MagickSizeType session_key)
+static MagickBooleanType WriteDistributeCacheMetacontent(
+  SplayTreeInfo *image_registry,int file,const MagickSizeType session_key)
 {
   ExceptionInfo
     *exception;
@@ -488,6 +562,9 @@ static MagickBooleanType WriteDistributeCache(SplayTreeInfo *image_registry,
     region;
 
   register Quantum
+    *q;
+
+  register unsigned char
     *p;
 
   size_t
@@ -496,32 +573,99 @@ static MagickBooleanType WriteDistributeCache(SplayTreeInfo *image_registry,
   ssize_t
     count;
 
+  unsigned char
+    buffer[MaxTextExtent];
+
   image=(Image *) GetValueFromSplayTree(image_registry,(const void *)
     session_key);
   if (image == (Image *) NULL)
     return(MagickFalse);
-  count=read(file,&region.width,sizeof(region.width));
-  if (count != (ssize_t) sizeof(region.width))
+  length=sizeof(region.width)+sizeof(region.height)+sizeof(region.x)+
+    sizeof(region.y)+sizeof(length);
+  count=read(file,buffer,length);
+  if (count != (ssize_t) length)
     return(MagickFalse);
-  count=read(file,&region.height,sizeof(region.height));
-  if (count != (ssize_t) sizeof(region.height))
+  p=buffer;
+  (void) memcpy(&region.width,p,sizeof(region.width));
+  p+=sizeof(region.width);
+  (void) memcpy(&region.height,p,sizeof(region.height));
+  p+=sizeof(region.width);
+  (void) memcpy(&region.x,p,sizeof(region.x));
+  p+=sizeof(region.width);
+  (void) memcpy(&region.y,p,sizeof(region.y));
+  p+=sizeof(region.width);
+  (void) memcpy(&length,p,sizeof(length));
+  p+=sizeof(length);
+  exception=AcquireExceptionInfo();
+  q=GetAuthenticPixels(image,region.x,region.y,region.width,region.height,
+    exception);
+  exception=DestroyExceptionInfo(exception);
+  if (q == (Quantum *) NULL)
     return(MagickFalse);
-  count=read(file,&region.x,sizeof(region.x));
-  if (count != (ssize_t) sizeof(region.x))
+  count=read(file,q,length);
+  if (count != (ssize_t) length)
     return(MagickFalse);
-  count=read(file,&region.y,sizeof(region.y));
-  if (count != (ssize_t) sizeof(region.y))
+  status=SyncAuthenticPixels(image,exception);
+  return(status);
+}
+
+static MagickBooleanType WriteDistributeCachePixels(
+  SplayTreeInfo *image_registry,int file,const MagickSizeType session_key)
+{
+  ExceptionInfo
+    *exception;
+
+  Image
+    *image;
+
+  MagickBooleanType
+    status;
+
+  RectangleInfo
+    region;
+
+  register Quantum
+    *q;
+
+  register unsigned char
+    *p;
+
+  size_t
+    length;
+
+  ssize_t
+    count;
+
+  unsigned char
+    buffer[MaxTextExtent];
+
+  image=(Image *) GetValueFromSplayTree(image_registry,(const void *)
+    session_key);
+  if (image == (Image *) NULL)
     return(MagickFalse);
-  count=read(file,&length,sizeof(length));
-  if (count != (ssize_t) sizeof(length))
+  length=sizeof(region.width)+sizeof(region.height)+sizeof(region.x)+
+    sizeof(region.y)+sizeof(length);
+  count=read(file,buffer,length);
+  if (count != (ssize_t) length)
     return(MagickFalse);
+  p=buffer;
+  (void) memcpy(&region.width,p,sizeof(region.width));
+  p+=sizeof(region.width);
+  (void) memcpy(&region.height,p,sizeof(region.height));
+  p+=sizeof(region.width);
+  (void) memcpy(&region.x,p,sizeof(region.x));
+  p+=sizeof(region.width);
+  (void) memcpy(&region.y,p,sizeof(region.y));
+  p+=sizeof(region.width);
+  (void) memcpy(&length,p,sizeof(length));
+  p+=sizeof(length);
   exception=AcquireExceptionInfo();
-  p=GetAuthenticPixels(image,region.x,region.y,region.width,region.height,
+  q=GetAuthenticPixels(image,region.x,region.y,region.width,region.height,
     exception);
   exception=DestroyExceptionInfo(exception);
-  if (p == (Quantum *) NULL)
+  if (q == (Quantum *) NULL)
     return(MagickFalse);
-  count=read(file,p,length);
+  count=read(file,q,length);
   if (count != (ssize_t) length)
     return(MagickFalse);
   status=SyncAuthenticPixels(image,exception);
@@ -596,12 +740,14 @@ static void *DistributePixelCacheClient(void *socket)
       }
       case 'r':
       {
-        status=ReadDistributeCache(image_registry,client_socket,session_key);
+        status=ReadDistributeCachePixels(image_registry,client_socket,
+          session_key);
         break;
       }
       case 'u':
       {
-        status=WriteDistributeCache(image_registry,client_socket,session_key);
+        status=WriteDistributeCachePixels(image_registry,client_socket,
+          session_key);
         break;
       }
       case 'd':
@@ -609,6 +755,18 @@ static void *DistributePixelCacheClient(void *socket)
         status=DestroyDistributeCache(image_registry,client_socket,session_key);
         break;
       }
+      case 'm':
+      {
+        status=ReadDistributeCacheMetacontent(image_registry,client_socket,
+          session_key);
+        break;
+      }
+      case 'M':
+      {
+        status=WriteDistributeCacheMetacontent(image_registry,client_socket,
+          session_key);
+        break;
+      }
       default:
         break;
     }
@@ -679,6 +837,102 @@ MagickExport void DistributePixelCacheServer(const size_t port,
 %                                                                             %
 %                                                                             %
 %                                                                             %
++   G e t D i s t r i b u t e C a c h e F i l e                               %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  GetDistributeCacheFile() returns the file associated with this
+%  DistributeCacheInfo structure.
+%
+%  The format of the GetDistributeCacheFile method is:
+%
+%      int GetDistributeCacheFile(
+%        const DistributeCacheInfo *distribute_cache_info)
+%
+%  A description of each parameter follows:
+%
+%    o distribute_cache_info: the distributed cache info.
+%
+*/
+MagickPrivate int GetDistributeCacheFile(
+  const DistributeCacheInfo *distribute_cache_info)
+{
+  assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
+  assert(distribute_cache_info->signature == MagickSignature);
+  return(distribute_cache_info->file);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
++   G e t D i s t r i b u t e C a c h e H o s t n a m e                       %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  GetDistributeCacheHostname() returns the hostname associated with this
+%  DistributeCacheInfo structure.
+%
+%  The format of the GetDistributeCacheHostname method is:
+%
+%      const char *GetDistributeCacheHostname(
+%        const DistributeCacheInfo *distribute_cache_info)
+%
+%  A description of each parameter follows:
+%
+%    o distribute_cache_info: the distributed cache info.
+%
+*/
+MagickPrivate const char *GetDistributeCacheHostname(
+  const DistributeCacheInfo *distribute_cache_info)
+{
+  assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
+  assert(distribute_cache_info->signature == MagickSignature);
+  return(distribute_cache_info->hostname);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
++   G e t D i s t r i b u t e C a c h e P o r t                               %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  GetDistributeCachePort() returns the port associated with this
+%  DistributeCacheInfo structure.
+%
+%  The format of the GetDistributeCachePort method is:
+%
+%      int GetDistributeCachePort(
+%        const DistributeCacheInfo *distribute_cache_info)
+%
+%  A description of each parameter follows:
+%
+%    o distribute_cache_info: the distributed cache info.
+%
+*/
+MagickPrivate int GetDistributeCachePort(
+  const DistributeCacheInfo *distribute_cache_info)
+{
+  assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
+  assert(distribute_cache_info->signature == MagickSignature);
+  return(distribute_cache_info->port);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
 %   O p e n D i s t r i b u t e P i x e l C a c h e                           %
 %                                                                             %
 %                                                                             %
@@ -702,43 +956,122 @@ MagickExport void DistributePixelCacheServer(const size_t port,
 MagickPrivate MagickBooleanType OpenDistributePixelCache(
   DistributeCacheInfo *distribute_cache_info,Image *image)
 {
-  int
-    file;
-
   MagickBooleanType
     status;
 
-  MagickSizeType
-    session_key;
+  register unsigned char
+    *p;
 
   ssize_t
     count;
 
+  unsigned char
+    buffer[MaxTextExtent];
+
   assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
   assert(distribute_cache_info->signature == MagickSignature);
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
-  file=distribute_cache_info->file;
-  session_key=distribute_cache_info->session_key;
-  count=write(file,"c",1);
-  if (count != 1)
-    return(MagickFalse);
-  count=write(file,&session_key,sizeof(session_key));
-  if (count != (ssize_t) sizeof(session_key))
+  p=buffer;
+  *p++='c';  /* create */
+  (void) memcpy(p,&distribute_cache_info->session_key,
+    sizeof(distribute_cache_info->session_key));
+  p+=sizeof(distribute_cache_info->session_key);
+  (void) memcpy(p,&image->columns,sizeof(image->columns));
+  p+=sizeof(image->columns);
+  (void) memcpy(p,&image->rows,sizeof(image->rows));
+  p+=sizeof(image->rows);
+  (void) memcpy(p,&image->number_channels,sizeof(image->number_channels));
+  p+=sizeof(image->number_channels);
+  count=write(distribute_cache_info->file,buffer,p-buffer);
+  if (count != (ssize_t) (p-buffer))
     return(MagickFalse);
-  count=write(file,&image->columns,sizeof(image->columns));
-  if (count != (ssize_t) sizeof(image->columns))
+  count=read(distribute_cache_info->file,&status,sizeof(status));
+  if (count != (ssize_t) sizeof(status))
     return(MagickFalse);
-  count=write(file,&image->rows,sizeof(image->rows));
-  if (count != (ssize_t) sizeof(image->rows))
+  return(MagickTrue);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   R e a d D i s t r i b u t e P i x e l C a c h e M e t a c o n t e n t     %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  ReadDistributePixelCacheMetacontents() reads metacontent from the specified
+%  region of the distributed pixel cache.
+%
+%  The format of the ReadDistributePixelCacheMetacontents method is:
+%
+%      MagickBooleanType *ReadDistributePixelCacheMetacontents(
+%        DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
+%        const MagickSizeType length,unsigned char *metacontent)
+%
+%  A description of each parameter follows:
+%
+%    o distribute_cache_info: the distributed cache info.
+%
+%    o image: the image.
+%
+%    o region: read the metacontent from this region of the image.
+%
+%    o length: write the metacontent to this region of the image.
+%
+%    o metacontent: read these metacontent from the pixel cache.
+%
+*/
+MagickPrivate MagickBooleanType ReadDistributePixelCacheMetacontent(
+  DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
+  const MagickSizeType length,unsigned char *metacontent)
+{
+  MagickBooleanType
+    status;
+
+  register unsigned char
+    *p;
+
+  ssize_t
+    count;
+
+  unsigned char
+    buffer[MaxTextExtent];
+
+  assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
+  assert(distribute_cache_info->signature == MagickSignature);
+  assert(region != (RectangleInfo *) NULL);
+  assert(metacontent != (unsigned char *) NULL);
+  assert(length == ((size_t) length));
+  p=buffer;
+  *p++='m';  /* read */
+  (void) memcpy(p,&distribute_cache_info->session_key,
+    sizeof(distribute_cache_info->session_key));
+  p+=sizeof(distribute_cache_info->session_key);
+  (void) memcpy(p,&region->width,sizeof(region->width));
+  p+=sizeof(region->width);
+  (void) memcpy(p,&region->height,sizeof(region->height));
+  p+=sizeof(region->height);
+  (void) memcpy(p,&region->x,sizeof(region->x));
+  p+=sizeof(region->x);
+  (void) memcpy(p,&region->y,sizeof(region->y));
+  p+=sizeof(region->y);
+  (void) memcpy(p,&length,sizeof(length));
+  p+=sizeof(length);
+  count=write(distribute_cache_info->file,buffer,p-buffer);
+  if (count != (ssize_t) (p-buffer))
     return(MagickFalse);
-  count=write(file,&image->number_channels,sizeof(image->number_channels));
-  if (count != (ssize_t) sizeof(image->number_channels))
+  count=read(distribute_cache_info->file,(unsigned char *) metacontent,(size_t)
+    length);
+  if (count != (ssize_t) length)
     return(MagickFalse);
-  count=read(file,&status,sizeof(status));
+  count=read(distribute_cache_info->file,&status,sizeof(status));
   if (count != (ssize_t) sizeof(status))
     return(MagickFalse);
-  return(MagickTrue);
+  return(status != 0 ? MagickTrue : MagickFalse);
 }
 \f
 /*
@@ -746,20 +1079,20 @@ MagickPrivate MagickBooleanType OpenDistributePixelCache(
 %                                                                             %
 %                                                                             %
 %                                                                             %
-%   R e a d D i s t r i b u t e P i x e l C a c h e                           %
+%   R e a d D i s t r i b u t e P i x e l C a c h e P i x e l s               %
 %                                                                             %
 %                                                                             %
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  ReadDistributePixelCache() reads pixels from the specified region of the
-%  distributed pixel cache.
+%  ReadDistributePixelCachePixels() reads pixels from the specified region of
+%  the distributed pixel cache.
 %
-%  The format of the ReadDistributePixelCache method is:
+%  The format of the ReadDistributePixelCachePixels method is:
 %
-%      MagickBooleanType *ReadDistributePixelCache(
+%      MagickBooleanType *ReadDistributePixelCachePixels(
 %        DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
-%        const MagickSizeType length,Quantum *pixels)
+%        const MagickSizeType length,unsigned char *pixels)
 %
 %  A description of each parameter follows:
 %
@@ -774,55 +1107,50 @@ MagickPrivate MagickBooleanType OpenDistributePixelCache(
 %    o pixels: read these pixels from the pixel cache.
 %
 */
-MagickPrivate MagickBooleanType ReadDistributePixelCache(
+MagickPrivate MagickBooleanType ReadDistributePixelCachePixels(
   DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
-  const MagickSizeType length,Quantum *pixels)
+  const MagickSizeType length,unsigned char *pixels)
 {
-  int
-    file;
-
   MagickBooleanType
     status;
 
-  MagickSizeType
-    session_key;
+  register unsigned char
+    *p;
 
   ssize_t
     count;
 
+  unsigned char
+    buffer[MaxTextExtent];
+
   assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
   assert(distribute_cache_info->signature == MagickSignature);
   assert(region != (RectangleInfo *) NULL);
-  assert(pixels != (Quantum *) NULL);
-  file=distribute_cache_info->file;
-  session_key=distribute_cache_info->session_key;
-  count=write(file,"r",1);
-  if (count != 1)
-    return(MagickFalse);
-  count=write(file,&session_key,sizeof(session_key));
-  if (count != (ssize_t) sizeof(session_key))
-    return(MagickFalse);
-  count=write(file,&region->width,sizeof(region->width));
-  if (count != (ssize_t) sizeof(region->width))
+  assert(pixels != (unsigned char *) NULL);
+  assert(length == ((size_t) length));
+  p=buffer;
+  *p++='r';  /* read */
+  (void) memcpy(p,&distribute_cache_info->session_key,
+    sizeof(distribute_cache_info->session_key));
+  p+=sizeof(distribute_cache_info->session_key);
+  (void) memcpy(p,&region->width,sizeof(region->width));
+  p+=sizeof(region->width);
+  (void) memcpy(p,&region->height,sizeof(region->height));
+  p+=sizeof(region->height);
+  (void) memcpy(p,&region->x,sizeof(region->x));
+  p+=sizeof(region->x);
+  (void) memcpy(p,&region->y,sizeof(region->y));
+  p+=sizeof(region->y);
+  (void) memcpy(p,&length,sizeof(length));
+  p+=sizeof(length);
+  count=write(distribute_cache_info->file,buffer,p-buffer);
+  if (count != (ssize_t) (p-buffer))
     return(MagickFalse);
-  count=write(file,&region->height,sizeof(region->height));
-  if (count != (ssize_t) sizeof(region->height))
-    return(MagickFalse);
-  count=write(file,&region->x,sizeof(region->x));
-  if (count != (ssize_t) sizeof(region->x))
-    return(MagickFalse);
-  count=write(file,&region->y,sizeof(region->y));
-  if (count != (ssize_t) sizeof(region->y))
-    return(MagickFalse);
-  if (length != ((size_t) length))
-    return(MagickFalse);
-  count=write(file,&length,sizeof(length));
-  if (count != (ssize_t) sizeof(length))
-    return(MagickFalse);
-  count=read(file,(unsigned char *) pixels,(size_t) length);
+  count=read(distribute_cache_info->file,(unsigned char *) pixels,(size_t)
+    length);
   if (count != (ssize_t) length)
     return(MagickFalse);
-  count=read(file,&status,sizeof(status));
+  count=read(distribute_cache_info->file,&status,sizeof(status));
   if (count != (ssize_t) sizeof(status))
     return(MagickFalse);
   return(status != 0 ? MagickTrue : MagickFalse);
@@ -844,7 +1172,7 @@ MagickPrivate MagickBooleanType ReadDistributePixelCache(
 %
 %  The format of the RelinquishDistributePixelCache method is:
 %
-%      void RelinquishDistributePixelCache(
+%      MagickBooleanType RelinquishDistributePixelCache(
 %        DistributeCacheInfo *distribute_cache_info)
 %
 %  A description of each parameter follows:
@@ -852,21 +1180,29 @@ MagickPrivate MagickBooleanType ReadDistributePixelCache(
 %    o distribute_cache_info: the distributed cache info.
 %
 */
-MagickPrivate void RelinquishDistributePixelCache(
+MagickPrivate MagickBooleanType RelinquishDistributePixelCache(
   DistributeCacheInfo *distribute_cache_info)
 {
-  int
-    file;
+  register unsigned char
+    *p;
 
-  MagickSizeType
-    session_key;
+  ssize_t
+    count;
+
+  unsigned char
+    buffer[MaxTextExtent];
 
   assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
   assert(distribute_cache_info->signature == MagickSignature);
-  file=distribute_cache_info->file;
-  session_key=distribute_cache_info->session_key;
-  (void) write(file,"c",1);
-  (void) write(file,&session_key,sizeof(session_key));
+  p=buffer;
+  *p++='d';  /* delete */
+  (void) memcpy(p,&distribute_cache_info->session_key,
+    sizeof(distribute_cache_info->session_key));
+  p+=sizeof(distribute_cache_info->session_key);
+  count=write(distribute_cache_info->file,buffer,p-buffer);
+  if (count != (ssize_t) (p-buffer))
+    return(MagickFalse);
+  return(MagickTrue);
 }
 \f
 /*
@@ -874,21 +1210,21 @@ MagickPrivate void RelinquishDistributePixelCache(
 %                                                                             %
 %                                                                             %
 %                                                                             %
-%   W r i t e D i s t r i b u t e P i x e l C a c h e                         %
+%   W r i t e D i s t r i b u t e P i x e l C a c h e M e t a c o n t e n t   %
 %                                                                             %
 %                                                                             %
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  WriteDistributePixelCache() writes image pixels to the specified region of
-%  the distributed pixel cache.
+%  WriteDistributePixelCacheMetacontents() writes image metacontent to the
+%  specified region of the distributed pixel cache.
 %
 %
-%  The format of the WriteDistributePixelCache method is:
+%  The format of the WriteDistributePixelCacheMetacontents method is:
 %
-%      MagickBooleanType *WriteDistributePixelCache(
+%      MagickBooleanType *WriteDistributePixelCacheMetacontents(
 %        DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
-%        const MagickSizeType length,const Quantum *pixels)
+%        const MagickSizeType length,const unsigned char *metacontent)
 %
 %  A description of each parameter follows:
 %
@@ -896,62 +1232,140 @@ MagickPrivate void RelinquishDistributePixelCache(
 %
 %    o image: the image.
 %
-%    o region: write the pixels to this region of the image.
+%    o region: write the metacontent to this region of the image.
 %
-%    o length: write the pixels to this region of the image.
+%    o length: write the metacontent to this region of the image.
 %
-%    o pixels: write these pixels to the pixel cache.
+%    o metacontent: write these metacontent to the pixel cache.
 %
 */
-MagickPrivate MagickBooleanType WriteDistributePixelCache(
+MagickPrivate MagickBooleanType WriteDistributePixelCacheMetacontent(
   DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
-  const MagickSizeType length,const Quantum *pixels)
+  const MagickSizeType length,const unsigned char *metacontent)
 {
-  int
-    file;
-
   MagickBooleanType
     status;
 
-  MagickSizeType
-    session_key;
+  register unsigned char
+    *p;
 
   ssize_t
     count;
 
+  unsigned char
+    buffer[MaxTextExtent];
+
   assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
   assert(distribute_cache_info->signature == MagickSignature);
   assert(region != (RectangleInfo *) NULL);
-  assert(pixels != (Quantum *) NULL);
-  file=distribute_cache_info->file;
-  session_key=distribute_cache_info->session_key;
-  count=write(file,"u",1);
-  if (count != 1)
-    return(MagickFalse);
-  count=write(file,&session_key,sizeof(session_key));
-  if (count != (ssize_t) sizeof(session_key))
-    return(MagickFalse);
-  count=write(file,&region->width,sizeof(region->width));
-  if (count != (ssize_t) sizeof(region->width))
-    return(MagickFalse);
-  count=write(file,&region->height,sizeof(region->height));
-  if (count != (ssize_t) sizeof(region->height))
-    return(MagickFalse);
-  count=write(file,&region->x,sizeof(region->x));
-  if (count != (ssize_t) sizeof(region->x))
+  assert(metacontent != (unsigned char *) NULL);
+  assert(length == ((size_t) length));
+  p=buffer;
+  *p++='M';  /* update */
+  (void) memcpy(p,&distribute_cache_info->session_key,
+    sizeof(distribute_cache_info->session_key));
+  p+=sizeof(distribute_cache_info->session_key);
+  (void) memcpy(p,&region->width,sizeof(region->width));
+  p+=sizeof(region->width);
+  (void) memcpy(p,&region->height,sizeof(region->height));
+  p+=sizeof(region->height);
+  (void) memcpy(p,&region->x,sizeof(region->x));
+  p+=sizeof(region->x);
+  (void) memcpy(p,&region->y,sizeof(region->y));
+  p+=sizeof(region->y);
+  (void) memcpy(p,&length,sizeof(length));
+  p+=sizeof(length);
+  count=write(distribute_cache_info->file,buffer,p-buffer);
+  if (count != (ssize_t) (p-buffer))
     return(MagickFalse);
-  count=write(file,&region->y,sizeof(region->y));
-  if (count != (ssize_t) sizeof(region->y))
+  count=write(distribute_cache_info->file,(unsigned char *) metacontent,(size_t)
+    length);
+  if (count != (ssize_t) length)
     return(MagickFalse);
-  if (length != ((size_t) length))
+  count=read(distribute_cache_info->file,&status,sizeof(status));
+  if (count != (ssize_t) sizeof(status))
     return(MagickFalse);
-  count=write(file,&length,sizeof(length));
-  if (count != (ssize_t) sizeof(length))
+  return(status != 0 ? MagickTrue : MagickFalse);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   W r i t e D i s t r i b u t e P i x e l C a c h e P i x e l s             %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  WriteDistributePixelCachePixels() writes image pixels to the specified
+%  region of the distributed pixel cache.
+%
+%
+%  The format of the WriteDistributePixelCachePixels method is:
+%
+%      MagickBooleanType *WriteDistributePixelCachePixels(
+%        DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
+%        const MagickSizeType length,const unsigned char *pixels)
+%
+%  A description of each parameter follows:
+%
+%    o distribute_cache_info: the distributed cache info.
+%
+%    o image: the image.
+%
+%    o region: write the pixels to this region of the image.
+%
+%    o length: write the pixels to this region of the image.
+%
+%    o pixels: write these pixels to the pixel cache.
+%
+*/
+MagickPrivate MagickBooleanType WriteDistributePixelCachePixels(
+  DistributeCacheInfo *distribute_cache_info,const RectangleInfo *region,
+  const MagickSizeType length,const unsigned char *pixels)
+{
+  MagickBooleanType
+    status;
+
+  register unsigned char
+    *p;
+
+  ssize_t
+    count;
+
+  unsigned char
+    buffer[MaxTextExtent];
+
+  assert(distribute_cache_info != (DistributeCacheInfo *) NULL);
+  assert(distribute_cache_info->signature == MagickSignature);
+  assert(region != (RectangleInfo *) NULL);
+  assert(pixels != (const unsigned char *) NULL);
+  assert(length == ((size_t) length));
+  p=buffer;
+  *p++='u';  /* update */
+  (void) memcpy(p,&distribute_cache_info->session_key,
+    sizeof(distribute_cache_info->session_key));
+  p+=sizeof(distribute_cache_info->session_key);
+  (void) memcpy(p,&region->width,sizeof(region->width));
+  p+=sizeof(region->width);
+  (void) memcpy(p,&region->height,sizeof(region->height));
+  p+=sizeof(region->height);
+  (void) memcpy(p,&region->x,sizeof(region->x));
+  p+=sizeof(region->x);
+  (void) memcpy(p,&region->y,sizeof(region->y));
+  p+=sizeof(region->y);
+  (void) memcpy(p,&length,sizeof(length));
+  p+=sizeof(length);
+  count=write(distribute_cache_info->file,buffer,p-buffer);
+  if (count != (ssize_t) (p-buffer))
     return(MagickFalse);
-  count=write(file,(unsigned char *) pixels,(size_t) length);
+  count=write(distribute_cache_info->file,(unsigned char *) pixels,(size_t)
+    length);
   if (count != (ssize_t) length)
     return(MagickFalse);
-  count=read(file,&status,sizeof(status));
+  count=read(distribute_cache_info->file,&status,sizeof(status));
   if (count != (ssize_t) sizeof(status))
     return(MagickFalse);
   return(status != 0 ? MagickTrue : MagickFalse);

diff --git a/MagickCore/method-attribute.h b/MagickCore/method-attribute.h
index 43da2dc1824b19a3fc506510b89db5fba2896b95..23d83d9222b2218761a7e66d30b39c4b594055c8 100644 (file)
--- a/MagickCore/method-attribute.h
+++ b/MagickCore/method-attribute.h
@@ -105,7 +105,7 @@ extern "C" {
 
 #define MagickSignature  0xabacadabUL
 #if !defined(MaxTextExtent)
-# define MaxTextExtent  4096
+# define MaxTextExtent  4096  /* always >= 4096 */
 #endif
 
 #if defined(MAGICKCORE_HAVE___ATTRIBUTE__)