00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #ifndef MAGICKCORE_CACHE_PRIVATE_H
00019 #define MAGICKCORE_CACHE_PRIVATE_H
00020
00021 #include <time.h>
00022 #include "magick/cache.h"
00023 #include "magick/distribute-cache.h"
00024 #include "magick/opencl-private.h"
00025 #include "magick/random_.h"
00026 #include "magick/thread-private.h"
00027 #include "magick/semaphore.h"
00028
00029 #if defined(__cplusplus) || defined(c_plusplus)
00030 extern "C" {
00031 #endif
00032
00033 typedef void
00034 *Cache;
00035
00036 typedef const IndexPacket
00037 *(*GetVirtualIndexesFromHandler)(const Image *);
00038
00039 typedef IndexPacket
00040 *(*GetAuthenticIndexesFromHandler)(const Image *);
00041
00042 typedef MagickBooleanType
00043 (*GetOneAuthenticPixelFromHandler)(Image *,const ssize_t,const ssize_t,
00044 PixelPacket *,ExceptionInfo *),
00045 (*GetOneVirtualPixelFromHandler)(const Image *,const VirtualPixelMethod,
00046 const ssize_t,const ssize_t,PixelPacket *,ExceptionInfo *),
00047 (*SyncAuthenticPixelsHandler)(Image *,ExceptionInfo *);
00048
00049 typedef const PixelPacket
00050 *(*GetVirtualPixelHandler)(const Image *,const VirtualPixelMethod,
00051 const ssize_t,const ssize_t,const size_t,const size_t,ExceptionInfo *),
00052 *(*GetVirtualPixelsHandler)(const Image *);
00053
00054 typedef PixelPacket
00055 *(*GetAuthenticPixelsHandler)(Image *,const ssize_t,const ssize_t,
00056 const size_t,const size_t,ExceptionInfo *);
00057
00058 typedef PixelPacket
00059 *(*GetAuthenticPixelsFromHandler)(const Image *);
00060
00061 typedef PixelPacket
00062 *(*QueueAuthenticPixelsHandler)(Image *,const ssize_t,const ssize_t,
00063 const size_t,const size_t,ExceptionInfo *);
00064
00065 typedef void
00066 (*DestroyPixelHandler)(Image *);
00067
00068 typedef struct _CacheMethods
00069 {
00070 GetVirtualPixelHandler
00071 get_virtual_pixel_handler;
00072
00073 GetVirtualPixelsHandler
00074 get_virtual_pixels_handler;
00075
00076 GetVirtualIndexesFromHandler
00077 get_virtual_indexes_from_handler;
00078
00079 GetOneVirtualPixelFromHandler
00080 get_one_virtual_pixel_from_handler;
00081
00082 GetAuthenticPixelsHandler
00083 get_authentic_pixels_handler;
00084
00085 GetAuthenticIndexesFromHandler
00086 get_authentic_indexes_from_handler;
00087
00088 GetOneAuthenticPixelFromHandler
00089 get_one_authentic_pixel_from_handler;
00090
00091 GetAuthenticPixelsFromHandler
00092 get_authentic_pixels_from_handler;
00093
00094 QueueAuthenticPixelsHandler
00095 queue_authentic_pixels_handler;
00096
00097 SyncAuthenticPixelsHandler
00098 sync_authentic_pixels_handler;
00099
00100 DestroyPixelHandler
00101 destroy_pixel_handler;
00102 } CacheMethods;
00103
00104 typedef struct _NexusInfo
00105 {
00106 MagickBooleanType
00107 mapped;
00108
00109 RectangleInfo
00110 region;
00111
00112 MagickSizeType
00113 length;
00114
00115 PixelPacket
00116 *cache,
00117 *pixels;
00118
00119 MagickBooleanType
00120 authentic_pixel_cache;
00121
00122 IndexPacket
00123 *indexes;
00124
00125 size_t
00126 signature;
00127
00128 struct _NexusInfo
00129 *virtual_nexus;
00130 } NexusInfo;
00131
00132 typedef struct _OpenCLCacheInfo
00133 {
00134 cl_event
00135 *events;
00136
00137 cl_mem
00138 buffer;
00139
00140 cl_uint
00141 event_count;
00142
00143 MagickSizeType
00144 length;
00145
00146 PixelPacket
00147 *pixels;
00148
00149 SemaphoreInfo
00150 *events_semaphore;
00151 } OpenCLCacheInfo;
00152
00153 typedef struct _CacheInfo
00154 {
00155 ClassType
00156 storage_class;
00157
00158 ColorspaceType
00159 colorspace;
00160
00161 size_t
00162 channels;
00163
00164 CacheType
00165 type;
00166
00167 MapMode
00168 mode,
00169 disk_mode;
00170
00171 MagickBooleanType
00172 mapped;
00173
00174 size_t
00175 columns,
00176 rows;
00177
00178 MagickOffsetType
00179 offset;
00180
00181 MagickSizeType
00182 length;
00183
00184 VirtualPixelMethod
00185 virtual_pixel_method;
00186
00187 MagickPixelPacket
00188 virtual_pixel_color;
00189
00190 size_t
00191 number_threads;
00192
00193 NexusInfo
00194 **nexus_info;
00195
00196 PixelPacket
00197 *pixels;
00198
00199 IndexPacket
00200 *indexes;
00201
00202 MagickBooleanType
00203 active_index_channel;
00204
00205 int
00206 file;
00207
00208 char
00209 filename[MaxTextExtent],
00210 cache_filename[MaxTextExtent];
00211
00212 CacheMethods
00213 methods;
00214
00215 RandomInfo
00216 *random_info;
00217
00218 size_t
00219 number_connections;
00220
00221 void
00222 *server_info;
00223
00224 MagickBooleanType
00225 synchronize,
00226 debug;
00227
00228 MagickThreadType
00229 id;
00230
00231 ssize_t
00232 reference_count;
00233
00234 SemaphoreInfo
00235 *semaphore,
00236 *file_semaphore;
00237
00238 time_t
00239 timestamp;
00240
00241 size_t
00242 signature;
00243
00244 OpenCLCacheInfo
00245 *opencl;
00246
00247 MagickSizeType
00248 width_limit,
00249 height_limit;
00250 } CacheInfo;
00251
00252 extern MagickExport Cache
00253 AcquirePixelCache(const size_t),
00254 ClonePixelCache(const Cache),
00255 DestroyPixelCache(Cache),
00256 ReferencePixelCache(Cache);
00257
00258 extern MagickExport CacheType
00259 GetPixelCacheType(const Image *);
00260
00261 extern MagickExport ClassType
00262 GetPixelCacheStorageClass(const Cache);
00263
00264 extern MagickExport ColorspaceType
00265 GetPixelCacheColorspace(const Cache);
00266
00267 extern MagickExport const IndexPacket
00268 *GetVirtualIndexesFromNexus(const Cache,NexusInfo *);
00269
00270 extern MagickExport const PixelPacket
00271 *GetVirtualPixelCacheNexus(const Image *,const VirtualPixelMethod,
00272 const ssize_t,const ssize_t,const size_t,const size_t,NexusInfo *,
00273 ExceptionInfo *) magick_hot_spot,
00274 *GetVirtualPixelsNexus(const Cache,NexusInfo *);
00275
00276 extern MagickExport MagickBooleanType
00277 SyncAuthenticPixelCacheNexus(Image *,NexusInfo *magick_restrict,
00278 ExceptionInfo *) magick_hot_spot;
00279
00280 extern MagickExport MagickSizeType
00281 GetPixelCacheNexusExtent(const Cache,NexusInfo *);
00282
00283 extern MagickExport NexusInfo
00284 **AcquirePixelCacheNexus(const size_t),
00285 **DestroyPixelCacheNexus(NexusInfo **,const size_t);
00286
00287 extern MagickExport PixelPacket
00288 *GetAuthenticPixelCacheNexus(Image *,const ssize_t,const ssize_t,
00289 const size_t,const size_t,NexusInfo *,ExceptionInfo *) magick_hot_spot,
00290 *QueueAuthenticPixel(Image *,const ssize_t,const ssize_t,const size_t,
00291 const size_t,const MagickBooleanType,NexusInfo *,ExceptionInfo *),
00292 *QueueAuthenticPixelCacheNexus(Image *,const ssize_t,const ssize_t,
00293 const size_t,const size_t,const MagickBooleanType,NexusInfo *,
00294 ExceptionInfo *) magick_hot_spot;
00295
00296 extern MagickExport size_t
00297 GetPixelCacheChannels(const Cache);
00298
00299 extern MagickExport void
00300 ClonePixelCacheMethods(Cache,const Cache),
00301 GetPixelCacheTileSize(const Image *,size_t *,size_t *),
00302 GetPixelCacheMethods(CacheMethods *),
00303 SetPixelCacheMethods(Cache,CacheMethods *);
00304
00305 extern MagickPrivate void
00306 ResetPixelCacheEpoch(void);
00307
00308 extern MagickPrivate MagickBooleanType
00309 SyncImagePixelCache(Image *,ExceptionInfo *);
00310
00311 #if defined(MAGICKCORE_OPENCL_SUPPORT)
00312 extern MagickPrivate cl_event
00313 *GetOpenCLEvents(const Image *,cl_uint *);
00314
00315 extern MagickPrivate cl_mem
00316 GetAuthenticOpenCLBuffer(const Image *,ExceptionInfo *);
00317
00318 extern MagickPrivate void
00319 AddOpenCLEvent(const Image *,cl_event),
00320 SyncAuthenticOpenCLBuffer(const Image *);
00321 #endif
00322
00323 #if defined(__cplusplus) || defined(c_plusplus)
00324 }
00325 #endif
00326
00327 #endif