#if defined(_magickcore_inline) && !defined(inline)
# define inline _magickcore_inline
#endif
-#if defined(_magickcore_restrict) && !defined(restrict)
-# define restrict _magickcore_restrict
+#if !defined(magick_restrict)
+# if !defined(_magickcore_restrict)
+# define magick_restrict restrict
+# else
+# define magick_restrict _magickcore_restrict
+# endif
#endif
# if defined(__cplusplus) || defined(c_plusplus)
# undef inline
*filteredImage;
RandomInfo
- **restrict random_info;
+ **magick_restrict random_info;
size_t
global_work_size[1],
fill_color;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetCacheViewAuthenticPixels(annotate_view,0,y,annotate_image->columns,
1,exception);
bounding_box;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
id = GetOpenMPThreadId();
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
id = GetOpenMPThreadId();
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
*GetVirtualPixelsFromNexus(const Image *,const VirtualPixelMethod,
const ssize_t,const ssize_t,const size_t,const size_t,NexusInfo *,
ExceptionInfo *) magick_hot_spot,
- *GetVirtualPixelsNexus(const Cache,NexusInfo *restrict);
+ *GetVirtualPixelsNexus(const Cache,NexusInfo *magick_restrict);
extern MagickPrivate const void
*AcquirePixelCachePixels(const Image *,MagickSizeType *,ExceptionInfo *),
- *GetVirtualMetacontentFromNexus(const Cache,NexusInfo *restrict);
+ *GetVirtualMetacontentFromNexus(const Cache,NexusInfo *magick_restrict);
extern MagickPrivate MagickBooleanType
CacheComponentGenesis(void),
- SyncAuthenticPixelCacheNexus(Image *,NexusInfo *restrict,ExceptionInfo *)
- magick_hot_spot,
+ SyncAuthenticPixelCacheNexus(Image *,NexusInfo *magick_restrict,
+ ExceptionInfo *) magick_hot_spot,
SyncImagePixelCache(Image *,ExceptionInfo *);
extern MagickPrivate MagickSizeType
- GetPixelCacheNexusExtent(const Cache,NexusInfo *restrict);
+ GetPixelCacheNexusExtent(const Cache,NexusInfo *magick_restrict);
extern MagickPrivate NexusInfo
**AcquirePixelCacheNexus(const size_t),
ExceptionInfo *exception)
{
CacheView
- *restrict cache_view;
+ *magick_restrict cache_view;
cache_view=AcquireVirtualCacheView(image,exception);
(void) SyncImagePixelCache(cache_view->image,exception);
ExceptionInfo *exception)
{
CacheView
- *restrict cache_view;
+ *magick_restrict cache_view;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
MagickExport CacheView *CloneCacheView(const CacheView *cache_view)
{
CacheView
- *restrict clone_view;
+ *magick_restrict clone_view;
assert(cache_view != (CacheView *) NULL);
assert(cache_view->signature == MagickCoreSignature);
id = GetOpenMPThreadId();
Quantum
- *restrict pixels;
+ *magick_restrict pixels;
assert(cache_view != (CacheView *) NULL);
assert(cache_view->signature == MagickCoreSignature);
id = GetOpenMPThreadId();
const void
- *restrict metacontent;
+ *magick_restrict metacontent;
assert(cache_view != (const CacheView *) NULL);
assert(cache_view->signature == MagickCoreSignature);
id = GetOpenMPThreadId();
const Quantum
- *restrict pixels;
+ *magick_restrict pixels;
assert(cache_view != (const CacheView *) NULL);
assert(cache_view->signature == MagickCoreSignature);
id = GetOpenMPThreadId();
const Quantum
- *restrict pixels;
+ *magick_restrict pixels;
assert(cache_view != (CacheView *) NULL);
assert(cache_view->signature == MagickCoreSignature);
id = GetOpenMPThreadId();
Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
i;
id = GetOpenMPThreadId();
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
i;
id = GetOpenMPThreadId();
register const Quantum
- *restrict p;
+ *magick_restrict p;
assert(cache_view != (CacheView *) NULL);
assert(cache_view->signature == MagickCoreSignature);
id = GetOpenMPThreadId();
const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
i;
id = GetOpenMPThreadId();
Quantum
- *restrict pixels;
+ *magick_restrict pixels;
assert(cache_view != (CacheView *) NULL);
assert(cache_view->signature == MagickCoreSignature);
%
*/
MagickExport MagickBooleanType SetCacheViewVirtualPixelMethod(
- CacheView *restrict cache_view,const VirtualPixelMethod virtual_pixel_method)
+ CacheView *magick_restrict cache_view,
+ const VirtualPixelMethod virtual_pixel_method)
{
assert(cache_view != (CacheView *) NULL);
assert(cache_view->signature == MagickCoreSignature);
%
*/
MagickExport MagickBooleanType SyncCacheViewAuthenticPixels(
- CacheView *restrict cache_view,ExceptionInfo *exception)
+ CacheView *magick_restrict cache_view,ExceptionInfo *exception)
{
const int
id = GetOpenMPThreadId();
GetOneCacheViewVirtualPixelInfo(const CacheView *,const ssize_t,const ssize_t,
PixelInfo *,ExceptionInfo *),
SetCacheViewStorageClass(CacheView *,const ClassType,ExceptionInfo *),
- SetCacheViewVirtualPixelMethod(CacheView *restrict,const VirtualPixelMethod),
- SyncCacheViewAuthenticPixels(CacheView *restrict,ExceptionInfo *)
+ SetCacheViewVirtualPixelMethod(CacheView *magick_restrict,
+ const VirtualPixelMethod),
+ SyncCacheViewAuthenticPixels(CacheView *magick_restrict,ExceptionInfo *)
magick_hot_spot;
extern MagickExport MagickSizeType
const ssize_t,const ssize_t,Quantum *,ExceptionInfo *),
OpenPixelCache(Image *,const MapMode,ExceptionInfo *),
OpenPixelCacheOnDisk(CacheInfo *,const MapMode),
- ReadPixelCachePixels(CacheInfo *restrict,NexusInfo *restrict,ExceptionInfo *),
- ReadPixelCacheMetacontent(CacheInfo *restrict,NexusInfo *restrict,
+ ReadPixelCachePixels(CacheInfo *magick_restrict,NexusInfo *magick_restrict,
ExceptionInfo *),
+ ReadPixelCacheMetacontent(CacheInfo *magick_restrict,
+ NexusInfo *magick_restrict,ExceptionInfo *),
SyncAuthenticPixelsCache(Image *,ExceptionInfo *),
- WritePixelCachePixels(CacheInfo *restrict,NexusInfo *restrict,
+ WritePixelCachePixels(CacheInfo *magick_restrict,NexusInfo *magick_restrict,
ExceptionInfo *),
- WritePixelCacheMetacontent(CacheInfo *,NexusInfo *restrict,ExceptionInfo *);
+ WritePixelCacheMetacontent(CacheInfo *,NexusInfo *magick_restrict,
+ ExceptionInfo *);
static Quantum
*GetAuthenticPixelsCache(Image *,const ssize_t,const ssize_t,const size_t,
MagickPrivate Cache AcquirePixelCache(const size_t number_threads)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
char
*synchronize;
MagickPrivate NexusInfo **AcquirePixelCacheNexus(const size_t number_threads)
{
NexusInfo
- **restrict nexus_info;
+ **magick_restrict nexus_info;
register ssize_t
i;
MagickSizeType *length,ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
MagickPrivate Cache ClonePixelCache(const Cache cache)
{
CacheInfo
- *restrict clone_info;
+ *magick_restrict clone_info;
const CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
assert(cache != NULL);
cache_info=(const CacheInfo *) cache;
MagickPrivate void ClonePixelCacheMethods(Cache clone,const Cache cache)
{
CacheInfo
- *restrict cache_info,
- *restrict source_info;
+ *magick_restrict cache_info,
+ *magick_restrict source_info;
assert(clone != (Cache) NULL);
source_info=(CacheInfo *) clone;
% %
% %
% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% ClonePixelCacheRepository() clones the source pixel cache to the destination
% cache.
%
%
*/
-static MagickBooleanType ClonePixelCacheOnDisk(CacheInfo *restrict cache_info,
- CacheInfo *restrict clone_info,ExceptionInfo *exception)
+static MagickBooleanType ClonePixelCacheOnDisk(
+ CacheInfo *magick_restrict cache_info,CacheInfo *magick_restrict clone_info,
+ ExceptionInfo *exception)
{
MagickSizeType
extent;
}
static MagickBooleanType ClonePixelCacheRepository(
- CacheInfo *restrict clone_info,CacheInfo *restrict cache_info,
+ CacheInfo *magick_restrict clone_info,CacheInfo *magick_restrict cache_info,
ExceptionInfo *exception)
{
#define MaxCacheThreads 2
status;
NexusInfo
- **restrict cache_nexus,
- **restrict clone_nexus;
+ **magick_restrict cache_nexus,
+ **magick_restrict clone_nexus;
size_t
length;
else
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
/*
Mismatched pixel channel map.
MagickExport void DestroyImagePixels(Image *image)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
MagickPrivate Cache DestroyPixelCache(Cache cache)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
assert(cache != (Cache) NULL);
cache_info=(CacheInfo *) cache;
MagickExport void *GetAuthenticMetacontent(const Image *image)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
static void *GetAuthenticMetacontentFromCache(const Image *image)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
Quantum
- *restrict pixels;
+ *magick_restrict pixels;
/*
Transfer pixels from the cache.
static Quantum *GetAuthenticPixelsFromCache(const Image *image)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
MagickExport Quantum *GetAuthenticPixelQueue(const Image *image)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
Quantum
- *restrict pixels;
+ *magick_restrict pixels;
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
MagickExport MagickSizeType GetImageExtent(const Image *image)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
*/
static inline MagickBooleanType ValidatePixelCacheMorphology(
- const Image *restrict image)
+ const Image *magick_restrict image)
{
const CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const PixelChannelMap
- *restrict p,
- *restrict q;
+ *magick_restrict p,
+ *magick_restrict q;
/*
Does the image match the pixel cache morphology?
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
MagickBooleanType
destroy,
MagickExport CacheType GetImagePixelCacheType(const Image *image)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
const ssize_t x,const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
register Quantum
- *restrict q;
+ *magick_restrict q;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
const ssize_t x,const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
register Quantum
- *restrict q;
+ *magick_restrict q;
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
const ssize_t x,const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
Quantum *pixel,ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
PixelInfo *pixel,ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
register const Quantum
- *restrict p;
+ *magick_restrict p;
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
MagickPrivate ColorspaceType GetPixelCacheColorspace(const Cache cache)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
assert(cache != (Cache) NULL);
cache_info=(CacheInfo *) cache;
%
*/
MagickPrivate MagickSizeType GetPixelCacheNexusExtent(const Cache cache,
- NexusInfo *restrict nexus_info)
+ NexusInfo *magick_restrict nexus_info)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
MagickSizeType
extent;
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
MagickPrivate ClassType GetPixelCacheStorageClass(const Cache cache)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
assert(cache != (Cache) NULL);
cache_info=(CacheInfo *) cache;
size_t *height)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
MagickPrivate VirtualPixelMethod GetPixelCacheVirtualMethod(const Image *image)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
static const void *GetVirtualMetacontentFromCache(const Image *image)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
const void
- *restrict metacontent;
+ *magick_restrict metacontent;
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
%
*/
MagickPrivate const void *GetVirtualMetacontentFromNexus(const Cache cache,
- NexusInfo *restrict nexus_info)
+ NexusInfo *magick_restrict nexus_info)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
assert(cache != (Cache) NULL);
cache_info=(CacheInfo *) cache;
MagickExport const void *GetVirtualMetacontent(const Image *image)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
const void
- *restrict metacontent;
+ *magick_restrict metacontent;
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
MagickOffsetType
offset;
number_pixels;
NexusInfo
- **restrict virtual_nexus;
+ **magick_restrict virtual_nexus;
Quantum
- *restrict pixels,
+ *magick_restrict pixels,
virtual_pixel[MaxPixelChannels];
RectangleInfo
region;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register const void
- *restrict r;
+ *magick_restrict r;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
i,
u;
register unsigned char
- *restrict s;
+ *magick_restrict s;
ssize_t
v;
void
- *restrict virtual_metacontent;
+ *magick_restrict virtual_metacontent;
/*
Acquire pixels.
const size_t columns,const size_t rows,ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
const Quantum
- *restrict p;
+ *magick_restrict p;
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
MagickExport const Quantum *GetVirtualPixelQueue(const Image *image)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
const Quantum
- *restrict p;
+ *magick_restrict p;
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
static const Quantum *GetVirtualPixelsCache(const Image *image)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
%
*/
MagickPrivate const Quantum *GetVirtualPixelsNexus(const Cache cache,
- NexusInfo *restrict nexus_info)
+ NexusInfo *magick_restrict nexus_info)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
assert(cache != (Cache) NULL);
cache_info=(CacheInfo *) cache;
}
static inline MagickOffsetType WritePixelCacheRegion(
- const CacheInfo *restrict cache_info,const MagickOffsetType offset,
- const MagickSizeType length,const unsigned char *restrict buffer)
+ const CacheInfo *magick_restrict cache_info,const MagickOffsetType offset,
+ const MagickSizeType length,const unsigned char *magick_restrict buffer)
{
register MagickOffsetType
i;
static MagickBooleanType SetPixelCacheExtent(Image *image,MagickSizeType length)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
MagickOffsetType
count,
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info,
+ *magick_restrict cache_info,
source_info;
char
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info,
- *restrict clone_info;
+ *magick_restrict cache_info,
+ *magick_restrict clone_info;
Image
clone_image;
const MagickBooleanType clone,NexusInfo *nexus_info,ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
MagickOffsetType
offset;
number_pixels;
Quantum
- *restrict pixels;
+ *magick_restrict pixels;
RectangleInfo
region;
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
Quantum
- *restrict pixels;
+ *magick_restrict pixels;
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
Quantum
- *restrict pixels;
+ *magick_restrict pixels;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
*/
static inline MagickOffsetType ReadPixelCacheRegion(
- const CacheInfo *restrict cache_info,const MagickOffsetType offset,
- const MagickSizeType length,unsigned char *restrict buffer)
+ const CacheInfo *magick_restrict cache_info,const MagickOffsetType offset,
+ const MagickSizeType length,unsigned char *magick_restrict buffer)
{
register MagickOffsetType
i;
}
static MagickBooleanType ReadPixelCacheMetacontent(
- CacheInfo *restrict cache_info,NexusInfo *restrict nexus_info,
+ CacheInfo *magick_restrict cache_info,NexusInfo *magick_restrict nexus_info,
ExceptionInfo *exception)
{
MagickOffsetType
y;
register unsigned char
- *restrict q;
+ *magick_restrict q;
size_t
rows;
case MapCache:
{
register unsigned char
- *restrict p;
+ *magick_restrict p;
/*
Read meta-content from memory.
% o exception: return any errors or warnings in this structure.
%
*/
-static MagickBooleanType ReadPixelCachePixels(CacheInfo *restrict cache_info,
- NexusInfo *restrict nexus_info,ExceptionInfo *exception)
+static MagickBooleanType ReadPixelCachePixels(
+ CacheInfo *magick_restrict cache_info,NexusInfo *magick_restrict nexus_info,
+ ExceptionInfo *exception)
{
MagickOffsetType
count,
length;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
y;
case MapCache:
{
register Quantum
- *restrict p;
+ *magick_restrict p;
/*
Read pixels from memory.
MagickPrivate Cache ReferencePixelCache(Cache cache)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
assert(cache != (Cache *) NULL);
cache_info=(CacheInfo *) cache;
MagickPrivate void SetPixelCacheMethods(Cache cache,CacheMethods *cache_methods)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
GetOneAuthenticPixelFromHandler
get_one_authentic_pixel_from_handler;
*/
static inline MagickBooleanType AcquireCacheNexusPixels(
- const CacheInfo *restrict cache_info,NexusInfo *nexus_info,
+ const CacheInfo *magick_restrict cache_info,NexusInfo *nexus_info,
ExceptionInfo *exception)
{
if (nexus_info->length != (MagickSizeType) ((size_t) nexus_info->length))
}
static inline MagickBooleanType IsPixelCacheAuthentic(
- const CacheInfo *restrict cache_info,const NexusInfo *restrict nexus_info)
+ const CacheInfo *magick_restrict cache_info,
+ const NexusInfo *magick_restrict nexus_info)
{
MagickBooleanType
status;
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
CacheView
- *restrict image_view;
+ *magick_restrict image_view;
MagickBooleanType
status;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
const VirtualPixelMethod virtual_pixel_method,ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
VirtualPixelMethod
method;
%
*/
MagickPrivate MagickBooleanType SyncAuthenticPixelCacheNexus(Image *image,
- NexusInfo *restrict nexus_info,ExceptionInfo *exception)
+ NexusInfo *magick_restrict nexus_info,ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
MagickBooleanType
status;
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
const int
id = GetOpenMPThreadId();
ExceptionInfo *exception)
{
CacheInfo
- *restrict cache_info;
+ *magick_restrict cache_info;
assert(image != (Image *) NULL);
assert(exception != (ExceptionInfo *) NULL);
%
*/
static MagickBooleanType WritePixelCacheMetacontent(CacheInfo *cache_info,
- NexusInfo *restrict nexus_info,ExceptionInfo *exception)
+ NexusInfo *magick_restrict nexus_info,ExceptionInfo *exception)
{
MagickOffsetType
count,
length;
register const unsigned char
- *restrict p;
+ *magick_restrict p;
register ssize_t
y;
case MapCache:
{
register unsigned char
- *restrict q;
+ *magick_restrict q;
/*
Write associated pixels to memory.
% o exception: return any errors or warnings in this structure.
%
*/
-static MagickBooleanType WritePixelCachePixels(CacheInfo *restrict cache_info,
- NexusInfo *restrict nexus_info,ExceptionInfo *exception)
+static MagickBooleanType WritePixelCachePixels(
+ CacheInfo *magick_restrict cache_info,NexusInfo *magick_restrict nexus_info,
+ ExceptionInfo *exception)
{
MagickOffsetType
count,
length;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
y;
case MapCache:
{
register Quantum
- *restrict q;
+ *magick_restrict q;
/*
Write pixels to memory.
source_traits;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
*pixels;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
i;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
ssize_t
index;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
pixel;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
}
static inline MagickBooleanType ValidateImageMorphology(
- const Image *restrict image,const Image *restrict reconstruct_image)
+ const Image *magick_restrict image,
+ const Image *magick_restrict reconstruct_image)
{
/*
Does the image match the reconstructed image morphology?
sync;
register const Quantum
- *restrict p,
- *restrict q;
+ *magick_restrict p,
+ *magick_restrict q;
register Quantum
- *restrict r;
+ *magick_restrict r;
register ssize_t
x;
channel_distortion[MaxPixelChannels+1];
register const Quantum
- *restrict p,
- *restrict q;
+ *magick_restrict p,
+ *magick_restrict q;
register ssize_t
j,
channel_distortion[MaxPixelChannels+1];
register const Quantum
- *restrict p,
- *restrict q;
+ *magick_restrict p,
+ *magick_restrict q;
register ssize_t
x;
channel_distortion[MaxPixelChannels+1];
register const Quantum
- *restrict p,
- *restrict q;
+ *magick_restrict p,
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) rows; y++)
{
register const Quantum
- *restrict p,
- *restrict q;
+ *magick_restrict p,
+ *magick_restrict q;
register ssize_t
x;
channel_distortion[MaxPixelChannels+1];
register const Quantum
- *restrict p,
- *restrict q;
+ *magick_restrict p,
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) rows; y++)
{
register const Quantum
- *restrict p,
- *restrict q;
+ *magick_restrict p,
+ *magick_restrict q;
register ssize_t
x;
channel_distortion[MaxPixelChannels+1];
register const Quantum
- *restrict p,
- *restrict q;
+ *magick_restrict p,
+ *magick_restrict q;
register ssize_t
j,
for (y=0; y < (ssize_t) rows; y++)
{
register const Quantum
- *restrict p,
- *restrict q;
+ *magick_restrict p,
+ *magick_restrict q;
register ssize_t
x;
similarity;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
*pixels;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
sync;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
sync;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
source_pixel;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; ((y < (ssize_t) image->rows) && (null_lines < 3)); )
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
% The format of the LZWEncodeImage method is:
%
% MagickBooleanType LZWEncodeImage(Image *image,const size_t length,
-% unsigned char *restrict pixels,ExceptionInfo *exception)
+% unsigned char *magick_restrict pixels,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
*/
MagickExport MagickBooleanType LZWEncodeImage(Image *image,const size_t length,
- unsigned char *restrict pixels,ExceptionInfo *exception)
+ unsigned char *magick_restrict pixels,ExceptionInfo *exception)
{
#define LZWClr 256UL /* Clear Table Marker */
#define LZWEod 257UL /* End of Data marker */
% The format of the PackbitsEncodeImage method is:
%
% MagickBooleanType PackbitsEncodeImage(Image *image,const size_t length,
-% unsigned char *restrict pixels)
+% unsigned char *magick_restrict pixels)
%
% A description of each parameter follows:
%
%
*/
MagickExport MagickBooleanType PackbitsEncodeImage(Image *image,
- const size_t length,unsigned char *restrict pixels,ExceptionInfo *exception)
+ const size_t length,unsigned char *magick_restrict pixels,
+ ExceptionInfo *exception)
{
int
count;
% The format of the ZLIBEncodeImage method is:
%
% MagickBooleanType ZLIBEncodeImage(Image *image,const size_t length,
-% unsigned char *restrict pixels,ExceptionInfo *exception)
+% unsigned char *magick_restrict pixels,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
}
MagickExport MagickBooleanType ZLIBEncodeImage(Image *image,const size_t length,
- unsigned char *restrict pixels,ExceptionInfo *exception)
+ unsigned char *magick_restrict pixels,ExceptionInfo *exception)
{
int
status;
extern MagickExport MagickBooleanType
HuffmanDecodeImage(Image *,ExceptionInfo *),
HuffmanEncodeImage(const ImageInfo *,Image *,Image *,ExceptionInfo *),
- LZWEncodeImage(Image *,const size_t,unsigned char *restrict,ExceptionInfo *),
- PackbitsEncodeImage(Image *,const size_t,unsigned char *restrict,
+ LZWEncodeImage(Image *,const size_t,unsigned char *magick_restrict,
ExceptionInfo *),
- ZLIBEncodeImage(Image *,const size_t,unsigned char *restrict,ExceptionInfo *);
+ PackbitsEncodeImage(Image *,const size_t,unsigned char *magick_restrict,
+ ExceptionInfo *),
+ ZLIBEncodeImage(Image *,const size_t,unsigned char *magick_restrict,
+ ExceptionInfo *);
extern MagickExport void
Ascii85Encode(Image *,const unsigned char),
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
/*
Draw top of ornamental border.
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
size_t
width;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
/*
Draw bottom of ornamental border.
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
zero;
ResampleFilter
- **restrict resample_filter;
+ **magick_restrict resample_filter;
ssize_t
j;
i;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=QueueCacheViewAuthenticPixels(distort_view,0,j,distort_image->columns,1,
exception);
i;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetCacheViewAuthenticPixels(sparse_view,0,j,sparse_image->columns,
1,exception);
ReadDistributePixelCacheMetacontent(DistributeCacheInfo *,
const RectangleInfo *,const MagickSizeType,unsigned char *),
ReadDistributePixelCachePixels(DistributeCacheInfo *,const RectangleInfo *,
- const MagickSizeType,unsigned char *restrict),
+ const MagickSizeType,unsigned char *magick_restrict),
WriteDistributePixelCacheMetacontent(DistributeCacheInfo *,
const RectangleInfo *,const MagickSizeType,const unsigned char *),
WriteDistributePixelCachePixels(DistributeCacheInfo *,const RectangleInfo *,
- const MagickSizeType,const unsigned char *restrict);
+ const MagickSizeType,const unsigned char *magick_restrict);
#if defined(__cplusplus) || defined(c_plusplus)
}
*/
static inline MagickOffsetType dpc_read(int file,const MagickSizeType length,
- unsigned char *restrict message)
+ unsigned char *magick_restrict message)
{
register MagickOffsetType
i;
}
static inline MagickOffsetType dpc_send(int file,const MagickSizeType length,
- const unsigned char *restrict message)
+ const unsigned char *magick_restrict message)
{
MagickOffsetType
count;
%
% MagickOffsetType ReadDistributePixelCachePixels(
% DistributeCacheInfo *server_info,const RectangleInfo *region,
-% const MagickSizeType length,unsigned char *restrict pixels)
+% const MagickSizeType length,unsigned char *magick_restrict pixels)
%
% A description of each parameter follows:
%
*/
MagickPrivate MagickOffsetType ReadDistributePixelCachePixels(
DistributeCacheInfo *server_info,const RectangleInfo *region,
- const MagickSizeType length,unsigned char *restrict pixels)
+ const MagickSizeType length,unsigned char *magick_restrict pixels)
{
MagickOffsetType
count;
%
% MagickBooleanType WriteDistributePixelCachePixels(
% DistributeCacheInfo *server_info,const RectangleInfo *region,
-% const MagickSizeType length,const unsigned char *restrict pixels)
+% const MagickSizeType length,
+% const unsigned char *magick_restrict pixels)
%
% A description of each parameter follows:
%
*/
MagickPrivate MagickOffsetType WriteDistributePixelCachePixels(
DistributeCacheInfo *server_info,const RectangleInfo *region,
- const MagickSizeType length,const unsigned char *restrict pixels)
+ const MagickSizeType length,const unsigned char *magick_restrict pixels)
{
MagickOffsetType
count;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
SegmentInfo
inverse_edge;
offset;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
i,
const PrimitiveInfo *primitive_info)
{
PathInfo
- *restrict path_info;
+ *magick_restrict path_info;
PolygonInfo
**polygon_info;
mid;
PolygonInfo
- **restrict polygon_info;
+ **magick_restrict polygon_info;
register EdgeInfo
*p;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
ssize_t
start_x,
stroke_color;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
exception);
for (y=0; y < (ssize_t) blur_image->rows; y++)
{
register const Quantum
- *restrict r;
+ *magick_restrict r;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (x=0; x < (ssize_t) blur_image->columns; x++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
i;
traits;
register const MagickRealType
- *restrict k;
+ *magick_restrict k;
register const Quantum
- *restrict pixels;
+ *magick_restrict pixels;
register ssize_t
u;
for (y=0; y < (ssize_t) sharp_image->rows; y++)
{
register const Quantum
- *restrict r;
+ *magick_restrict r;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (x=0; x < (ssize_t) sharp_image->columns; x++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
i;
traits;
register const MagickRealType
- *restrict k;
+ *magick_restrict k;
register const Quantum
- *restrict pixels;
+ *magick_restrict pixels;
register ssize_t
u;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% DespeckleImage() reduces the speckle noise in an image while perserving the
-% edges of the original image. A speckle removing filter uses a complementary % hulling technique (raising pixels that are darker than their surrounding
+% edges of the original image. A speckle removing filter uses a complementary
+% hulling technique (raising pixels that are darker than their surrounding
% neighbors, then complementarily lowering pixels that are brighter than their
% surrounding neighbors) to reduce the speckle index of that image (reference
% Crimmins speckle removal).
static void Hull(const Image *image,const ssize_t x_offset,
const ssize_t y_offset,const size_t columns,const size_t rows,
- const int polarity,Quantum *restrict f,Quantum *restrict g)
+ const int polarity,Quantum *magick_restrict f,Quantum *magick_restrict g)
{
register Quantum
*p,
*pixel_info;
Quantum
- *restrict buffer,
- *restrict pixels;
+ *magick_restrict buffer,
+ *magick_restrict pixels;
register ssize_t
i;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
sync;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetCacheViewAuthenticPixels(despeckle_view,0,y,despeckle_image->columns,
1,exception);
%
*/
-static inline MagickRealType GetMeanLuma(const Image *restrict image,
- const double *restrict pixel)
+static inline MagickRealType GetMeanLuma(const Image *magick_restrict image,
+ const double *magick_restrict pixel)
{
if (image->colorspace == GRAYColorspace)
return((MagickRealType) pixel[image->channel_map[GrayPixelChannel].offset]);
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (x=0; x < (ssize_t) image->columns; x++)
{
const Quantum
- *restrict p;
+ *magick_restrict p;
double
min_variance;
for (i=0; i < 4; i++)
{
const Quantum
- *restrict k;
+ *magick_restrict k;
double
mean[MaxPixelChannels],
for (x=0; x < (ssize_t) image->columns; x++)
{
const Quantum
- *restrict p;
+ *magick_restrict p;
float
*out,
for (y=0; y < (ssize_t) image->rows; y++)
{
const Quantum
- *restrict p;
+ *magick_restrict p;
float
*pix,
*pixels;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
traits;
register const Quantum
- *restrict r;
+ *magick_restrict r;
register MagickRealType
- *restrict k;
+ *magick_restrict k;
register ssize_t
j;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
traits;
register const Quantum
- *restrict r;
+ *magick_restrict r;
register ssize_t
j;
sync;
register const Quantum
- *restrict l,
- *restrict p;
+ *magick_restrict l,
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
traits;
register const MagickRealType
- *restrict k;
+ *magick_restrict k;
register const Quantum
- *restrict luminance_pixels,
- *restrict pixels;
+ *magick_restrict luminance_pixels,
+ *magick_restrict pixels;
register ssize_t
u;
normal;
register const Quantum
- *restrict center,
- *restrict p,
- *restrict post,
- *restrict pre;
+ *magick_restrict center,
+ *magick_restrict p,
+ *magick_restrict post,
+ *magick_restrict pre;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
progress;
RandomInfo
- **restrict random_info;
+ **magick_restrict random_info;
size_t
width;
id = GetOpenMPThreadId();
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
pixel;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
luma;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
red;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
pixel;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
aggregate;
register const Quantum
- *restrict r;
+ *magick_restrict r;
if (GetPixelReadMask(image,p) == 0)
{
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
sync;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) edge_image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
dy;
register const Quantum
- *restrict kernel_pixels;
+ *magick_restrict kernel_pixels;
ssize_t
v;
for (y=0; y < (ssize_t) edge_image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
pixel;
register const Quantum
- *restrict p;
+ *magick_restrict p;
/*
Edge if pixel gradient higher than upper threshold.
for (r=0; r < (ssize_t) image->rows; r++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (r=0; r < (ssize_t) image->rows; r++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) mean_image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) images->rows; y++)
{
register const Quantum
- *restrict Ai,
- *restrict Ar,
- *restrict Bi,
- *restrict Br;
+ *magick_restrict Ai,
+ *magick_restrict Ar,
+ *magick_restrict Bi,
+ *magick_restrict Br;
register Quantum
- *restrict Ci,
- *restrict Cr;
+ *magick_restrict Ci,
+ *magick_restrict Cr;
register ssize_t
x;
progress;
RandomInfo
- **restrict random_info;
+ **magick_restrict random_info;
ssize_t
y;
sync;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
quantum;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
sync;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
pixel;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
*image_view;
FxInfo
- **restrict fx_info;
+ **magick_restrict fx_info;
Image
*fx_image;
id = GetOpenMPThreadId();
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
delta;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
sync;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
plasma;
register const Quantum
- *restrict u,
- *restrict v;
+ *magick_restrict u,
+ *magick_restrict v;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
i;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
background_color;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
status;
RandomInfo
- **restrict random_info;
+ **magick_restrict random_info;
ssize_t
y;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
for (y=0; y < (ssize_t) stereo_image->rows; y++)
{
register const Quantum
- *restrict p,
- *restrict q;
+ *magick_restrict p,
+ *magick_restrict q;
register ssize_t
x;
register Quantum
- *restrict r;
+ *magick_restrict r;
p=GetVirtualPixels(left_image,-x_offset,y-y_offset,image->columns,1,
exception);
delta;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) wave_image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
*p;
register Quantum
- *restrict q;
+ *magick_restrict q;
status=MagickTrue;
p=node_info->list;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
pixel;
register PixelInfo
- *restrict p;
+ *magick_restrict p;
GetPixelInfo(image,&pixel);
p=image->colormap;
sync;
register const Quantum
- *restrict duplex_pixels,
- *restrict pixels;
+ *magick_restrict duplex_pixels,
+ *magick_restrict pixels;
register Quantum
- *restrict destination_pixels;
+ *magick_restrict destination_pixels;
if (status == MagickFalse)
continue;
sync;
register Quantum
- *restrict pixels;
+ *magick_restrict pixels;
if (status == MagickFalse)
continue;
sync;
register const Quantum
- *restrict pixels;
+ *magick_restrict pixels;
register Quantum
- *restrict destination_pixels;
+ *magick_restrict destination_pixels;
if (status == MagickFalse)
continue;
id = GetOpenMPThreadId();
register Quantum
- *restrict pixels;
+ *magick_restrict pixels;
if (status == MagickFalse)
continue;
pixel;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
sync;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
index;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetAuthenticPixels(image,bounds->x,bounds->y+y,bounds->width,1,exception);
if (q == (Quantum *) NULL)
LocaleComponentTerminus(void);
extern MagickPrivate ssize_t
- FormatLocaleFileList(FILE *,const char *restrict,va_list)
+ FormatLocaleFileList(FILE *,const char *magick_restrict,va_list)
magick_attribute((__format__ (__printf__,2,0))),
- FormatLocaleStringList(char *restrict,const size_t,const char *restrict,
- va_list) magick_attribute((__format__ (__printf__,3,0)));
+ FormatLocaleStringList(char *magick_restrict,const size_t,
+ const char *magick_restrict,va_list)
+ magick_attribute((__format__ (__printf__,3,0)));
#if defined(__cplusplus) || defined(c_plusplus)
}
*/
MagickPrivate ssize_t FormatLocaleFileList(FILE *file,
- const char *restrict format,va_list operands)
+ const char *magick_restrict format,va_list operands)
{
ssize_t
n;
return(n);
}
-MagickExport ssize_t FormatLocaleFile(FILE *file,const char *restrict format,
- ...)
+MagickExport ssize_t FormatLocaleFile(FILE *file,
+ const char *magick_restrict format,...)
{
ssize_t
n;
%
*/
-MagickPrivate ssize_t FormatLocaleStringList(char *restrict string,
- const size_t length,const char *restrict format,va_list operands)
+MagickPrivate ssize_t FormatLocaleStringList(char *magick_restrict string,
+ const size_t length,const char *magick_restrict format,va_list operands)
{
ssize_t
n;
return(n);
}
-MagickExport ssize_t FormatLocaleString(char *restrict string,
- const size_t length,const char *restrict format,...)
+MagickExport ssize_t FormatLocaleString(char *magick_restrict string,
+ const size_t length,const char *magick_restrict format,...)
{
ssize_t
n;
% referenced by sentinal.
%
*/
-MagickExport double InterpretLocaleValue(const char *restrict string,
- char **restrict sentinal)
+MagickExport double InterpretLocaleValue(const char *magick_restrict string,
+ char **magick_restrict sentinal)
{
char
*q;
**GetLocaleInfoList(const char *,size_t *,ExceptionInfo *);
extern MagickExport double
- InterpretLocaleValue(const char *restrict,char **restrict);
+ InterpretLocaleValue(const char *magick_restrict,char **magick_restrict);
extern MagickExport int
LocaleCompare(const char *,const char *),
ListLocaleInfo(FILE *,ExceptionInfo *);
extern MagickExport ssize_t
- FormatLocaleFile(FILE *,const char *restrict,...)
+ FormatLocaleFile(FILE *,const char *magick_restrict,...)
magick_attribute((__format__ (__printf__,2,3))),
- FormatLocaleString(char *restrict,const size_t,const char *restrict,...)
+ FormatLocaleString(char *magick_restrict,const size_t,
+ const char *magick_restrict,...)
magick_attribute((__format__ (__printf__,3,4)));
extern MagickExport void
#endif
static inline MagickOffsetType WriteMatrixElements(
- const MatrixInfo *restrict matrix_info,const MagickOffsetType offset,
- const MagickSizeType length,const unsigned char *restrict buffer)
+ const MatrixInfo *magick_restrict matrix_info,const MagickOffsetType offset,
+ const MagickSizeType length,const unsigned char *magick_restrict buffer)
{
register MagickOffsetType
i;
return(i);
}
-static MagickBooleanType SetMatrixExtent(MatrixInfo *restrict matrix_info,
+static MagickBooleanType SetMatrixExtent(
+ MatrixInfo *magick_restrict matrix_info,
MagickSizeType length)
{
MagickOffsetType
}
static inline MagickOffsetType ReadMatrixElements(
- const MatrixInfo *restrict matrix_info,const MagickOffsetType offset,
- const MagickSizeType length,unsigned char *restrict buffer)
+ const MatrixInfo *magick_restrict matrix_info,const MagickOffsetType offset,
+ const MagickSizeType length,unsigned char *magick_restrict buffer)
{
register MagickOffsetType
i;
id = GetOpenMPThreadId();
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
r;
traits;
register const MagickRealType
- *restrict k;
+ *magick_restrict k;
register const Quantum
- *restrict pixels;
+ *magick_restrict pixels;
register ssize_t
v;
id = GetOpenMPThreadId();
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
traits;
register const MagickRealType
- *restrict k;
+ *magick_restrict k;
register const Quantum
- *restrict pixels;
+ *magick_restrict pixels;
register ssize_t
u;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
traits;
register const MagickRealType
- *restrict k;
+ *magick_restrict k;
register const Quantum
- *restrict pixels;
+ *magick_restrict pixels;
register ssize_t
u;
for (y=(ssize_t) image->rows-1; y >= 0; y--)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
traits;
register const MagickRealType
- *restrict k;
+ *magick_restrict k;
register const Quantum
- *restrict pixels;
+ *magick_restrict pixels;
register ssize_t
u;
while (s > segment_stack)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) linear_image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register size_t
*histogram;
pixel;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
pixel;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
#endif
}
-static inline Quantum GetPixela(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixela(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
return(pixel[image->channel_map[aPixelChannel].offset]);
}
-static inline Quantum GetPixelAlpha(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelAlpha(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
if (image->channel_map[AlphaPixelChannel].traits == UndefinedPixelTrait)
return(OpaqueAlpha);
return(pixel[image->channel_map[AlphaPixelChannel].offset]);
}
-static inline PixelTrait GetPixelAlphaTraits(const Image *restrict image)
+static inline PixelTrait GetPixelAlphaTraits(
+ const Image *magick_restrict image)
{
return(image->channel_map[AlphaPixelChannel].traits);
}
-static inline Quantum GetPixelb(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelb(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
return(pixel[image->channel_map[bPixelChannel].offset]);
}
-static inline Quantum GetPixelBlack(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelBlack(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
if (image->channel_map[BlackPixelChannel].traits == UndefinedPixelTrait)
return((Quantum) 0);
return(pixel[image->channel_map[BlackPixelChannel].offset]);
}
-static inline PixelTrait GetPixelBlackTraits(const Image *restrict image)
+static inline PixelTrait GetPixelBlackTraits(
+ const Image *magick_restrict image)
{
return(image->channel_map[BlackPixelChannel].traits);
}
-static inline Quantum GetPixelBlue(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelBlue(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
return(pixel[image->channel_map[BluePixelChannel].offset]);
}
-static inline PixelTrait GetPixelBlueTraits(const Image *restrict image)
+static inline PixelTrait GetPixelBlueTraits(const Image *magick_restrict image)
{
return(image->channel_map[BluePixelChannel].traits);
}
-static inline Quantum GetPixelCb(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelCb(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
return(pixel[image->channel_map[CbPixelChannel].offset]);
}
-static inline PixelTrait GetPixelCbTraits(const Image *restrict image)
+static inline PixelTrait GetPixelCbTraits(const Image *magick_restrict image)
{
return(image->channel_map[CbPixelChannel].traits);
}
-static inline Quantum GetPixelChannel(const Image *restrict image,
- const PixelChannel channel,const Quantum *restrict pixel)
+static inline Quantum GetPixelChannel(const Image *magick_restrict image,
+ const PixelChannel channel,const Quantum *magick_restrict pixel)
{
if (image->channel_map[channel].traits == UndefinedPixelTrait)
return((Quantum) 0);
return(pixel[image->channel_map[channel].offset]);
}
-static inline PixelChannel GetPixelChannelChannel(const Image *restrict image,
- const ssize_t offset)
+static inline PixelChannel GetPixelChannelChannel(
+ const Image *magick_restrict image,const ssize_t offset)
{
return(image->channel_map[offset].channel);
}
-static inline ssize_t GetPixelChannelOffset(const Image *restrict image,
+static inline ssize_t GetPixelChannelOffset(const Image *magick_restrict image,
const PixelChannel channel)
{
return(image->channel_map[channel].offset);
}
-static inline PixelTrait GetPixelChannelTraits(const Image *restrict image,
- const PixelChannel channel)
+static inline PixelTrait GetPixelChannelTraits(
+ const Image *magick_restrict image,const PixelChannel channel)
{
return(image->channel_map[channel].traits);
}
-static inline size_t GetPixelChannels(const Image *restrict image)
+static inline size_t GetPixelChannels(const Image *magick_restrict image)
{
return(image->number_channels);
}
-static inline Quantum GetPixelCr(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelCr(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
return(pixel[image->channel_map[CrPixelChannel].offset]);
}
-static inline PixelTrait GetPixelCrTraits(const Image *restrict image)
+static inline PixelTrait GetPixelCrTraits(const Image *magick_restrict image)
{
return(image->channel_map[CrPixelChannel].traits);
}
-static inline Quantum GetPixelCyan(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelCyan(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
return(pixel[image->channel_map[CyanPixelChannel].offset]);
}
-static inline PixelTrait GetPixelCyanTraits(const Image *restrict image)
+static inline PixelTrait GetPixelCyanTraits(const Image *magick_restrict image)
{
return(image->channel_map[CyanPixelChannel].traits);
}
-static inline Quantum GetPixelGray(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelGray(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
return(pixel[image->channel_map[GrayPixelChannel].offset]);
}
-static inline PixelTrait GetPixelGrayTraits(const Image *restrict image)
+static inline PixelTrait GetPixelGrayTraits(const Image *magick_restrict image)
{
return(image->channel_map[GrayPixelChannel].traits);
}
-static inline Quantum GetPixelGreen(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelGreen(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
return(pixel[image->channel_map[GreenPixelChannel].offset]);
}
-static inline PixelTrait GetPixelGreenTraits(const Image *restrict image)
+static inline PixelTrait GetPixelGreenTraits(
+ const Image *magick_restrict image)
{
return(image->channel_map[GreenPixelChannel].traits);
}
-static inline Quantum GetPixelIndex(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelIndex(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
if (image->channel_map[IndexPixelChannel].traits == UndefinedPixelTrait)
return((Quantum) 0);
return(pixel[image->channel_map[IndexPixelChannel].offset]);
}
-static inline PixelTrait GetPixelIndexTraits(const Image *restrict image)
+static inline PixelTrait GetPixelIndexTraits(
+ const Image *magick_restrict image)
{
return(image->channel_map[IndexPixelChannel].traits);
}
static inline MagickRealType GetPixelInfoChannel(
- const PixelInfo *restrict pixel_info,const PixelChannel channel)
+ const PixelInfo *magick_restrict pixel_info,const PixelChannel channel)
{
switch (channel)
{
return(sign/MagickEpsilon);
}
-static inline MagickRealType GetPixelInfoLuma(const PixelInfo *restrict pixel)
+static inline MagickRealType GetPixelInfoLuma(
+ const PixelInfo *magick_restrict pixel)
{
MagickRealType
intensity;
}
static inline MagickRealType GetPixelInfoLuminance(
- const PixelInfo *restrict pixel)
+ const PixelInfo *magick_restrict pixel)
{
MagickRealType
intensity;
return(intensity);
}
-static inline Quantum GetPixelL(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelL(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
return(pixel[image->channel_map[LPixelChannel].offset]);
}
-static inline MagickRealType GetPixelLuma(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline MagickRealType GetPixelLuma(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
MagickRealType
intensity;
return(intensity);
}
-static inline MagickRealType GetPixelLuminance(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline MagickRealType GetPixelLuminance(
+ const Image *magick_restrict image,const Quantum *magick_restrict pixel)
{
MagickRealType
intensity;
return(intensity);
}
-static inline Quantum GetPixelMagenta(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelMagenta(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
return(pixel[image->channel_map[MagentaPixelChannel].offset]);
}
-static inline PixelTrait GetPixelMagentaTraits(const Image *restrict image)
+static inline PixelTrait GetPixelMagentaTraits(
+ const Image *magick_restrict image)
{
return(image->channel_map[MagentaPixelChannel].traits);
}
-static inline Quantum GetPixelReadMask(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelReadMask(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
if (image->channel_map[ReadMaskPixelChannel].traits == UndefinedPixelTrait)
return((Quantum) QuantumRange);
return(pixel[image->channel_map[ReadMaskPixelChannel].offset]);
}
-static inline Quantum GetPixelWriteMask(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelWriteMask(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
if (image->channel_map[WriteMaskPixelChannel].traits == UndefinedPixelTrait)
return((Quantum) QuantumRange);
return(pixel[image->channel_map[WriteMaskPixelChannel].offset]);
}
-static inline PixelTrait GetPixelReadMaskTraits(const Image *restrict image)
+static inline PixelTrait GetPixelReadMaskTraits(
+ const Image *magick_restrict image)
{
return(image->channel_map[ReadMaskPixelChannel].traits);
}
-static inline size_t GetPixelMetaChannels(const Image *restrict image)
+static inline size_t GetPixelMetaChannels(const Image *magick_restrict image)
{
return(image->number_meta_channels);
}
-static inline size_t GetPixelMetacontentExtent(const Image *restrict image)
+static inline size_t GetPixelMetacontentExtent(
+ const Image *magick_restrict image)
{
return(image->metacontent_extent);
}
-static inline Quantum GetPixelOpacity(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelOpacity(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
if (image->channel_map[AlphaPixelChannel].traits != BlendPixelTrait)
return(QuantumRange-OpaqueAlpha);
return(QuantumRange-pixel[image->channel_map[AlphaPixelChannel].offset]);
}
-static inline Quantum GetPixelRed(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelRed(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
return(pixel[image->channel_map[RedPixelChannel].offset]);
}
-static inline PixelTrait GetPixelRedTraits(const Image *restrict image)
+static inline PixelTrait GetPixelRedTraits(const Image *magick_restrict image)
{
return(image->channel_map[RedPixelChannel].traits);
}
-static inline void GetPixelInfoPixel(const Image *restrict image,
- const Quantum *restrict pixel,PixelInfo *restrict pixel_info)
+static inline void GetPixelInfoPixel(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel,PixelInfo *magick_restrict pixel_info)
{
pixel_info->storage_class=image->storage_class;
pixel_info->colorspace=image->colorspace;
pixel_info->count=0;
}
-static inline PixelTrait GetPixelTraits(const Image *restrict image,
+static inline PixelTrait GetPixelTraits(const Image *magick_restrict image,
const PixelChannel channel)
{
return(image->channel_map[channel].traits);
}
-static inline Quantum GetPixelY(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelY(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
return(pixel[image->channel_map[YPixelChannel].offset]);
}
-static inline PixelTrait GetPixelYTraits(const Image *restrict image)
+static inline PixelTrait GetPixelYTraits(const Image *magick_restrict image)
{
return(image->channel_map[YPixelChannel].traits);
}
-static inline Quantum GetPixelYellow(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline Quantum GetPixelYellow(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
return(pixel[image->channel_map[YellowPixelChannel].offset]);
}
-static inline PixelTrait GetPixelYellowTraits(const Image *restrict image)
+static inline PixelTrait GetPixelYellowTraits(
+ const Image *magick_restrict image)
{
return(image->channel_map[YellowPixelChannel].traits);
}
return(pixel == quantum ? MagickTrue : MagickFalse);
}
-static inline MagickBooleanType IsPixelEquivalent(const Image *restrict image,
- const Quantum *restrict p,const PixelInfo *restrict q)
+static inline MagickBooleanType IsPixelEquivalent(
+ const Image *magick_restrict image,const Quantum *magick_restrict p,
+ const PixelInfo *magick_restrict q)
{
MagickRealType
value;
return(MagickTrue);
}
-static inline MagickBooleanType IsPixelGray(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline MagickBooleanType IsPixelGray(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
MagickRealType
green_blue,
}
static inline MagickBooleanType IsPixelInfoEquivalent(
- const PixelInfo *restrict p,const PixelInfo *restrict q)
+ const PixelInfo *magick_restrict p,const PixelInfo *magick_restrict q)
{
if ((p->alpha_trait != UndefinedPixelTrait) &&
(q->alpha_trait == UndefinedPixelTrait) &&
return(MagickTrue);
}
-static inline MagickBooleanType IsPixelMonochrome(const Image *restrict image,
- const Quantum *restrict pixel)
+static inline MagickBooleanType IsPixelMonochrome(
+ const Image *magick_restrict image,const Quantum *magick_restrict pixel)
{
MagickRealType
green_blue,
}
static inline MagickBooleanType IsPixelInfoGray(
- const PixelInfo *restrict pixel)
+ const PixelInfo *magick_restrict pixel)
{
if ((pixel->colorspace != GRAYColorspace) &&
(pixel->colorspace != RGBColorspace))
}
static inline MagickBooleanType IsPixelInfoMonochrome(
- const PixelInfo *restrict pixel_info)
+ const PixelInfo *magick_restrict pixel_info)
{
MagickRealType
green_blue,
return(MagickFalse);
}
-static inline void SetPixela(const Image *restrict image,
- const Quantum a,Quantum *restrict pixel)
+static inline void SetPixela(const Image *magick_restrict image,
+ const Quantum a,Quantum *magick_restrict pixel)
{
if (image->channel_map[aPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[aPixelChannel].offset]=a;
}
-static inline void SetPixelAlpha(const Image *restrict image,
- const Quantum alpha,Quantum *restrict pixel)
+static inline void SetPixelAlpha(const Image *magick_restrict image,
+ const Quantum alpha,Quantum *magick_restrict pixel)
{
if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[AlphaPixelChannel].offset]=alpha;
image->channel_map[AlphaPixelChannel].traits=traits;
}
-static inline void SetPixelb(const Image *restrict image,const Quantum b,
- Quantum *restrict pixel)
+static inline void SetPixelb(const Image *magick_restrict image,
+ const Quantum b,Quantum *magick_restrict pixel)
{
if (image->channel_map[bPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[bPixelChannel].offset]=b;
}
-static inline void SetPixelBackgoundColor(const Image *restrict image,
- Quantum *restrict pixel)
+static inline void SetPixelBackgoundColor(const Image *magick_restrict image,
+ Quantum *magick_restrict pixel)
{
register ssize_t
i;
ClampToQuantum(image->background_color.alpha);
}
-static inline void SetPixelBlack(const Image *restrict image,
- const Quantum black,Quantum *restrict pixel)
+static inline void SetPixelBlack(const Image *magick_restrict image,
+ const Quantum black,Quantum *magick_restrict pixel)
{
if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[BlackPixelChannel].offset]=black;
image->channel_map[BlackPixelChannel].traits=traits;
}
-static inline void SetPixelBlue(const Image *restrict image,const Quantum blue,
- Quantum *restrict pixel)
+static inline void SetPixelBlue(const Image *magick_restrict image,
+ const Quantum blue,Quantum *magick_restrict pixel)
{
pixel[image->channel_map[BluePixelChannel].offset]=blue;
}
image->channel_map[BluePixelChannel].traits=traits;
}
-static inline void SetPixelCb(const Image *restrict image,const Quantum cb,
- Quantum *restrict pixel)
+static inline void SetPixelCb(const Image *magick_restrict image,
+ const Quantum cb,Quantum *magick_restrict pixel)
{
pixel[image->channel_map[CbPixelChannel].offset]=cb;
}
image->channel_map[CbPixelChannel].traits=traits;
}
-static inline void SetPixelChannel(const Image *restrict image,
- const PixelChannel channel,const Quantum quantum,Quantum *restrict pixel)
+static inline void SetPixelChannel(const Image *magick_restrict image,
+ const PixelChannel channel,const Quantum quantum,
+ Quantum *magick_restrict pixel)
{
if (image->channel_map[channel].traits != UndefinedPixelTrait)
pixel[image->channel_map[channel].offset]=quantum;
}
-static inline void SetPixelChannelAttributes(const Image *restrict image,
- const PixelChannel channel,const PixelTrait traits,const ssize_t offset)
+static inline void SetPixelChannelAttributes(
+ const Image *magick_restrict image,const PixelChannel channel,
+ const PixelTrait traits,const ssize_t offset)
{
image->channel_map[offset].channel=channel;
image->channel_map[channel].offset=offset;
image->channel_map[channel].traits=traits;
}
-static inline void SetPixelChannelChannel(const Image *restrict image,
+static inline void SetPixelChannelChannel(const Image *magick_restrict image,
const PixelChannel channel,const ssize_t offset)
{
image->channel_map[offset].channel=channel;
image->channel_map[channel].traits=traits;
}
-static inline void SetPixelCr(const Image *restrict image,const Quantum cr,
- Quantum *restrict pixel)
+static inline void SetPixelCr(const Image *magick_restrict image,
+ const Quantum cr,Quantum *magick_restrict pixel)
{
pixel[image->channel_map[CrPixelChannel].offset]=cr;
}
image->channel_map[CrPixelChannel].traits=traits;
}
-static inline void SetPixelCyan(const Image *restrict image,const Quantum cyan,
- Quantum *restrict pixel)
+static inline void SetPixelCyan(const Image *magick_restrict image,
+ const Quantum cyan,Quantum *magick_restrict pixel)
{
pixel[image->channel_map[CyanPixelChannel].offset]=cyan;
}
-static inline void SetPixelGray(const Image *restrict image,const Quantum gray,
- Quantum *restrict pixel)
+static inline void SetPixelGray(const Image *magick_restrict image,
+ const Quantum gray,Quantum *magick_restrict pixel)
{
pixel[image->channel_map[GrayPixelChannel].offset]=gray;
}
image->channel_map[GrayPixelChannel].traits=traits;
}
-static inline void SetPixelGreen(const Image *restrict image,
- const Quantum green,Quantum *restrict pixel)
+static inline void SetPixelGreen(const Image *magick_restrict image,
+ const Quantum green,Quantum *magick_restrict pixel)
{
pixel[image->channel_map[GreenPixelChannel].offset]=green;
}
image->channel_map[GreenPixelChannel].traits=traits;
}
-static inline void SetPixelIndex(const Image *restrict image,
- const Quantum index,Quantum *restrict pixel)
+static inline void SetPixelIndex(const Image *magick_restrict image,
+ const Quantum index,Quantum *magick_restrict pixel)
{
if (image->channel_map[IndexPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[IndexPixelChannel].offset]=index;
image->channel_map[IndexPixelChannel].traits=traits;
}
-static inline void SetPixelViaPixelInfo(const Image *restrict image,
- const PixelInfo *restrict pixel_info,Quantum *restrict pixel)
+static inline void SetPixelViaPixelInfo(const Image *magick_restrict image,
+ const PixelInfo *magick_restrict pixel_info,Quantum *magick_restrict pixel)
{
pixel[image->channel_map[RedPixelChannel].offset]=
ClampToQuantum(pixel_info->red);
ClampToQuantum(pixel_info->alpha);
}
-static inline void SetPixelL(const Image *restrict image,const Quantum L,
- Quantum *restrict pixel)
+static inline void SetPixelL(const Image *magick_restrict image,const Quantum L,
+ Quantum *magick_restrict pixel)
{
if (image->channel_map[LPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[LPixelChannel].offset]=L;
}
-static inline void SetPixelMagenta(const Image *restrict image,
- const Quantum magenta,Quantum *restrict pixel)
+static inline void SetPixelMagenta(const Image *magick_restrict image,
+ const Quantum magenta,Quantum *magick_restrict pixel)
{
pixel[image->channel_map[MagentaPixelChannel].offset]=magenta;
}
image->channel_map[MagentaPixelChannel].traits=traits;
}
-static inline void SetPixelReadMask(const Image *restrict image,
- const Quantum mask,Quantum *restrict pixel)
+static inline void SetPixelReadMask(const Image *magick_restrict image,
+ const Quantum mask,Quantum *magick_restrict pixel)
{
if (image->channel_map[ReadMaskPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[ReadMaskPixelChannel].offset]=mask;
}
-static inline void SetPixelWriteMask(const Image *restrict image,
- const Quantum mask,Quantum *restrict pixel)
+static inline void SetPixelWriteMask(const Image *magick_restrict image,
+ const Quantum mask,Quantum *magick_restrict pixel)
{
if (image->channel_map[WriteMaskPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[WriteMaskPixelChannel].offset]=mask;
image->metacontent_extent=extent;
}
-static inline void SetPixelOpacity(const Image *restrict image,
- const Quantum alpha,Quantum *restrict pixel)
+static inline void SetPixelOpacity(const Image *magick_restrict image,
+ const Quantum alpha,Quantum *magick_restrict pixel)
{
if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
pixel[image->channel_map[AlphaPixelChannel].offset]=QuantumRange-alpha;
}
-static inline void SetPixelRed(const Image *restrict image,const Quantum red,
- Quantum *restrict pixel)
+static inline void SetPixelRed(const Image *magick_restrict image,
+ const Quantum red,Quantum *magick_restrict pixel)
{
pixel[image->channel_map[RedPixelChannel].offset]=red;
}
image->channel_map[RedPixelChannel].traits=traits;
}
-static inline void SetPixelYellow(const Image *restrict image,
- const Quantum yellow,Quantum *restrict pixel)
+static inline void SetPixelYellow(const Image *magick_restrict image,
+ const Quantum yellow,Quantum *magick_restrict pixel)
{
pixel[image->channel_map[YellowPixelChannel].offset]=yellow;
}
image->channel_map[YellowPixelChannel].traits=traits;
}
-static inline void SetPixelY(const Image *restrict image,const Quantum y,
- Quantum *restrict pixel)
+static inline void SetPixelY(const Image *magick_restrict image,
+ const Quantum y,Quantum *magick_restrict pixel)
{
pixel[image->channel_map[YPixelChannel].offset]=y;
}
*/
static void ExportCharPixel(Image *image,const RectangleInfo *roi,
- const char *restrict map,const QuantumType *quantum_map,void *pixels,
+ const char *magick_restrict map,const QuantumType *quantum_map,void *pixels,
ExceptionInfo *exception)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register unsigned char
- *restrict q;
+ *magick_restrict q;
size_t
length;
}
static void ExportDoublePixel(Image *image,const RectangleInfo *roi,
- const char *restrict map,const QuantumType *quantum_map,void *pixels,
+ const char *magick_restrict map,const QuantumType *quantum_map,void *pixels,
ExceptionInfo *exception)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register double
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
}
static void ExportFloatPixel(Image *image,const RectangleInfo *roi,
- const char *restrict map,const QuantumType *quantum_map,void *pixels,
+ const char *magick_restrict map,const QuantumType *quantum_map,void *pixels,
ExceptionInfo *exception)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register float
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
}
static void ExportLongPixel(Image *image,const RectangleInfo *roi,
- const char *restrict map,const QuantumType *quantum_map,void *pixels,
+ const char *magick_restrict map,const QuantumType *quantum_map,void *pixels,
ExceptionInfo *exception)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register unsigned int
- *restrict q;
+ *magick_restrict q;
size_t
length;
}
static void ExportLongLongPixel(Image *image,const RectangleInfo *roi,
- const char *restrict map,const QuantumType *quantum_map,void *pixels,
+ const char *magick_restrict map,const QuantumType *quantum_map,void *pixels,
ExceptionInfo *exception)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register MagickSizeType
- *restrict q;
+ *magick_restrict q;
size_t
length;
}
static void ExportQuantumPixel(Image *image,const RectangleInfo *roi,
- const char *restrict map,const QuantumType *quantum_map,void *pixels,
+ const char *magick_restrict map,const QuantumType *quantum_map,void *pixels,
ExceptionInfo *exception)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
}
static void ExportShortPixel(Image *image,const RectangleInfo *roi,
- const char *restrict map,const QuantumType *quantum_map,void *pixels,
+ const char *magick_restrict map,const QuantumType *quantum_map,void *pixels,
ExceptionInfo *exception)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register unsigned short
- *restrict q;
+ *magick_restrict q;
size_t
length;
% o pixel: Specifies a pointer to a Quantum structure.
%
*/
-MagickExport MagickRealType GetPixelInfoIntensity(const Image *restrict image,
- const PixelInfo *restrict pixel)
+MagickExport MagickRealType GetPixelInfoIntensity(
+ const Image *magick_restrict image,const PixelInfo *magick_restrict pixel)
{
MagickRealType
blue,
% o pixel: Specifies a pointer to a Quantum structure.
%
*/
-MagickExport MagickRealType GetPixelIntensity(const Image *restrict image,
- const Quantum *restrict pixel)
+MagickExport MagickRealType GetPixelIntensity(const Image *magick_restrict image,
+ const Quantum *magick_restrict pixel)
{
MagickRealType
blue,
*/
static void ImportCharPixel(Image *image,const RectangleInfo *roi,
- const char *restrict map,const QuantumType *quantum_map,const void *pixels,
- ExceptionInfo *exception)
+ const char *magick_restrict map,const QuantumType *quantum_map,
+ const void *pixels,ExceptionInfo *exception)
{
register const unsigned char
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
}
static void ImportDoublePixel(Image *image,const RectangleInfo *roi,
- const char *restrict map,const QuantumType *quantum_map,const void *pixels,
- ExceptionInfo *exception)
+ const char *magick_restrict map,const QuantumType *quantum_map,
+ const void *pixels,ExceptionInfo *exception)
{
register const double
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
}
static void ImportFloatPixel(Image *image,const RectangleInfo *roi,
- const char *restrict map,const QuantumType *quantum_map,const void *pixels,
- ExceptionInfo *exception)
+ const char *magick_restrict map,const QuantumType *quantum_map,
+ const void *pixels,ExceptionInfo *exception)
{
register const float
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
}
static void ImportLongPixel(Image *image,const RectangleInfo *roi,
- const char *restrict map,const QuantumType *quantum_map,const void *pixels,
- ExceptionInfo *exception)
+ const char *magick_restrict map,const QuantumType *quantum_map,
+ const void *pixels,ExceptionInfo *exception)
{
register const unsigned int
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
}
static void ImportLongLongPixel(Image *image,const RectangleInfo *roi,
- const char *restrict map,const QuantumType *quantum_map,const void *pixels,
- ExceptionInfo *exception)
+ const char *magick_restrict map,const QuantumType *quantum_map,
+ const void *pixels,ExceptionInfo *exception)
{
register const MagickSizeType
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
}
static void ImportQuantumPixel(Image *image,const RectangleInfo *roi,
- const char *restrict map,const QuantumType *quantum_map,const void *pixels,
- ExceptionInfo *exception)
+ const char *magick_restrict map,const QuantumType *quantum_map,
+ const void *pixels,ExceptionInfo *exception)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
}
static void ImportShortPixel(Image *image,const RectangleInfo *roi,
- const char *restrict map,const QuantumType *quantum_map,const void *pixels,
- ExceptionInfo *exception)
+ const char *magick_restrict map,const QuantumType *quantum_map,
+ const void *pixels,ExceptionInfo *exception)
{
register const unsigned short
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
SetPixelMetaChannels(Image *,const size_t,ExceptionInfo *);
extern MagickExport MagickRealType
- GetPixelInfoIntensity(const Image *restrict,const PixelInfo *restrict)
- magick_hot_spot,
- GetPixelIntensity(const Image *restrict,const Quantum *restrict)
- magick_hot_spot;
+ GetPixelInfoIntensity(const Image *magick_restrict,
+ const PixelInfo *magick_restrict) magick_hot_spot,
+ GetPixelIntensity(const Image *magick_restrict,
+ const Quantum *magick_restrict) magick_hot_spot;
extern MagickExport PixelChannelMap
*AcquirePixelChannelMap(void),
target_profile;
cmsHTRANSFORM
- *restrict transform;
+ *magick_restrict transform;
cmsUInt32Number
flags,
y;
unsigned short
- **restrict source_pixels,
- **restrict target_pixels;
+ **magick_restrict source_pixels,
+ **magick_restrict target_pixels;
target_profile=(cmsHPROFILE) NULL;
if (icc_profile != (StringInfo *) NULL)
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
register unsigned short
*p;
cube;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
intensity;
register PixelInfo
- *restrict q;
+ *magick_restrict q;
register ssize_t
i;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y++; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
distance;
register PixelInfo
- *restrict p;
+ *magick_restrict p;
register RealPixelInfo
- *restrict q;
+ *magick_restrict q;
/*
Determine if this color is "closest".
alpha;
register PixelInfo
- *restrict q;
+ *magick_restrict q;
/*
Colormap entry is defined by the mean color in this cube.
*previous;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
(p->y >= 0) && (p->y < (ssize_t) image->rows))
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
i;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
proceed;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
%
% size_t ExportQuantumPixels(const Image *image,CacheView *image_view,
% QuantumInfo *quantum_info,const QuantumType quantum_type,
-% unsigned char *restrict pixels,ExceptionInfo *exception)
+% unsigned char *magick_restrict pixels,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
*/
static inline unsigned char *PopDoublePixel(QuantumInfo *quantum_info,
- const double pixel,unsigned char *restrict pixels)
+ const double pixel,unsigned char *magick_restrict pixels)
{
double
*p;
}
static inline unsigned char *PopFloatPixel(QuantumInfo *quantum_info,
- const float pixel,unsigned char *restrict pixels)
+ const float pixel,unsigned char *magick_restrict pixels)
{
float
*p;
}
static inline unsigned char *PopQuantumPixel(QuantumInfo *quantum_info,
- const QuantumAny pixel,unsigned char *restrict pixels)
+ const QuantumAny pixel,unsigned char *magick_restrict pixels)
{
register ssize_t
i;
}
static inline unsigned char *PopQuantumLongPixel(QuantumInfo *quantum_info,
- const size_t pixel,unsigned char *restrict pixels)
+ const size_t pixel,unsigned char *magick_restrict pixels)
{
register ssize_t
i;
}
static void ExportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ExportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ExportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ExportBGROQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ExportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ExportBlueQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ExportCbYCrYQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
Quantum
cbcr[4];
}
static void ExportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
register ssize_t
x;
}
static void ExportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
register ssize_t
x;
}
static void ExportCMYKOQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
register ssize_t
x;
}
static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ExportGreenQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ExportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
register ssize_t
x;
static void ExportIndexAlphaQuantum(const Image *image,
QuantumInfo *quantum_info,const MagickSizeType number_pixels,
- const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception)
+ const Quantum *magick_restrict p,unsigned char *magick_restrict q,
+ ExceptionInfo *exception)
{
register ssize_t
x;
}
static void ExportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ExportRedQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ExportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ExportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ExportRGBOQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const Quantum *restrict p,
- unsigned char *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const Quantum *magick_restrict p,
+ unsigned char *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
MagickExport size_t ExportQuantumPixels(const Image *image,
CacheView *image_view,QuantumInfo *quantum_info,
- const QuantumType quantum_type,unsigned char *restrict pixels,
+ const QuantumType quantum_type,unsigned char *magick_restrict pixels,
ExceptionInfo *exception)
{
MagickSizeType
number_pixels;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register unsigned char
- *restrict q;
+ *magick_restrict q;
size_t
extent;
Sa;
register Quantum
- *restrict q;
+ *magick_restrict q;
/*
Associate alpha.
quantum;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
quantum;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
%
% size_t ImportQuantumPixels(const Image *image,CacheView *image_view,
% QuantumInfo *quantum_info,const QuantumType quantum_type,
-% const unsigned char *restrict pixels,ExceptionInfo *exception)
+% const unsigned char *magick_restrict pixels,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
}
static inline const unsigned char *PushDoublePixel(QuantumInfo *quantum_info,
- const unsigned char *restrict pixels,double *pixel)
+ const unsigned char *magick_restrict pixels,double *pixel)
{
double
*p;
}
static inline const unsigned char *PushFloatPixel(QuantumInfo *quantum_info,
- const unsigned char *restrict pixels,float *pixel)
+ const unsigned char *magick_restrict pixels,float *pixel)
{
float
*p;
}
static inline const unsigned char *PushQuantumPixel(QuantumInfo *quantum_info,
- const unsigned char *restrict pixels,unsigned int *quantum)
+ const unsigned char *magick_restrict pixels,unsigned int *quantum)
{
register ssize_t
i;
}
static inline const unsigned char *PushQuantumLongPixel(
- QuantumInfo *quantum_info,const unsigned char *restrict pixels,
+ QuantumInfo *quantum_info,const unsigned char *magick_restrict pixels,
unsigned int *quantum)
{
register ssize_t
}
static void ImportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportBGROQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportBlueQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportCbYCrYQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportCMYKOQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportGreenQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
MagickBooleanType
range_exception;
static void ImportIndexAlphaQuantum(const Image *image,
QuantumInfo *quantum_info,const MagickSizeType number_pixels,
- const unsigned char *restrict p,Quantum *restrict q,ExceptionInfo *exception)
+ const unsigned char *magick_restrict p,Quantum *magick_restrict q,
+ ExceptionInfo *exception)
{
MagickBooleanType
range_exception;
}
static void ImportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportRedQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
}
static void ImportRGBOQuantum(const Image *image,QuantumInfo *quantum_info,
- const MagickSizeType number_pixels,const unsigned char *restrict p,
- Quantum *restrict q,ExceptionInfo *exception)
+ const MagickSizeType number_pixels,const unsigned char *magick_restrict p,
+ Quantum *magick_restrict q,ExceptionInfo *exception)
{
QuantumAny
range;
MagickExport size_t ImportQuantumPixels(const Image *image,
CacheView *image_view,QuantumInfo *quantum_info,
- const QuantumType quantum_type,const unsigned char *restrict pixels,
+ const QuantumType quantum_type,const unsigned char *magick_restrict pixels,
ExceptionInfo *exception)
{
MagickSizeType
number_pixels;
register const unsigned char
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
size_t
extent;
quantum;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetAuthenticPixelQueue(image);
if (image_view != (CacheView *) NULL)
Sa;
register Quantum
- *restrict q;
+ *magick_restrict q;
/*
Disassociate alpha.
extern MagickExport size_t
ExportQuantumPixels(const Image *,CacheView *,QuantumInfo *,const QuantumType,
- unsigned char *restrict,ExceptionInfo *),
+ unsigned char *magick_restrict,ExceptionInfo *),
GetQuantumExtent(const Image *,const QuantumInfo *,const QuantumType),
ImportQuantumPixels(const Image *,CacheView *,QuantumInfo *,const QuantumType,
- const unsigned char *restrict,ExceptionInfo *);
+ const unsigned char *magick_restrict,ExceptionInfo *);
extern MagickExport unsigned char
*GetQuantumPixels(const QuantumInfo *);
offset;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
while (lqr_carver_scan_ext(carver,&x_offset,&y_offset,(void **) &packet) != 0)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
i;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
intensity[9];
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict r;
+ *magick_restrict r;
register ssize_t
i;
storage_class;
ContributionInfo
- **restrict contributions;
+ **magick_restrict contributions;
MagickBooleanType
status;
density;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ContributionInfo
- *restrict contribution;
+ *magick_restrict contribution;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
y;
storage_class;
ContributionInfo
- **restrict contributions;
+ **magick_restrict contributions;
double
scale,
density;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ContributionInfo
- *restrict contribution;
+ *magick_restrict contribution;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) sample_image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) scale_image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
*cluster;
register const PixelInfo
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
i,
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
i,
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
sync;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
y;
for (y=0; y < (ssize_t) width; y++)
{
register const Quantum
- *restrict tile_pixels;
+ *magick_restrict tile_pixels;
register ssize_t
x;
sync;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
sync;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
y;
for (y=0; y < (ssize_t) width; y++)
{
register const Quantum
- *restrict tile_pixels;
+ *magick_restrict tile_pixels;
register ssize_t
x;
displacement;
register Quantum
- *restrict p,
- *restrict q;
+ *magick_restrict p,
+ *magick_restrict q;
register ssize_t
i;
destination;
register Quantum
- *restrict p,
- *restrict q;
+ *magick_restrict p,
+ *magick_restrict q;
register ssize_t
i;
progress;
PixelChannels
- **restrict evaluate_pixels;
+ **magick_restrict evaluate_pixels;
RandomInfo
- **restrict random_info;
+ **magick_restrict random_info;
size_t
number_images;
*evaluate_pixel;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
*evaluate_pixel;
register Quantum
- *restrict q;
+ *magick_restrict q;
ssize_t
j;
progress;
RandomInfo
- **restrict random_info;
+ **magick_restrict random_info;
ssize_t
y;
id = GetOpenMPThreadId();
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
row_initialize;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
progress;
PixelChannels
- **restrict polynomial_pixels;
+ **magick_restrict polynomial_pixels;
size_t
number_images;
*polynomial_pixel;
register Quantum
- *restrict q;
+ *magick_restrict q;
ssize_t
j;
progress;
PixelList
- **restrict pixel_list;
+ **magick_restrict pixel_list;
ssize_t
center,
id = GetOpenMPThreadId();
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
pixel;
register const Quantum
- *restrict pixels;
+ *magick_restrict pixels;
register ssize_t
u;
return(value);
}
-static inline double StringToDouble(const char *restrict string,
- char **restrict sentinal)
+static inline double StringToDouble(const char *magick_restrict string,
+ char **magick_restrict sentinal)
{
return(InterpretLocaleValue(string,sentinal));
}
return(value);
}
-static inline int StringToInteger(const char *restrict value)
+static inline int StringToInteger(const char *magick_restrict value)
{
return((int) strtol(value,(char **) NULL,10));
}
-static inline long StringToLong(const char *restrict value)
+static inline long StringToLong(const char *magick_restrict value)
{
return(strtol(value,(char **) NULL,10));
}
-static inline unsigned long StringToUnsignedLong(const char *restrict value)
+static inline unsigned long StringToUnsignedLong(
+ const char *magick_restrict value)
{
return(strtoul(value,(char **) NULL,10));
}
% after the last character used in the conversion.
%
*/
-MagickExport double InterpretSiPrefixValue(const char *restrict string,
- char **restrict sentinal)
+MagickExport double InterpretSiPrefixValue(const char *magick_restrict string,
+ char **magick_restrict sentinal)
{
char
*q;
*GetStringInfoPath(const StringInfo *);
extern MagickExport double
- InterpretSiPrefixValue(const char *restrict,char **restrict),
+ InterpretSiPrefixValue(const char *magick_restrict,char **magick_restrict),
*StringToArrayOfDoubles(const char *,ssize_t *,ExceptionInfo *);
extern MagickExport int
# include <stdlib.h>
# endif
#endif
-#if defined(_magickcore_restrict) && !defined(restrict)
-# define restrict _magickcore_restrict
+#if !defined(magick_restrict)
+# if !defined(_magickcore_restrict)
+# define magick_restrict restrict
+# else
+# define magick_restrict _magickcore_restrict
+# endif
#endif
#if defined(MAGICKCORE_HAVE_STRING_H)
# if !defined(STDC_HEADERS) && defined(MAGICKCORE_HAVE_MEMORY_H)
channel_sum[MaxPixelChannels];
register const Quantum
- *restrict p,
- *restrict pixels;
+ *magick_restrict p,
+ *magick_restrict pixels;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
i,
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
i;
register PixelInfo
- *restrict q;
+ *magick_restrict q;
q=image->colormap;
for (i=0; i < (ssize_t) image->colors; i++)
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
i;
register PixelInfo
- *restrict q;
+ *magick_restrict q;
q=image->colormap;
for (i=0; i < (ssize_t) image->colors; i++)
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
threshold;
RandomInfo
- **restrict random_info;
+ **magick_restrict random_info;
ssize_t
y;
id = GetOpenMPThreadId();
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
for (y=0; y < (ssize_t) extent.y; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
for (y=0; y < (ssize_t) (image->rows-(extent.y+extent.height)); y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
for (y=0; y < (ssize_t) images->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
p=GetCacheViewVirtualPixels(image_view,0,y,images->columns,1,exception);
q=QueueCacheViewAuthenticPixels(cmyk_view,0,y,cmyk_image->columns,1,
for (y=0; y < (ssize_t) crop_image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) excerpt_image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) flip_image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) flop_image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
sync;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) splice_geometry.y; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
y < (ssize_t) splice_image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
sync;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) bounding_box.height+2; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) bounding_box.height; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p,
- *restrict q;
+ *magick_restrict p,
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) component_image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetCacheViewAuthenticPixels(annotate_view,0,(ssize_t) y,
annotate_image->columns,1,exception);
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=QueueCacheViewAuthenticPixels(draw_view,0,(ssize_t) y,draw_image->columns,
1,exception);
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=GetCacheViewAuthenticPixels(draw_view,0,(ssize_t) y,draw_image->columns,1,
exception);
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
register size_t
pixel;
*affinity_image;
register Quantum
- *restrict q;
+ *magick_restrict q;
/*
Improve image appearance with error diffusion.
x;
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetCacheViewAuthenticPixels(image_view,0,(ssize_t) y,
image->columns,1,exception);
#if defined(_magickcore_inline) && !defined(inline)
# define inline _magickcore_inline
#endif
-#if defined(_magickcore_restrict) && !defined(restrict)
-# define restrict _magickcore_restrict
+#if !defined(magick_restrict)
+# if !defined(_magickcore_restrict)
+# define magick_restrict restrict
+# else
+# define magick_restrict _magickcore_restrict
+# endif
#endif
# if defined(__cplusplus) || defined(c_plusplus)
# undef inline
*mask_image;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
*mask_image;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
x;
register Quantum
- *restrict pixels;
+ *_magickcore_restrict pixels;
assert(iterator != (const PixelIterator *) NULL);
assert(iterator->signature == MagickWandSignature);
# include <stdlib.h>
# endif
#endif
-#if defined(_magickcore_restrict) && !defined(restrict)
-# define restrict _magickcore_restrict
+#if !defined(magick_restrict)
+# if !defined(_magickcore_restrict)
+# define magick_restrict restrict
+# else
+# define magick_restrict _magickcore_restrict
+# endif
#endif
#if defined(MAGICKCORE_HAVE_STRING_H)
# if !defined(STDC_HEADERS) && defined(MAGICKCORE_HAVE_MEMORY_H)
sync;
register const Quantum
- *restrict duplex_pixels,
- *restrict pixels;
+ *magick_restrict duplex_pixels,
+ *magick_restrict pixels;
register ssize_t
x;
register Quantum
- *restrict destination_pixels;
+ *magick_restrict destination_pixels;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict pixels;
+ *magick_restrict pixels;
if (status == MagickFalse)
continue;
sync;
register const Quantum
- *restrict pixels;
+ *magick_restrict pixels;
register ssize_t
x;
register Quantum
- *restrict destination_pixels;
+ *magick_restrict destination_pixels;
if (status == MagickFalse)
continue;
x;
register Quantum
- *restrict pixels;
+ *magick_restrict pixels;
if (status == MagickFalse)
continue;
scene;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register unsigned char
- *restrict q;
+ *magick_restrict q;
ssize_t
count,
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
*pixel_info;
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register unsigned char
- *restrict q;
+ *magick_restrict q;
ssize_t
count,
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=QueueAuthenticPixels(image,0,offset,image->columns,1,exception);
if (q == (Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (count != (ssize_t) length)
{
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
red;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
continue;
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (jpeg_read_scanlines(&jpeg_info,scanline,1) != 1)
{
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
if (image->storage_class == PseudoClass)
{
register PixelInfo
- *restrict p;
+ *magick_restrict p;
(void) FormatLocaleFile(file," \"colormapEntries\": %.20g,\n",
(double) image->colors);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
if (status == MagickFalse)
break;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
sync;
register Quantum
- *restrict q;
+ *magick_restrict q;
ssize_t
count,
sync;
register const unsigned char
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
ssize_t
count,
sync;
register const unsigned char
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
ssize_t
count,
sync;
register const unsigned char
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
ssize_t
count,
sync;
register Quantum
- *restrict q;
+ *magick_restrict q;
ssize_t
count,
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (y=(ssize_t) image->rows-1; y >= 0; y--)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) layer_info->image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
status;
register Quantum
- *restrict q;
+ *magick_restrict q;
status=TIFFReadPixels(tiff,bits_per_sample,0,y,(char *) pixels);
if (status == -1)
status;
register Quantum
- *restrict q;
+ *magick_restrict q;
status=TIFFReadPixels(tiff,bits_per_sample,0,y,(char *) pixels);
if (status == -1)
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
int
status;
status;
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
x;
register Quantum
- *restrict q,
- *restrict tile;
+ *magick_restrict q,
+ *magick_restrict tile;
size_t
columns_remaining,
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
%
*/
-static inline uint32_t ReadWebPLSBWord(const unsigned char *restrict data)
+static inline uint32_t ReadWebPLSBWord(
+ const unsigned char *magick_restrict data)
{
register const unsigned char
*p;
configure;
WebPDecBuffer
- *restrict webp_image = &configure.output;
+ *magick_restrict webp_image = &configure.output;
WebPBitstreamFeatures
- *restrict features = &configure.input;
+ *magick_restrict features = &configure.input;
/*
Open image file.
*pixel_info;
register uint32_t
- *restrict q;
+ *magick_restrict q;
ssize_t
y;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
projects / imagemagick / commitdiff