cache-private.h

Go to the documentation of this file.
00001 /*
00002   Copyright 1999-2019 ImageMagick Studio LLC, a non-profit organization
00003   dedicated to making software imaging solutions freely available.
00004   
00005   You may not use this file except in compliance with the License.  You may
00006   obtain a copy of the License at
00007   
00008     https://imagemagick.org/script/license.php
00009   
00010   Unless required by applicable law or agreed to in writing, software
00011   distributed under the License is distributed on an "AS IS" BASIS,
00012   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013   See the License for the specific language governing permissions and
00014   limitations under the License.
00015 
00016   MagickCore cache private methods.
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

Generated on 30 Sep 2019 for MagickCore by  doxygen 1.6.1