% MagickWand Wand View Methods %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% March 2003 %
% %
% %
-% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2014 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
CacheView
*view;
- size_t
- number_threads;
-
PixelWand
***pixel_wands;
wand_view->exception);
clone_view->view=CloneCacheView(wand_view->view);
clone_view->extent=wand_view->extent;
- clone_view->number_threads=wand_view->number_threads;
clone_view->exception=AcquireExceptionInfo();
InheritException(clone_view->exception,wand_view->exception);
- for (i=0; i < (ssize_t) wand_view->number_threads; i++)
+ for (i=0; i < (ssize_t) GetMagickResourceLimit(ThreadResource); i++)
clone_view->pixel_wands[i]=ClonePixelWands((const PixelWand **)
wand_view->pixel_wands[i],wand_view->extent.width);
clone_view->debug=wand_view->debug;
*/
static PixelWand ***DestroyPixelsThreadSet(PixelWand ***pixel_wands,
- const size_t number_wands,const size_t number_threads)
+ const size_t number_wands)
{
register ssize_t
i;
assert(pixel_wands != (PixelWand ***) NULL);
- for (i=0; i < (ssize_t) number_threads; i++)
+ for (i=0; i < (ssize_t) GetMagickResourceLimit(ThreadResource); i++)
if (pixel_wands[i] != (PixelWand **) NULL)
pixel_wands[i]=DestroyPixelWands(pixel_wands[i],number_wands);
pixel_wands=(PixelWand ***) RelinquishMagickMemory(pixel_wands);
assert(wand_view != (WandView *) NULL);
assert(wand_view->signature == WandSignature);
wand_view->pixel_wands=DestroyPixelsThreadSet(wand_view->pixel_wands,
- wand_view->extent.width,wand_view->number_threads);
+ wand_view->extent.width);
wand_view->image=DestroyImage(wand_view->image);
wand_view->view=DestroyCacheView(wand_view->view);
wand_view->exception=DestroyExceptionInfo(wand_view->exception);
WandView *duplex,WandView *destination,DuplexTransferWandViewMethod transfer,
void *context)
{
- ExceptionInfo
- *exception;
-
Image
*destination_image,
*source_image;
MagickOffsetType
progress;
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ size_t
+ height;
+#endif
+
ssize_t
y;
return(MagickFalse);
source_image=source->wand->images;
destination_image=destination->wand->images;
- exception=destination->exception;
- if (SetImageStorageClass(destination_image,DirectClass,exception) == MagickFalse)
+ status=SetImageStorageClass(destination_image,DirectClass,
+ destination->exception);
+ if (status == MagickFalse)
return(MagickFalse);
status=MagickTrue;
progress=0;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status) num_threads(source->number_threads)
+ height=source->extent.height-source->extent.y;
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ magick_threads(source_image,destination_image,height,1)
#endif
for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
{
duplex_pixels+=GetPixelChannels(duplex->image);
}
destination_pixels=GetCacheViewAuthenticPixels(destination->view,
- destination->extent.x,y,destination->extent.width,1,exception);
+ destination->extent.x,y,destination->extent.width,1,
+ destination->exception);
if (destination_pixels == (Quantum *) NULL)
{
status=MagickFalse;
if (transfer(source,duplex,destination,y,id,context) == MagickFalse)
status=MagickFalse;
destination_pixels=GetCacheViewAuthenticPixels(destination->view,
- destination->extent.x,y,destination->extent.width,1,exception);
+ destination->extent.x,y,destination->extent.width,1,
+ destination->exception);
for (x=0; x < (ssize_t) destination->extent.width; x++)
{
PixelGetQuantumPixel(destination->image,destination->pixel_wands[id][x],
destination_pixels);
destination_pixels+=GetPixelChannels(destination->image);
}
- sync=SyncCacheViewAuthenticPixels(destination->view,exception);
+ sync=SyncCacheViewAuthenticPixels(destination->view,destination->exception);
if (sync == MagickFalse)
- {
- InheritException(destination->exception,GetCacheViewException(
- source->view));
- status=MagickFalse;
- }
+ status=MagickFalse;
if (source_image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickWand_DuplexTransferWandViewIterator)
+ #pragma omp critical (MagickWand_DuplexTransferWandViewIterator)
#endif
proceed=SetImageProgress(source_image,source->description,progress++,
source->extent.height);
%
% The format of the GetWandViewException method is:
%
-% char *GetWandViewException(const PixelWand *wand_view,
+% char *GetWandViewException(const WandView *wand_view,
% ExceptionType *severity)
%
% A description of each parameter follows:
MagickOffsetType
progress;
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ size_t
+ height;
+#endif
+
ssize_t
y;
status=MagickTrue;
progress=0;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status) num_threads(source->number_threads)
+ height=source->extent.height-source->extent.y;
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ magick_threads(source_image,source_image,height,1)
#endif
for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
{
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickWand_GetWandViewIterator)
+ #pragma omp critical (MagickWand_GetWandViewIterator)
#endif
proceed=SetImageProgress(source_image,source->description,progress++,
source->extent.height);
%
*/
-static PixelWand ***AcquirePixelsThreadSet(const size_t number_wands,
- const size_t number_threads)
+static PixelWand ***AcquirePixelsThreadSet(const size_t number_wands)
{
PixelWand
***pixel_wands;
register ssize_t
i;
+ size_t
+ number_threads;
+
+ number_threads=GetOpenMPMaximumThreads();
pixel_wands=(PixelWand ***) AcquireQuantumMemory(number_threads,
sizeof(*pixel_wands));
if (pixel_wands == (PixelWand ***) NULL)
{
pixel_wands[i]=NewPixelWands(number_wands);
if (pixel_wands[i] == (PixelWand **) NULL)
- return(DestroyPixelsThreadSet(pixel_wands,number_wands,number_threads));
+ return(DestroyPixelsThreadSet(pixel_wands,number_wands));
}
return(pixel_wands);
}
WandExport WandView *NewWandView(MagickWand *wand)
{
+ ExceptionInfo
+ *exception;
+
WandView
*wand_view;
WandViewId,(double) wand_view->id);
wand_view->description=ConstantString("WandView");
wand_view->wand=wand;
- wand_view->view=AcquireCacheView(wand_view->wand->images);
+ exception=AcquireExceptionInfo();
+ wand_view->view=AcquireVirtualCacheView(wand_view->wand->images,exception);
wand_view->extent.width=wand->images->columns;
wand_view->extent.height=wand->images->rows;
- wand_view->number_threads=GetOpenMPMaximumThreads();
- wand_view->pixel_wands=AcquirePixelsThreadSet(wand_view->extent.width,
- wand_view->number_threads);
- wand_view->exception=AcquireExceptionInfo();
+ wand_view->pixel_wands=AcquirePixelsThreadSet(wand_view->extent.width);
+ wand_view->exception=exception;
if (wand_view->pixel_wands == (PixelWand ***) NULL)
ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
GetExceptionMessage(errno));
WandExport WandView *NewWandViewExtent(MagickWand *wand,const ssize_t x,
const ssize_t y,const size_t width,const size_t height)
{
+ ExceptionInfo
+ *exception;
+
WandView
*wand_view;
(void) FormatLocaleString(wand_view->name,MaxTextExtent,"%s-%.20g",
WandViewId,(double) wand_view->id);
wand_view->description=ConstantString("WandView");
- wand_view->view=AcquireCacheView(wand_view->wand->images);
+ exception=AcquireExceptionInfo();
+ wand_view->view=AcquireVirtualCacheView(wand_view->wand->images,exception);
wand_view->wand=wand;
wand_view->extent.width=width;
wand_view->extent.height=height;
wand_view->extent.x=x;
wand_view->extent.y=y;
- wand_view->number_threads=GetOpenMPMaximumThreads();
- wand_view->exception=AcquireExceptionInfo();
- wand_view->pixel_wands=AcquirePixelsThreadSet(wand_view->extent.width,
- wand_view->number_threads);
+ wand_view->exception=exception;
+ wand_view->pixel_wands=AcquirePixelsThreadSet(wand_view->extent.width);
if (wand_view->pixel_wands == (PixelWand ***) NULL)
ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
GetExceptionMessage(errno));
WandExport MagickBooleanType SetWandViewIterator(WandView *destination,
SetWandViewMethod set,void *context)
{
- ExceptionInfo
- *exception;
-
Image
*destination_image;
MagickOffsetType
progress;
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ size_t
+ height;
+#endif
+
ssize_t
y;
if (set == (SetWandViewMethod) NULL)
return(MagickFalse);
destination_image=destination->wand->images;
- exception=destination->exception;
- if (SetImageStorageClass(destination_image,DirectClass,exception) == MagickFalse)
+ status=SetImageStorageClass(destination_image,DirectClass,
+ destination->exception);
+ if (status == MagickFalse)
return(MagickFalse);
status=MagickTrue;
progress=0;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status) num_threads(destination->number_threads)
+ height=destination->extent.height-destination->extent.y;
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ magick_threads(destination_image,destination_image,height,1)
#endif
for (y=destination->extent.y; y < (ssize_t) destination->extent.height; y++)
{
if (status == MagickFalse)
continue;
pixels=GetCacheViewAuthenticPixels(destination->view,destination->extent.x,
- y,destination->extent.width,1,exception);
+ y,destination->extent.width,1,destination->exception);
if (pixels == (Quantum *) NULL)
{
- InheritException(destination->exception,GetCacheViewException(
- destination->view));
status=MagickFalse;
continue;
}
pixels);
pixels+=GetPixelChannels(destination->image);
}
- sync=SyncCacheViewAuthenticPixels(destination->view,exception);
+ sync=SyncCacheViewAuthenticPixels(destination->view,destination->exception);
if (sync == MagickFalse)
- {
- InheritException(destination->exception,GetCacheViewException(
- destination->view));
- status=MagickFalse;
- }
+ status=MagickFalse;
if (destination_image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickWand_SetWandViewIterator)
+ #pragma omp critical (MagickWand_SetWandViewIterator)
#endif
proceed=SetImageProgress(destination_image,destination->description,
progress++,destination->extent.height);
% %
% %
% %
-% S e t W a n d V i e w T h r e a d s %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% SetWandViewThreads() sets the number of threads in a thread team.
-%
-% The format of the SetWandViewDescription method is:
-%
-% void SetWandViewThreads(WandView *image_view,
-% const size_t number_threads)
-%
-% A description of each parameter follows:
-%
-% o image_view: the image view.
-%
-% o number_threads: the number of threads in a thread team.
-%
-*/
-MagickExport void SetWandViewThreads(WandView *image_view,
- const size_t number_threads)
-{
- assert(image_view != (WandView *) NULL);
- assert(image_view->signature == MagickSignature);
- image_view->number_threads=number_threads;
- if (number_threads > GetOpenMPMaximumThreads())
- image_view->number_threads=GetOpenMPMaximumThreads();
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
% T r a n s f e r W a n d V i e w I t e r a t o r %
% %
% %
WandExport MagickBooleanType TransferWandViewIterator(WandView *source,
WandView *destination,TransferWandViewMethod transfer,void *context)
{
- ExceptionInfo
- *exception;
-
Image
*destination_image,
*source_image;
MagickOffsetType
progress;
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ size_t
+ height;
+#endif
+
ssize_t
y;
return(MagickFalse);
source_image=source->wand->images;
destination_image=destination->wand->images;
- exception=destination->exception;
- if (SetImageStorageClass(destination_image,DirectClass,exception) == MagickFalse)
+ status=SetImageStorageClass(destination_image,DirectClass,
+ destination->exception);
+ if (status == MagickFalse)
return(MagickFalse);
status=MagickTrue;
progress=0;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status) num_threads(source->number_threads)
+ height=source->extent.height-source->extent.y;
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ magick_threads(source_image,destination_image,height,1)
#endif
for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
{
pixels+=GetPixelChannels(source->image);
}
destination_pixels=GetCacheViewAuthenticPixels(destination->view,
- destination->extent.x,y,destination->extent.width,1,exception);
+ destination->extent.x,y,destination->extent.width,1,
+ destination->exception);
if (destination_pixels == (Quantum *) NULL)
{
status=MagickFalse;
if (transfer(source,destination,y,id,context) == MagickFalse)
status=MagickFalse;
destination_pixels=GetCacheViewAuthenticPixels(destination->view,
- destination->extent.x,y,destination->extent.width,1,exception);
+ destination->extent.x,y,destination->extent.width,1,
+ destination->exception);
for (x=0; x < (ssize_t) destination->extent.width; x++)
{
PixelGetQuantumPixel(destination->image,destination->pixel_wands[id][x],
destination_pixels);
destination_pixels+=GetPixelChannels(destination->image);
}
- sync=SyncCacheViewAuthenticPixels(destination->view,exception);
+ sync=SyncCacheViewAuthenticPixels(destination->view,destination->exception);
if (sync == MagickFalse)
- {
- InheritException(destination->exception,GetCacheViewException(
- source->view));
- status=MagickFalse;
- }
+ status=MagickFalse;
if (source_image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickWand_TransferWandViewIterator)
+ #pragma omp critical (MagickWand_TransferWandViewIterator)
#endif
proceed=SetImageProgress(source_image,source->description,progress++,
source->extent.height);
WandExport MagickBooleanType UpdateWandViewIterator(WandView *source,
UpdateWandViewMethod update,void *context)
{
- ExceptionInfo
- *exception;
-
Image
*source_image;
MagickOffsetType
progress;
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ size_t
+ height;
+#endif
+
ssize_t
y;
if (update == (UpdateWandViewMethod) NULL)
return(MagickFalse);
source_image=source->wand->images;
- exception=source->exception;
- if (SetImageStorageClass(source_image,DirectClass,exception) == MagickFalse)
+ status=SetImageStorageClass(source_image,DirectClass,source->exception);
+ if (status == MagickFalse)
return(MagickFalse);
status=MagickTrue;
progress=0;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status) num_threads(source->number_threads)
+ height=source->extent.height-source->extent.y;
+ #pragma omp parallel for schedule(static,4) shared(progress,status) \
+ magick_threads(source_image,source_image,height,1)
#endif
for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
{
const int
id = GetOpenMPThreadId();
+ MagickBooleanType
+ sync;
+
register ssize_t
x;
if (status == MagickFalse)
continue;
pixels=GetCacheViewAuthenticPixels(source->view,source->extent.x,y,
- source->extent.width,1,exception);
+ source->extent.width,1,source->exception);
if (pixels == (Quantum *) NULL)
{
- InheritException(source->exception,GetCacheViewException(
- source->view));
status=MagickFalse;
continue;
}
PixelGetQuantumPixel(source->image,source->pixel_wands[id][x],pixels);
pixels+=GetPixelChannels(source->image);
}
- if (SyncCacheViewAuthenticPixels(source->view,exception) == MagickFalse)
- {
- InheritException(source->exception,GetCacheViewException(source->view));
- status=MagickFalse;
- }
+ sync=SyncCacheViewAuthenticPixels(source->view,source->exception);
+ if (sync == MagickFalse)
+ status=MagickFalse;
if (source_image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickWand_UpdateWandViewIterator)
+ #pragma omp critical (MagickWand_UpdateWandViewIterator)
#endif
proceed=SetImageProgress(source_image,source->description,progress++,
source->extent.height);
projects / imagemagick / blobdiff