diff --git a/.gitignore b/.gitignore index 85330b9..ca93e76 100644 --- a/.gitignore +++ b/.gitignore @@ -8,4 +8,6 @@ build jextract* logo* -libs/lib* \ No newline at end of file +libs/lib* +includes.txt +includes_filtered.txt diff --git a/generate_ffm_bindings.sh b/generate_ffm_bindings.sh index 8d52070..bcad7a8 100755 --- a/generate_ffm_bindings.sh +++ b/generate_ffm_bindings.sh @@ -32,394 +32,39 @@ fi echo " Found ImageMagick headers at \"$IMAGEMAGICK_INCLUDES_PATH\"..." echo " Found MagickWand headers at \"$MAGICKWAND_INCLUDES_PATH\"..." +echo "Clearing generated files..." + +rm -rf lib/src/main/java/app/photofox/imffm/generated || true + +echo "Dumping all discovered includes..." + +"$JEXTRACT_DOWNLOAD_PATH"/bin/jextract \ +--define-macro MAGICKCORE_HDRI_ENABLE \ +--include-dir "$IMAGEMAGICK_INCLUDES_PATH" \ +--library "MagickWand-7.Q16HDRI" \ +--dump-includes includes.txt \ +"$MAGICKWAND_ENTRY_PATH" + +echo "Filtering includes..." + +grep -E ' [A-Za-z0-9_]*Magick[A-Za-z0-9]*' includes.txt > includes_filtered.txt +grep -E ' [A-Za-z0-9_]*Exception[A-Za-z0-9]*' includes.txt >> includes_filtered.txt +grep -E ' [A-Za-z0-9_]*Filter[A-Za-z0-9]*' includes.txt >> includes_filtered.txt +grep -E ' [A-Za-z0-9_]*Mogrify[A-Za-z0-9]*' includes.txt >> includes_filtered.txt +grep -E ' [A-Za-z0-9_]*Montage[A-Za-z0-9]*' includes.txt >> includes_filtered.txt +grep -E ' [A-Za-z0-9_]*PixelInfo[A-Za-z0-9]*' includes.txt >> includes_filtered.txt +grep -E ' [A-Za-z0-9_]*RectangleInfo[A-Za-z0-9]*' includes.txt >> includes_filtered.txt +grep -E ' [A-Za-z0-9_]*Wand[A-Za-z0-9]*' includes.txt >> includes_filtered.txt +grep -E ' [A-Za-z0-9_]+Command[A-Za-z0-9]*' includes.txt >> includes_filtered.txt +grep -E ' [A-Za-z0-9_]+Iterator[A-Za-z0-9]*' includes.txt >> includes_filtered.txt + echo "Running jextract..." -# https://imagemagick.org/api/magick-wand.php -# https://imagemagick.org/api/magick-image.php -# https://imagemagick.org/api/magick-property.php "$JEXTRACT_DOWNLOAD_PATH"/bin/jextract \ --define-macro MAGICKCORE_HDRI_ENABLE \ --include-dir "$IMAGEMAGICK_INCLUDES_PATH" \ ---include-constant "ExceptionType" \ ---include-constant "FilterType" \ ---include-constant "LanczosFilter" \ ---include-function "ClearMagickWand" \ ---include-function "CloneMagickWand" \ ---include-function "DestroyMagickWand" \ ---include-function "IsMagickWand" \ ---include-function "MagickClearException" \ ---include-function "MagickGetException" \ ---include-function "MagickGetExceptionType" \ ---include-function "MagickGetIteratorIndex" \ ---include-function "MagickQueryConfigureOption" \ ---include-function "MagickQueryConfigureOptions" \ ---include-function "MagickQueryFontMetrics" \ ---include-function "MagickQueryMultilineFontMetrics" \ ---include-function "MagickQueryFonts" \ ---include-function "MagickQueryFormats" \ ---include-function "MagickRelinquishMemory" \ ---include-function "MagickResetIterator" \ ---include-function "MagickSetFirstIterator" \ ---include-function "MagickSetIteratorIndex" \ ---include-function "MagickSetLastIterator" \ ---include-function "MagickWandGenesis" \ ---include-function "MagickWandTerminus" \ ---include-function "NewMagickWand" \ ---include-function "NewMagickWandFromImage" \ ---include-function "GetImageFromMagickWand" \ ---include-function "MagickAdaptiveBlurImage" \ ---include-function "MagickAdaptiveResizeImage" \ ---include-function "MagickAdaptiveSharpenImage" \ ---include-function "MagickAdaptiveThresholdImage" \ ---include-function "MagickAddImage" \ ---include-function "MagickAddNoiseImage" \ ---include-function "MagickAffineTransformImage" \ ---include-function "MagickAnnotateImage" \ ---include-function "MagickAnimateImages" \ ---include-function "MagickAppendImages" \ ---include-function "MagickAutoGammaImage" \ ---include-function "MagickAutoLevelImage" \ ---include-function "MagickAutoOrientImage" \ ---include-function "MagickAutoThresholdImage" \ ---include-function "MagickBilateralBlurImage" \ ---include-function "MagickBlackThresholdImage" \ ---include-function "MagickBlueShiftImage" \ ---include-function "MagickBlurImage" \ ---include-function "MagickBorderImage" \ ---include-function "MagickBrightnessContrastImage" \ ---include-function "MagickCannyEdgeImage" \ ---include-function "MagickChannelFxImage" \ ---include-function "MagickCharcoalImage" \ ---include-function "MagickChopImage" \ ---include-function "MagickCLAHEImage" \ ---include-function "MagickClampImage" \ ---include-function "MagickClipImage" \ ---include-function "MagickClipImagePath" \ ---include-function "MagickClutImage" \ ---include-function "MagickCoalesceImages" \ ---include-function "MagickColorDecisionListImage" \ ---include-function "MagickColorizeImage" \ ---include-function "MagickColorMatrixImage" \ ---include-function "MagickColorThresholdImage" \ ---include-function "MagickCombineImages" \ ---include-function "MagickCommentImage" \ ---include-function "MagickCompareImagesLayers" \ ---include-function "MagickCompareImages" \ ---include-function "MagickComplexImages" \ ---include-function "MagickCompositeImage" \ ---include-function "MagickCompositeImageGravity" \ ---include-function "MagickCompositeLayers" \ ---include-function "MagickConnectedComponentsImage" \ ---include-function "MagickContrastImage" \ ---include-function "MagickContrastStretchImage" \ ---include-function "MagickConvolveImage" \ ---include-function "MagickCropImage" \ ---include-function "MagickCycleColormapImage" \ ---include-function "MagickConstituteImage" \ ---include-function "MagickDecipherImage" \ ---include-function "MagickDeconstructImages" \ ---include-function "MagickDeskewImage" \ ---include-function "MagickDespeckleImage" \ ---include-function "MagickDestroyImage" \ ---include-function "MagickDisplayImage" \ ---include-function "MagickDisplayImages" \ ---include-function "MagickDistortImage" \ ---include-function "MagickDrawImage" \ ---include-function "MagickEdgeImage" \ ---include-function "MagickEmbossImage" \ ---include-function "MagickEncipherImage" \ ---include-function "MagickEnhanceImage" \ ---include-function "MagickEqualizeImage" \ ---include-function "MagickEvaluateImage" \ ---include-function "MagickExportImagePixels" \ ---include-function "MagickExtentImage" \ ---include-function "MagickFlipImage" \ ---include-function "MagickFloodfillPaintImage" \ ---include-function "MagickFlopImage" \ ---include-function "MagickForwardFourierTransformImage" \ ---include-function "MagickFrameImage" \ ---include-function "MagickFunctionImage" \ ---include-function "MagickFxImage" \ ---include-function "MagickGammaImage" \ ---include-function "MagickGaussianBlurImage" \ ---include-function "MagickGetImage" \ ---include-function "MagickGetImageAlphaChannel" \ ---include-function "MagickGetImageMask" \ ---include-function "MagickGetImageBackgroundColor" \ ---include-function "MagickGetImageBlob" \ ---include-function "MagickGetImagesBlob" \ ---include-function "MagickGetImageBluePrimary" \ ---include-function "MagickGetImageBorderColor" \ ---include-function "MagickGetImageFeatures" \ ---include-function "MagickGetImageKurtosis" \ ---include-function "MagickGetImageMean" \ ---include-function "MagickGetImageRange" \ ---include-function "MagickGetImageStatistics" \ ---include-function "MagickGetImageColormapColor" \ ---include-function "MagickGetImageColors" \ ---include-function "MagickGetImageColorspace" \ ---include-function "MagickGetImageCompose" \ ---include-function "MagickGetImageCompression" \ ---include-function "MagickGetImageCompressionQuality" \ ---include-function "MagickGetImageDelay" \ ---include-function "MagickGetImageDepth" \ ---include-function "MagickGetImageDispose" \ ---include-function "MagickGetImageDistortion" \ ---include-function "MagickGetImageDistortions" \ ---include-function "MagickGetImageEndian" \ ---include-function "MagickGetImageFilename" \ ---include-function "MagickGetImageFilter" \ ---include-function "MagickGetImageFormat" \ ---include-function "MagickGetImageFuzz" \ ---include-function "MagickGetImageGamma" \ ---include-function "MagickGetImageGravity" \ ---include-function "MagickGetImageGreenPrimary" \ ---include-function "MagickGetImageHeight" \ ---include-function "MagickGetImageHistogram" \ ---include-function "MagickGetImageInterlaceScheme" \ ---include-function "MagickGetImageInterpolateMethod" \ ---include-function "MagickGetImageIterations" \ ---include-function "MagickGetImageLength" \ ---include-function "MagickGetImageMatteColor" \ ---include-function "MagickGetImageOrientation" \ ---include-function "MagickGetImagePage" \ ---include-function "MagickGetImagePixelColor" \ ---include-function "MagickGetImageRedPrimary" \ ---include-function "MagickGetImageRegion" \ ---include-function "MagickGetImageRenderingIntent" \ ---include-function "MagickGetImageResolution" \ ---include-function "MagickGetImageScene" \ ---include-function "MagickGetImageSignature" \ ---include-function "MagickGetImageTicksPerSecond" \ ---include-function "MagickGetImageType" \ ---include-function "MagickGetImageUnits" \ ---include-function "MagickGetImageVirtualPixelMethod" \ ---include-function "MagickGetImageWhitePoint" \ ---include-function "MagickGetImageWidth" \ ---include-function "MagickGetNumberImages" \ ---include-function "MagickGetImageTotalInkDensity" \ ---include-function "MagickHaldClutImage" \ ---include-function "MagickHasNextImage" \ ---include-function "MagickHasPreviousImage" \ ---include-function "MagickHoughLineImage" \ ---include-function "MagickIdentifyImage" \ ---include-function "MagickIdentifyImageType" \ ---include-function "MagickImplodeImage" \ ---include-function "MagickImportImagePixels" \ ---include-function "MagickInterpolativeResizeImage" \ ---include-function "MagickInverseFourierTransformImage" \ ---include-function "MagickKmeansImage" \ ---include-function "MagickKuwaharaImage" \ ---include-function "MagickLabelImage" \ ---include-function "MagickLevelImage" \ ---include-function "MagickLevelImageColors" \ ---include-function "MagickLevelizeImage" \ ---include-function "MagickLinearStretchImage" \ ---include-function "MagickLiquidRescaleImage" \ ---include-function "MagickLocalContrastImage" \ ---include-function "MagickMagnifyImage" \ ---include-function "MagickMeanShiftImage" \ ---include-function "MagickMergeImageLayers" \ ---include-function "MagickMinifyImage" \ ---include-function "MagickModulateImage" \ ---include-function "MagickMontageImage" \ ---include-function "MagickMorphImages" \ ---include-function "MagickMorphologyImage" \ ---include-function "MagickMotionBlurImage" \ ---include-function "MagickNegateImage" \ ---include-function "MagickNewImage" \ ---include-function "MagickNextImage" \ ---include-function "MagickNormalizeImage" \ ---include-function "MagickOilPaintImage" \ ---include-function "MagickOpaquePaintImage" \ ---include-function "MagickOptimizeImageLayers" \ ---include-function "MagickOptimizeImageTransparency" \ ---include-function "MagickOrderedDitherImage" \ ---include-function "MagickPingImage" \ ---include-function "MagickPingImageBlob" \ ---include-function "MagickPingImageFile" \ ---include-function "MagickPolaroidImage" \ ---include-function "MagickPolynomialImage" \ ---include-function "MagickPosterizeImage" \ ---include-function "MagickPreviewImages" \ ---include-function "MagickPreviousImage" \ ---include-function "MagickQuantizeImage" \ ---include-function "MagickQuantizeImages" \ ---include-function "MagickRangeThresholdImage" \ ---include-function "MagickRotationalBlurImage" \ ---include-function "MagickRaiseImage" \ ---include-function "MagickRandomThresholdImage" \ ---include-function "MagickReadImage" \ ---include-function "MagickReadImageBlob" \ ---include-function "MagickReadImageFile" \ ---include-function "MagickRemapImage" \ ---include-function "MagickRemoveImage" \ ---include-function "MagickResampleImage" \ ---include-function "MagickResetImagePage" \ ---include-function "MagickResizeImage" \ ---include-function "MagickRollImage" \ ---include-function "MagickRotateImage" \ ---include-function "MagickSampleImage" \ ---include-function "MagickScaleImage" \ ---include-function "MagickSegmentImage" \ ---include-function "MagickSelectiveBlurImage" \ ---include-function "MagickSeparateImage" \ ---include-function "MagickSepiaToneImage" \ ---include-function "MagickSetImage" \ ---include-function "MagickSetImageAlphaChannel" \ ---include-function "MagickSetImageBackgroundColor" \ ---include-function "MagickSetImageBluePrimary" \ ---include-function "MagickSetImageBorderColor" \ ---include-function "MagickSetImageChannelMask" \ ---include-function "MagickSetImageMask" \ ---include-function "MagickSetImageColor" \ ---include-function "MagickSetImageColormapColor" \ ---include-function "MagickSetImageColorspace" \ ---include-function "MagickSetImageCompose" \ ---include-function "MagickSetImageCompression" \ ---include-function "MagickSetImageCompressionQuality" \ ---include-function "MagickSetImageDelay" \ ---include-function "MagickSetImageDepth" \ ---include-function "MagickSetImageDispose" \ ---include-function "MagickSetImageEndian" \ ---include-function "MagickSetImageExtent" \ ---include-function "MagickSetImageFilename" \ ---include-function "MagickSetImageFilter" \ ---include-function "MagickSetImageFormat" \ ---include-function "MagickSetImageFuzz" \ ---include-function "MagickSetImageGamma" \ ---include-function "MagickSetImageGravity" \ ---include-function "MagickSetImageGreenPrimary" \ ---include-function "MagickSetImageInterlaceScheme" \ ---include-function "MagickSetImageInterpolateMethod" \ ---include-function "MagickSetImageIterations" \ ---include-function "MagickSetImageMatte" \ ---include-function "MagickSetImageMatteColor" \ ---include-function "MagickSetImageAlpha" \ ---include-function "MagickSetImageOrientation" \ ---include-function "MagickSetImagePage" \ ---include-function "MagickSetImagePixelColor" \ ---include-function "MagickSetImageProgressMonitor" \ ---include-function "MagickSetImageRedPrimary" \ ---include-function "MagickSetImageRenderingIntent" \ ---include-function "MagickSetImageResolution" \ ---include-function "MagickSetImageScene" \ ---include-function "MagickSetImageTicksPerSecond" \ ---include-function "MagickSetImageType" \ ---include-function "MagickSetImageUnits" \ ---include-function "MagickSetImageVirtualPixelMethod" \ ---include-function "MagickSetImageWhitePoint" \ ---include-function "MagickShadeImage" \ ---include-function "MagickShadowImage" \ ---include-function "MagickSharpenImage" \ ---include-function "MagickShaveImage" \ ---include-function "MagickShearImage" \ ---include-function "MagickSigmoidalContrastImage" \ ---include-function "MagickSimilarityImage" \ ---include-function "MagickSketchImage" \ ---include-function "MagickSmushImages" \ ---include-function "MagickSolarizeImage" \ ---include-function "MagickSparseColorImage" \ ---include-function "MagickSpliceImage" \ ---include-function "MagickSpreadImage" \ ---include-function "MagickStatisticImage" \ ---include-function "MagickSteganoImage" \ ---include-function "MagickStereoImage" \ ---include-function "MagickStripImage" \ ---include-function "MagickSwirlImage" \ ---include-function "MagickTextureImage" \ ---include-function "MagickThresholdImage" \ ---include-function "MagickThumbnailImage" \ ---include-function "MagickTintImage" \ ---include-function "MagickTransformImageColorspace" \ ---include-function "MagickTransparentPaintImage" \ ---include-function "MagickTransposeImage" \ ---include-function "MagickTransverseImage" \ ---include-function "MagickTrimImage" \ ---include-function "MagickUniqueImageColors" \ ---include-function "MagickUnsharpMaskImage" \ ---include-function "MagickVignetteImage" \ ---include-function "MagickWaveImage" \ ---include-function "MagickWaveletDenoiseImage" \ ---include-function "MagickWhiteBalanceImage" \ ---include-function "MagickWhiteThresholdImage" \ ---include-function "MagickWriteImage" \ ---include-function "MagickWriteImageFile" \ ---include-function "MagickWriteImages" \ ---include-typedef "MagickBooleanType" \ ---include-function "MagickDeleteImageArtifact" \ ---include-function "MagickDeleteImageProperty" \ ---include-function "MagickDeleteOption" \ ---include-function "MagickGetAntialias" \ ---include-function "MagickGetBackgroundColor" \ ---include-function "MagickGetColorspace" \ ---include-function "MagickGetCompression" \ ---include-function "MagickGetCompressionQuality" \ ---include-function "MagickGetCopyright" \ ---include-function "MagickGetFilename" \ ---include-function "MagickGetFont" \ ---include-function "MagickGetFormat" \ ---include-function "MagickGetFilter" \ ---include-function "MagickGetGravity" \ ---include-function "MagickGetHomeURL" \ ---include-function "MagickGetImageArtifact" \ ---include-function "MagickGetImageArtifacts" \ ---include-function "MagickGetImageProfile" \ ---include-function "MagickGetImageProfiles" \ ---include-function "MagickGetImageProperty" \ ---include-function "MagickGetImageProperties" \ ---include-function "MagickGetInterlaceScheme" \ ---include-function "MagickGetInterpolateMethod" \ ---include-function "MagickGetOption" \ ---include-function "MagickGetOptions" \ ---include-function "MagickGetOrientation" \ ---include-function "MagickGetPackageName" \ ---include-function "MagickGetPage" \ ---include-function "MagickGetPointsize" \ ---include-function "MagickGetQuantumDepth" \ ---include-function "MagickGetQuantumRange" \ ---include-function "MagickGetReleaseDate" \ ---include-function "MagickGetResolution" \ ---include-function "MagickGetResource" \ ---include-function "MagickGetResourceLimit" \ ---include-function "MagickGetSamplingFactors" \ ---include-function "MagickGetSize" \ ---include-function "MagickGetSizeOffset" \ ---include-function "MagickGetType" \ ---include-function "MagickGetVersion" \ ---include-function "MagickProfileImage" \ ---include-function "MagickRemoveImageProfile" \ ---include-function "MagickSetAntialias" \ ---include-function "MagickSetBackgroundColor" \ ---include-function "MagickSetColorspace" \ ---include-function "MagickSetCompression" \ ---include-function "MagickSetCompressionQuality" \ ---include-function "MagickSetDepth" \ ---include-function "MagickSetExtract" \ ---include-function "MagickSetFilename" \ ---include-function "MagickSetFont" \ ---include-function "MagickSetFormat" \ ---include-function "MagickSetFilter" \ ---include-function "MagickSetGravity" \ ---include-function "MagickSetImageArtifact" \ ---include-function "MagickSetImageProfile" \ ---include-function "MagickSetImageProperty" \ ---include-function "MagickSetInterlaceScheme" \ ---include-function "MagickSetInterpolateMethod" \ ---include-function "MagickSetOption" \ ---include-function "MagickSetOrientation" \ ---include-function "MagickSetPage" \ ---include-function "MagickSetPassphrase" \ ---include-function "MagickSetPointsize" \ ---include-function "MagickSetProgressMonitor" \ ---include-function "MagickSetResourceLimit" \ ---include-function "MagickSetResolution" \ ---include-function "MagickSetSamplingFactors" \ ---include-function "MagickSetSeed" \ ---include-function "MagickSetSecurityPolicy" \ ---include-function "MagickSetSize" \ ---include-function "MagickSetSizeOffset" \ --output lib/src/main/java \ --target-package "app.photofox.imffm.generated" \ --library "MagickWand-7.Q16HDRI" \ +@includes_filtered.txt \ "$MAGICKWAND_ENTRY_PATH" diff --git a/lib/src/main/java/app/photofox/imffm/generated/DuplexTransferWandViewMethod.java b/lib/src/main/java/app/photofox/imffm/generated/DuplexTransferWandViewMethod.java new file mode 100644 index 0000000..b87e8c7 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/DuplexTransferWandViewMethod.java @@ -0,0 +1,73 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef MagickBooleanType (*DuplexTransferWandViewMethod)(const WandView *, const WandView *, WandView *, const ssize_t, const int, void *) + * } + */ +public class DuplexTransferWandViewMethod { + + DuplexTransferWandViewMethod() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + int apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, int _x4, MemorySegment _x5); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = MagickWand_h.upcallHandle(DuplexTransferWandViewMethod.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(DuplexTransferWandViewMethod.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3, int _x4, MemorySegment _x5) { + try { + return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4, _x5); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/ExceptionInfo.java b/lib/src/main/java/app/photofox/imffm/generated/ExceptionInfo.java new file mode 100644 index 0000000..19b91d3 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/ExceptionInfo.java @@ -0,0 +1,26 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef struct _ExceptionInfo ExceptionInfo + * } + */ +public class ExceptionInfo extends _ExceptionInfo { + + ExceptionInfo() { + // Should not be called directly + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/GetWandViewMethod.java b/lib/src/main/java/app/photofox/imffm/generated/GetWandViewMethod.java new file mode 100644 index 0000000..a1a85a9 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/GetWandViewMethod.java @@ -0,0 +1,71 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef MagickBooleanType (*GetWandViewMethod)(const WandView *, const ssize_t, const int, void *) + * } + */ +public class GetWandViewMethod { + + GetWandViewMethod() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + int apply(MemorySegment _x0, long _x1, int _x2, MemorySegment _x3); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = MagickWand_h.upcallHandle(GetWandViewMethod.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(GetWandViewMethod.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static int invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1, int _x2, MemorySegment _x3) { + try { + return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/ImageFilterHandler.java b/lib/src/main/java/app/photofox/imffm/generated/ImageFilterHandler.java new file mode 100644 index 0000000..a703594 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/ImageFilterHandler.java @@ -0,0 +1,71 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef size_t (ImageFilterHandler)(Image **, const int, const char **, ExceptionInfo *) + * } + */ +public class ImageFilterHandler { + + ImageFilterHandler() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + long apply(MemorySegment _x0, int _x1, MemorySegment _x2, MemorySegment _x3); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = MagickWand_h.upcallHandle(ImageFilterHandler.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ImageFilterHandler.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static long invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2, MemorySegment _x3) { + try { + return (long) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/MagickCommand.java b/lib/src/main/java/app/photofox/imffm/generated/MagickCommand.java new file mode 100644 index 0000000..ce21987 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/MagickCommand.java @@ -0,0 +1,72 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef MagickBooleanType (*MagickCommand)(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ +public class MagickCommand { + + MagickCommand() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + int apply(MemorySegment _x0, int _x1, MemorySegment _x2, MemorySegment _x3, MemorySegment _x4); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = MagickWand_h.upcallHandle(MagickCommand.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(MagickCommand.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static int invoke(MemorySegment funcPtr,MemorySegment _x0, int _x1, MemorySegment _x2, MemorySegment _x3, MemorySegment _x4) { + try { + return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/MagickInfo.java b/lib/src/main/java/app/photofox/imffm/generated/MagickInfo.java new file mode 100644 index 0000000..62c7093 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/MagickInfo.java @@ -0,0 +1,42 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef struct _MagickInfo { + * char *name; + * char *description; + * char *version; + * char *mime_type; + * char *note; + * char *module; + * DecodeImageHandler *decoder; + * EncodeImageHandler *encoder; + * ImageInfo *image_info; + * IsImageFormatHandler *magick; + * MagickFormatType format_type; + * MagickStatusType flags; + * SemaphoreInfo *semaphore; + * size_t signature; + * void *client_data; + * } MagickInfo + * } + */ +public class MagickInfo extends _MagickInfo { + + MagickInfo() { + // Should not be called directly + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/MagickLogMethod.java b/lib/src/main/java/app/photofox/imffm/generated/MagickLogMethod.java new file mode 100644 index 0000000..1ac4f10 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/MagickLogMethod.java @@ -0,0 +1,68 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef void (*MagickLogMethod)(const LogEventType, const char *) + * } + */ +public class MagickLogMethod { + + MagickLogMethod() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + void apply(int _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = MagickWand_h.upcallHandle(MagickLogMethod.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(MagickLogMethod.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static void invoke(MemorySegment funcPtr,int _x0, MemorySegment _x1) { + try { + DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/MagickProgressMonitor.java b/lib/src/main/java/app/photofox/imffm/generated/MagickProgressMonitor.java new file mode 100644 index 0000000..e0fdae4 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/MagickProgressMonitor.java @@ -0,0 +1,71 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef MagickBooleanType (*MagickProgressMonitor)(const char *, const MagickOffsetType, const MagickSizeType, void *) + * } + */ +public class MagickProgressMonitor { + + MagickProgressMonitor() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + int apply(MemorySegment _x0, long _x1, long _x2, MemorySegment _x3); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG_LONG, + MagickWand_h.C_LONG_LONG, + MagickWand_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = MagickWand_h.upcallHandle(MagickProgressMonitor.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(MagickProgressMonitor.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static int invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1, long _x2, MemorySegment _x3) { + try { + return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/MagickWand_h.java b/lib/src/main/java/app/photofox/imffm/generated/MagickWand_h.java index fa83cd2..d767b30 100644 --- a/lib/src/main/java/app/photofox/imffm/generated/MagickWand_h.java +++ b/lib/src/main/java/app/photofox/imffm/generated/MagickWand_h.java @@ -69,139 +69,161 @@ static MemoryLayout align(MemoryLayout layout, long align) { public static final AddressLayout C_POINTER = ValueLayout.ADDRESS .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE)); public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG; - private static final int LanczosFilter = (int)22L; + private static final int MagickPathExtent = (int)4096L; /** * {@snippet lang=c : - * enum .LanczosFilter = 22 + * #define MagickPathExtent 4096 * } */ - public static int LanczosFilter() { - return LanczosFilter; + public static int MagickPathExtent() { + return MagickPathExtent; } - - private static class MagickGetFilename { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER - ); - - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetFilename"); - - public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + private static final int MagickTimeExtent = (int)26L; + /** + * {@snippet lang=c : + * #define MagickTimeExtent 26 + * } + */ + public static int MagickTimeExtent() { + return MagickTimeExtent; } - + private static final int MagickMaxBufferExtent = (int)81920L; /** - * Function descriptor for: * {@snippet lang=c : - * extern char *MagickGetFilename(const MagickWand *) + * #define MagickMaxBufferExtent 81920 * } */ - public static FunctionDescriptor MagickGetFilename$descriptor() { - return MagickGetFilename.DESC; + public static int MagickMaxBufferExtent() { + return MagickMaxBufferExtent; } - + private static final int MagickMinBufferExtent = (int)16384L; /** - * Downcall method handle for: * {@snippet lang=c : - * extern char *MagickGetFilename(const MagickWand *) + * #define MagickMinBufferExtent 16384 * } */ - public static MethodHandle MagickGetFilename$handle() { - return MagickGetFilename.HANDLE; + public static int MagickMinBufferExtent() { + return MagickMinBufferExtent; } - + private static final int MagickLibVersion = (int)1809L; /** - * Address for: * {@snippet lang=c : - * extern char *MagickGetFilename(const MagickWand *) + * #define MagickLibVersion 1809 * } */ - public static MemorySegment MagickGetFilename$address() { - return MagickGetFilename.ADDR; + public static int MagickLibVersion() { + return MagickLibVersion; } - + private static final int MagickLibInterface = (int)10L; /** * {@snippet lang=c : - * extern char *MagickGetFilename(const MagickWand *) + * #define MagickLibInterface 10 * } */ - public static MemorySegment MagickGetFilename(MemorySegment x0) { - var mh$ = MagickGetFilename.HANDLE; - try { - if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetFilename", x0); - } - return (MemorySegment)mh$.invokeExact(x0); - } catch (Throwable ex$) { - throw new AssertionError("should not reach here", ex$); - } + public static int MagickLibInterface() { + return MagickLibInterface; } - - private static class MagickGetFormat { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER - ); - - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetFormat"); - - public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + private static final int MagickLibMinInterface = (int)10L; + /** + * {@snippet lang=c : + * #define MagickLibMinInterface 10 + * } + */ + public static int MagickLibMinInterface() { + return MagickLibMinInterface; } - + private static final int MagickppLibInterface = (int)5L; /** - * Function descriptor for: * {@snippet lang=c : - * extern char *MagickGetFormat(MagickWand *) + * #define MagickppLibInterface 5 * } */ - public static FunctionDescriptor MagickGetFormat$descriptor() { - return MagickGetFormat.DESC; + public static int MagickppLibInterface() { + return MagickppLibInterface; } - + private static final int MagickppLibMinInterface = (int)5L; /** - * Downcall method handle for: * {@snippet lang=c : - * extern char *MagickGetFormat(MagickWand *) + * #define MagickppLibMinInterface 5 * } */ - public static MethodHandle MagickGetFormat$handle() { - return MagickGetFormat.HANDLE; + public static int MagickppLibMinInterface() { + return MagickppLibMinInterface; } - /** - * Address for: * {@snippet lang=c : - * extern char *MagickGetFormat(MagickWand *) + * typedef float MagickFloatType * } */ - public static MemorySegment MagickGetFormat$address() { - return MagickGetFormat.ADDR; + public static final OfFloat MagickFloatType = MagickWand_h.C_FLOAT; + /** + * {@snippet lang=c : + * typedef double MagickDoubleType + * } + */ + public static final OfDouble MagickDoubleType = MagickWand_h.C_DOUBLE; + /** + * {@snippet lang=c : + * typedef MagickDoubleType MagickRealType + * } + */ + public static final OfDouble MagickRealType = MagickWand_h.C_DOUBLE; + /** + * {@snippet lang=c : + * typedef unsigned int MagickStatusType + * } + */ + public static final OfInt MagickStatusType = MagickWand_h.C_INT; + /** + * {@snippet lang=c : + * typedef long long MagickOffsetType + * } + */ + public static final OfLong MagickOffsetType = MagickWand_h.C_LONG_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long long MagickSizeType + * } + */ + public static final OfLong MagickSizeType = MagickWand_h.C_LONG_LONG; + /** + * {@snippet lang=c : + * typedef uintptr_t MagickAddressType + * } + */ + public static final OfLong MagickAddressType = MagickWand_h.C_LONG; + private static final int MagickFalse = (int)0L; + /** + * {@snippet lang=c : + * enum .MagickFalse = 0 + * } + */ + public static int MagickFalse() { + return MagickFalse; } - + private static final int MagickTrue = (int)1L; /** * {@snippet lang=c : - * extern char *MagickGetFormat(MagickWand *) + * enum .MagickTrue = 1 * } */ - public static MemorySegment MagickGetFormat(MemorySegment x0) { - var mh$ = MagickGetFormat.HANDLE; - try { - if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetFormat", x0); - } - return (MemorySegment)mh$.invokeExact(x0); - } catch (Throwable ex$) { - throw new AssertionError("should not reach here", ex$); - } + public static int MagickTrue() { + return MagickTrue; } - private static class MagickGetFont { + private static class InterpolatePixelInfo { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetFont"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("InterpolatePixelInfo"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -209,55 +231,58 @@ private static class MagickGetFont { /** * Function descriptor for: * {@snippet lang=c : - * extern char *MagickGetFont(MagickWand *) + * extern MagickBooleanType InterpolatePixelInfo(const Image *, const CacheView_ *, const PixelInterpolateMethod, const double, const double, PixelInfo *, ExceptionInfo *) * } */ - public static FunctionDescriptor MagickGetFont$descriptor() { - return MagickGetFont.DESC; + public static FunctionDescriptor InterpolatePixelInfo$descriptor() { + return InterpolatePixelInfo.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char *MagickGetFont(MagickWand *) + * extern MagickBooleanType InterpolatePixelInfo(const Image *, const CacheView_ *, const PixelInterpolateMethod, const double, const double, PixelInfo *, ExceptionInfo *) * } */ - public static MethodHandle MagickGetFont$handle() { - return MagickGetFont.HANDLE; + public static MethodHandle InterpolatePixelInfo$handle() { + return InterpolatePixelInfo.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char *MagickGetFont(MagickWand *) + * extern MagickBooleanType InterpolatePixelInfo(const Image *, const CacheView_ *, const PixelInterpolateMethod, const double, const double, PixelInfo *, ExceptionInfo *) * } */ - public static MemorySegment MagickGetFont$address() { - return MagickGetFont.ADDR; + public static MemorySegment InterpolatePixelInfo$address() { + return InterpolatePixelInfo.ADDR; } /** * {@snippet lang=c : - * extern char *MagickGetFont(MagickWand *) + * extern MagickBooleanType InterpolatePixelInfo(const Image *, const CacheView_ *, const PixelInterpolateMethod, const double, const double, PixelInfo *, ExceptionInfo *) * } */ - public static MemorySegment MagickGetFont(MemorySegment x0) { - var mh$ = MagickGetFont.HANDLE; + public static int InterpolatePixelInfo(MemorySegment x0, MemorySegment x1, int x2, double x3, double x4, MemorySegment x5, MemorySegment x6) { + var mh$ = InterpolatePixelInfo.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetFont", x0); + traceDowncall("InterpolatePixelInfo", x0, x1, x2, x3, x4, x5, x6); } - return (MemorySegment)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5, x6); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetHomeURL { + private static class IsFuzzyEquivalencePixelInfo { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER ); + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetHomeURL"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("IsFuzzyEquivalencePixelInfo"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -265,58 +290,58 @@ private static class MagickGetHomeURL { /** * Function descriptor for: * {@snippet lang=c : - * extern char *MagickGetHomeURL() + * extern MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *, const PixelInfo *) * } */ - public static FunctionDescriptor MagickGetHomeURL$descriptor() { - return MagickGetHomeURL.DESC; + public static FunctionDescriptor IsFuzzyEquivalencePixelInfo$descriptor() { + return IsFuzzyEquivalencePixelInfo.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char *MagickGetHomeURL() + * extern MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *, const PixelInfo *) * } */ - public static MethodHandle MagickGetHomeURL$handle() { - return MagickGetHomeURL.HANDLE; + public static MethodHandle IsFuzzyEquivalencePixelInfo$handle() { + return IsFuzzyEquivalencePixelInfo.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char *MagickGetHomeURL() + * extern MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *, const PixelInfo *) * } */ - public static MemorySegment MagickGetHomeURL$address() { - return MagickGetHomeURL.ADDR; + public static MemorySegment IsFuzzyEquivalencePixelInfo$address() { + return IsFuzzyEquivalencePixelInfo.ADDR; } /** * {@snippet lang=c : - * extern char *MagickGetHomeURL() + * extern MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *, const PixelInfo *) * } */ - public static MemorySegment MagickGetHomeURL() { - var mh$ = MagickGetHomeURL.HANDLE; + public static int IsFuzzyEquivalencePixelInfo(MemorySegment x0, MemorySegment x1) { + var mh$ = IsFuzzyEquivalencePixelInfo.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetHomeURL"); + traceDowncall("IsFuzzyEquivalencePixelInfo", x0, x1); } - return (MemorySegment)mh$.invokeExact(); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageArtifact { + private static class GetPixelInfoIntensity { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageArtifact"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetPixelInfoIntensity"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -324,59 +349,57 @@ private static class MagickGetImageArtifact { /** * Function descriptor for: * {@snippet lang=c : - * extern char *MagickGetImageArtifact(MagickWand *, const char *) + * extern MagickRealType GetPixelInfoIntensity(const Image *restrict, const PixelInfo *restrict) * } */ - public static FunctionDescriptor MagickGetImageArtifact$descriptor() { - return MagickGetImageArtifact.DESC; + public static FunctionDescriptor GetPixelInfoIntensity$descriptor() { + return GetPixelInfoIntensity.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char *MagickGetImageArtifact(MagickWand *, const char *) + * extern MagickRealType GetPixelInfoIntensity(const Image *restrict, const PixelInfo *restrict) * } */ - public static MethodHandle MagickGetImageArtifact$handle() { - return MagickGetImageArtifact.HANDLE; + public static MethodHandle GetPixelInfoIntensity$handle() { + return GetPixelInfoIntensity.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char *MagickGetImageArtifact(MagickWand *, const char *) + * extern MagickRealType GetPixelInfoIntensity(const Image *restrict, const PixelInfo *restrict) * } */ - public static MemorySegment MagickGetImageArtifact$address() { - return MagickGetImageArtifact.ADDR; + public static MemorySegment GetPixelInfoIntensity$address() { + return GetPixelInfoIntensity.ADDR; } /** * {@snippet lang=c : - * extern char *MagickGetImageArtifact(MagickWand *, const char *) + * extern MagickRealType GetPixelInfoIntensity(const Image *restrict, const PixelInfo *restrict) * } */ - public static MemorySegment MagickGetImageArtifact(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickGetImageArtifact.HANDLE; + public static double GetPixelInfoIntensity(MemorySegment x0, MemorySegment x1) { + var mh$ = GetPixelInfoIntensity.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageArtifact", x0, x1); + traceDowncall("GetPixelInfoIntensity", x0, x1); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (double)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageArtifacts { + private static class ClonePixelInfo { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageArtifacts"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ClonePixelInfo"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -384,59 +407,59 @@ private static class MagickGetImageArtifacts { /** * Function descriptor for: * {@snippet lang=c : - * extern char **MagickGetImageArtifacts(MagickWand *, const char *, size_t *) + * extern PixelInfo *ClonePixelInfo(const PixelInfo *) * } */ - public static FunctionDescriptor MagickGetImageArtifacts$descriptor() { - return MagickGetImageArtifacts.DESC; + public static FunctionDescriptor ClonePixelInfo$descriptor() { + return ClonePixelInfo.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char **MagickGetImageArtifacts(MagickWand *, const char *, size_t *) + * extern PixelInfo *ClonePixelInfo(const PixelInfo *) * } */ - public static MethodHandle MagickGetImageArtifacts$handle() { - return MagickGetImageArtifacts.HANDLE; + public static MethodHandle ClonePixelInfo$handle() { + return ClonePixelInfo.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char **MagickGetImageArtifacts(MagickWand *, const char *, size_t *) + * extern PixelInfo *ClonePixelInfo(const PixelInfo *) * } */ - public static MemorySegment MagickGetImageArtifacts$address() { - return MagickGetImageArtifacts.ADDR; + public static MemorySegment ClonePixelInfo$address() { + return ClonePixelInfo.ADDR; } /** * {@snippet lang=c : - * extern char **MagickGetImageArtifacts(MagickWand *, const char *, size_t *) + * extern PixelInfo *ClonePixelInfo(const PixelInfo *) * } */ - public static MemorySegment MagickGetImageArtifacts(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickGetImageArtifacts.HANDLE; + public static MemorySegment ClonePixelInfo(MemorySegment x0) { + var mh$ = ClonePixelInfo.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageArtifacts", x0, x1, x2); + traceDowncall("ClonePixelInfo", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageProfiles { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( + private static class ConformPixelInfo { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageProfiles"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ConformPixelInfo"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -444,58 +467,57 @@ private static class MagickGetImageProfiles { /** * Function descriptor for: * {@snippet lang=c : - * extern char **MagickGetImageProfiles(MagickWand *, const char *, size_t *) + * extern void ConformPixelInfo(Image *, const PixelInfo *, PixelInfo *, ExceptionInfo *) * } */ - public static FunctionDescriptor MagickGetImageProfiles$descriptor() { - return MagickGetImageProfiles.DESC; + public static FunctionDescriptor ConformPixelInfo$descriptor() { + return ConformPixelInfo.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char **MagickGetImageProfiles(MagickWand *, const char *, size_t *) + * extern void ConformPixelInfo(Image *, const PixelInfo *, PixelInfo *, ExceptionInfo *) * } */ - public static MethodHandle MagickGetImageProfiles$handle() { - return MagickGetImageProfiles.HANDLE; + public static MethodHandle ConformPixelInfo$handle() { + return ConformPixelInfo.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char **MagickGetImageProfiles(MagickWand *, const char *, size_t *) + * extern void ConformPixelInfo(Image *, const PixelInfo *, PixelInfo *, ExceptionInfo *) * } */ - public static MemorySegment MagickGetImageProfiles$address() { - return MagickGetImageProfiles.ADDR; + public static MemorySegment ConformPixelInfo$address() { + return ConformPixelInfo.ADDR; } /** * {@snippet lang=c : - * extern char **MagickGetImageProfiles(MagickWand *, const char *, size_t *) + * extern void ConformPixelInfo(Image *, const PixelInfo *, PixelInfo *, ExceptionInfo *) * } */ - public static MemorySegment MagickGetImageProfiles(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickGetImageProfiles.HANDLE; + public static void ConformPixelInfo(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { + var mh$ = ConformPixelInfo.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageProfiles", x0, x1, x2); + traceDowncall("ConformPixelInfo", x0, x1, x2, x3); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2); + mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageProperty { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, + private static class GetPixelInfo { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageProperty"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetPixelInfo"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -503,59 +525,61 @@ private static class MagickGetImageProperty { /** * Function descriptor for: * {@snippet lang=c : - * extern char *MagickGetImageProperty(MagickWand *, const char *) + * extern void GetPixelInfo(const Image *, PixelInfo *) * } */ - public static FunctionDescriptor MagickGetImageProperty$descriptor() { - return MagickGetImageProperty.DESC; + public static FunctionDescriptor GetPixelInfo$descriptor() { + return GetPixelInfo.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char *MagickGetImageProperty(MagickWand *, const char *) + * extern void GetPixelInfo(const Image *, PixelInfo *) * } */ - public static MethodHandle MagickGetImageProperty$handle() { - return MagickGetImageProperty.HANDLE; + public static MethodHandle GetPixelInfo$handle() { + return GetPixelInfo.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char *MagickGetImageProperty(MagickWand *, const char *) + * extern void GetPixelInfo(const Image *, PixelInfo *) * } */ - public static MemorySegment MagickGetImageProperty$address() { - return MagickGetImageProperty.ADDR; + public static MemorySegment GetPixelInfo$address() { + return GetPixelInfo.ADDR; } /** * {@snippet lang=c : - * extern char *MagickGetImageProperty(MagickWand *, const char *) + * extern void GetPixelInfo(const Image *, PixelInfo *) * } */ - public static MemorySegment MagickGetImageProperty(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickGetImageProperty.HANDLE; + public static void GetPixelInfo(MemorySegment x0, MemorySegment x1) { + var mh$ = GetPixelInfo.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageProperty", x0, x1); + traceDowncall("GetPixelInfo", x0, x1); } - return (MemorySegment)mh$.invokeExact(x0, x1); + mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageProperties { + private static class GetOneCacheViewVirtualPixelInfo { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageProperties"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetOneCacheViewVirtualPixelInfo"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -563,58 +587,147 @@ private static class MagickGetImageProperties { /** * Function descriptor for: * {@snippet lang=c : - * extern char **MagickGetImageProperties(MagickWand *, const char *, size_t *) + * extern MagickBooleanType GetOneCacheViewVirtualPixelInfo(const CacheView *, const ssize_t, const ssize_t, PixelInfo *, ExceptionInfo *) * } */ - public static FunctionDescriptor MagickGetImageProperties$descriptor() { - return MagickGetImageProperties.DESC; + public static FunctionDescriptor GetOneCacheViewVirtualPixelInfo$descriptor() { + return GetOneCacheViewVirtualPixelInfo.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char **MagickGetImageProperties(MagickWand *, const char *, size_t *) + * extern MagickBooleanType GetOneCacheViewVirtualPixelInfo(const CacheView *, const ssize_t, const ssize_t, PixelInfo *, ExceptionInfo *) * } */ - public static MethodHandle MagickGetImageProperties$handle() { - return MagickGetImageProperties.HANDLE; + public static MethodHandle GetOneCacheViewVirtualPixelInfo$handle() { + return GetOneCacheViewVirtualPixelInfo.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char **MagickGetImageProperties(MagickWand *, const char *, size_t *) + * extern MagickBooleanType GetOneCacheViewVirtualPixelInfo(const CacheView *, const ssize_t, const ssize_t, PixelInfo *, ExceptionInfo *) * } */ - public static MemorySegment MagickGetImageProperties$address() { - return MagickGetImageProperties.ADDR; + public static MemorySegment GetOneCacheViewVirtualPixelInfo$address() { + return GetOneCacheViewVirtualPixelInfo.ADDR; } /** * {@snippet lang=c : - * extern char **MagickGetImageProperties(MagickWand *, const char *, size_t *) + * extern MagickBooleanType GetOneCacheViewVirtualPixelInfo(const CacheView *, const ssize_t, const ssize_t, PixelInfo *, ExceptionInfo *) * } */ - public static MemorySegment MagickGetImageProperties(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickGetImageProperties.HANDLE; + public static int GetOneCacheViewVirtualPixelInfo(MemorySegment x0, long x1, long x2, MemorySegment x3, MemorySegment x4) { + var mh$ = GetOneCacheViewVirtualPixelInfo.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageProperties", x0, x1, x2); + traceDowncall("GetOneCacheViewVirtualPixelInfo", x0, x1, x2, x3, x4); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - - private static class MagickGetOption { + private static final int UndefinedException = (int)0L; + /** + * {@snippet lang=c : + * enum .UndefinedException = 0 + * } + */ + public static int UndefinedException() { + return UndefinedException; + } + private static final int WarningException = (int)300L; + /** + * {@snippet lang=c : + * enum .WarningException = 300 + * } + */ + public static int WarningException() { + return WarningException; + } + private static final int FilterWarning = (int)352L; + /** + * {@snippet lang=c : + * enum .FilterWarning = 352 + * } + */ + public static int FilterWarning() { + return FilterWarning; + } + private static final int WandWarning = (int)370L; + /** + * {@snippet lang=c : + * enum .WandWarning = 370 + * } + */ + public static int WandWarning() { + return WandWarning; + } + private static final int ErrorException = (int)400L; + /** + * {@snippet lang=c : + * enum .ErrorException = 400 + * } + */ + public static int ErrorException() { + return ErrorException; + } + private static final int FilterError = (int)452L; + /** + * {@snippet lang=c : + * enum .FilterError = 452 + * } + */ + public static int FilterError() { + return FilterError; + } + private static final int WandError = (int)470L; + /** + * {@snippet lang=c : + * enum .WandError = 470 + * } + */ + public static int WandError() { + return WandError; + } + private static final int FatalErrorException = (int)700L; + /** + * {@snippet lang=c : + * enum .FatalErrorException = 700 + * } + */ + public static int FatalErrorException() { + return FatalErrorException; + } + private static final int FilterFatalError = (int)752L; + /** + * {@snippet lang=c : + * enum .FilterFatalError = 752 + * } + */ + public static int FilterFatalError() { + return FilterFatalError; + } + private static final int WandFatalError = (int)770L; + /** + * {@snippet lang=c : + * enum .WandFatalError = 770 + * } + */ + public static int WandFatalError() { + return WandFatalError; + } + + private static class GetExceptionMessage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetOption"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetExceptionMessage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -622,59 +735,58 @@ private static class MagickGetOption { /** * Function descriptor for: * {@snippet lang=c : - * extern char *MagickGetOption(MagickWand *, const char *) + * extern char *GetExceptionMessage(const int) * } */ - public static FunctionDescriptor MagickGetOption$descriptor() { - return MagickGetOption.DESC; + public static FunctionDescriptor GetExceptionMessage$descriptor() { + return GetExceptionMessage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char *MagickGetOption(MagickWand *, const char *) + * extern char *GetExceptionMessage(const int) * } */ - public static MethodHandle MagickGetOption$handle() { - return MagickGetOption.HANDLE; + public static MethodHandle GetExceptionMessage$handle() { + return GetExceptionMessage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char *MagickGetOption(MagickWand *, const char *) + * extern char *GetExceptionMessage(const int) * } */ - public static MemorySegment MagickGetOption$address() { - return MagickGetOption.ADDR; + public static MemorySegment GetExceptionMessage$address() { + return GetExceptionMessage.ADDR; } /** * {@snippet lang=c : - * extern char *MagickGetOption(MagickWand *, const char *) + * extern char *GetExceptionMessage(const int) * } */ - public static MemorySegment MagickGetOption(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickGetOption.HANDLE; + public static MemorySegment GetExceptionMessage(int x0) { + var mh$ = GetExceptionMessage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetOption", x0, x1); + traceDowncall("GetExceptionMessage", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetOptions { + private static class GetLocaleExceptionMessage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetOptions"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetLocaleExceptionMessage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -682,57 +794,55 @@ private static class MagickGetOptions { /** * Function descriptor for: * {@snippet lang=c : - * extern char **MagickGetOptions(MagickWand *, const char *, size_t *) + * extern const char *GetLocaleExceptionMessage(const ExceptionType, const char *) * } */ - public static FunctionDescriptor MagickGetOptions$descriptor() { - return MagickGetOptions.DESC; + public static FunctionDescriptor GetLocaleExceptionMessage$descriptor() { + return GetLocaleExceptionMessage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char **MagickGetOptions(MagickWand *, const char *, size_t *) + * extern const char *GetLocaleExceptionMessage(const ExceptionType, const char *) * } */ - public static MethodHandle MagickGetOptions$handle() { - return MagickGetOptions.HANDLE; + public static MethodHandle GetLocaleExceptionMessage$handle() { + return GetLocaleExceptionMessage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char **MagickGetOptions(MagickWand *, const char *, size_t *) + * extern const char *GetLocaleExceptionMessage(const ExceptionType, const char *) * } */ - public static MemorySegment MagickGetOptions$address() { - return MagickGetOptions.ADDR; + public static MemorySegment GetLocaleExceptionMessage$address() { + return GetLocaleExceptionMessage.ADDR; } /** * {@snippet lang=c : - * extern char **MagickGetOptions(MagickWand *, const char *, size_t *) + * extern const char *GetLocaleExceptionMessage(const ExceptionType, const char *) * } */ - public static MemorySegment MagickGetOptions(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickGetOptions.HANDLE; + public static MemorySegment GetLocaleExceptionMessage(int x0, MemorySegment x1) { + var mh$ = GetLocaleExceptionMessage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetOptions", x0, x1, x2); + traceDowncall("GetLocaleExceptionMessage", x0, x1); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickQueryConfigureOption { + private static class AcquireExceptionInfo { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER - ); + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQueryConfigureOption"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("AcquireExceptionInfo"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -740,58 +850,57 @@ private static class MagickQueryConfigureOption { /** * Function descriptor for: * {@snippet lang=c : - * extern char *MagickQueryConfigureOption(const char *) + * extern ExceptionInfo *AcquireExceptionInfo() * } */ - public static FunctionDescriptor MagickQueryConfigureOption$descriptor() { - return MagickQueryConfigureOption.DESC; + public static FunctionDescriptor AcquireExceptionInfo$descriptor() { + return AcquireExceptionInfo.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char *MagickQueryConfigureOption(const char *) + * extern ExceptionInfo *AcquireExceptionInfo() * } */ - public static MethodHandle MagickQueryConfigureOption$handle() { - return MagickQueryConfigureOption.HANDLE; + public static MethodHandle AcquireExceptionInfo$handle() { + return AcquireExceptionInfo.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char *MagickQueryConfigureOption(const char *) + * extern ExceptionInfo *AcquireExceptionInfo() * } */ - public static MemorySegment MagickQueryConfigureOption$address() { - return MagickQueryConfigureOption.ADDR; + public static MemorySegment AcquireExceptionInfo$address() { + return AcquireExceptionInfo.ADDR; } /** * {@snippet lang=c : - * extern char *MagickQueryConfigureOption(const char *) + * extern ExceptionInfo *AcquireExceptionInfo() * } */ - public static MemorySegment MagickQueryConfigureOption(MemorySegment x0) { - var mh$ = MagickQueryConfigureOption.HANDLE; + public static MemorySegment AcquireExceptionInfo() { + var mh$ = AcquireExceptionInfo.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickQueryConfigureOption", x0); + traceDowncall("AcquireExceptionInfo"); } - return (MemorySegment)mh$.invokeExact(x0); + return (MemorySegment)mh$.invokeExact(); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickQueryConfigureOptions { + private static class CloneExceptionInfo { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQueryConfigureOptions"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("CloneExceptionInfo"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -799,58 +908,57 @@ private static class MagickQueryConfigureOptions { /** * Function descriptor for: * {@snippet lang=c : - * extern char **MagickQueryConfigureOptions(const char *, size_t *) + * extern ExceptionInfo *CloneExceptionInfo(ExceptionInfo *) * } */ - public static FunctionDescriptor MagickQueryConfigureOptions$descriptor() { - return MagickQueryConfigureOptions.DESC; + public static FunctionDescriptor CloneExceptionInfo$descriptor() { + return CloneExceptionInfo.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char **MagickQueryConfigureOptions(const char *, size_t *) + * extern ExceptionInfo *CloneExceptionInfo(ExceptionInfo *) * } */ - public static MethodHandle MagickQueryConfigureOptions$handle() { - return MagickQueryConfigureOptions.HANDLE; + public static MethodHandle CloneExceptionInfo$handle() { + return CloneExceptionInfo.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char **MagickQueryConfigureOptions(const char *, size_t *) + * extern ExceptionInfo *CloneExceptionInfo(ExceptionInfo *) * } */ - public static MemorySegment MagickQueryConfigureOptions$address() { - return MagickQueryConfigureOptions.ADDR; + public static MemorySegment CloneExceptionInfo$address() { + return CloneExceptionInfo.ADDR; } /** * {@snippet lang=c : - * extern char **MagickQueryConfigureOptions(const char *, size_t *) + * extern ExceptionInfo *CloneExceptionInfo(ExceptionInfo *) * } */ - public static MemorySegment MagickQueryConfigureOptions(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickQueryConfigureOptions.HANDLE; + public static MemorySegment CloneExceptionInfo(MemorySegment x0) { + var mh$ = CloneExceptionInfo.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickQueryConfigureOptions", x0, x1); + traceDowncall("CloneExceptionInfo", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickQueryFonts { + private static class DestroyExceptionInfo { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQueryFonts"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DestroyExceptionInfo"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -858,58 +966,60 @@ private static class MagickQueryFonts { /** * Function descriptor for: * {@snippet lang=c : - * extern char **MagickQueryFonts(const char *, size_t *) + * extern ExceptionInfo *DestroyExceptionInfo(ExceptionInfo *) * } */ - public static FunctionDescriptor MagickQueryFonts$descriptor() { - return MagickQueryFonts.DESC; + public static FunctionDescriptor DestroyExceptionInfo$descriptor() { + return DestroyExceptionInfo.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char **MagickQueryFonts(const char *, size_t *) + * extern ExceptionInfo *DestroyExceptionInfo(ExceptionInfo *) * } */ - public static MethodHandle MagickQueryFonts$handle() { - return MagickQueryFonts.HANDLE; + public static MethodHandle DestroyExceptionInfo$handle() { + return DestroyExceptionInfo.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char **MagickQueryFonts(const char *, size_t *) + * extern ExceptionInfo *DestroyExceptionInfo(ExceptionInfo *) * } */ - public static MemorySegment MagickQueryFonts$address() { - return MagickQueryFonts.ADDR; + public static MemorySegment DestroyExceptionInfo$address() { + return DestroyExceptionInfo.ADDR; } /** * {@snippet lang=c : - * extern char **MagickQueryFonts(const char *, size_t *) + * extern ExceptionInfo *DestroyExceptionInfo(ExceptionInfo *) * } */ - public static MemorySegment MagickQueryFonts(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickQueryFonts.HANDLE; + public static MemorySegment DestroyExceptionInfo(MemorySegment x0) { + var mh$ = DestroyExceptionInfo.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickQueryFonts", x0, x1); + traceDowncall("DestroyExceptionInfo", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickQueryFormats { + private static class ThrowException { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQueryFormats"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ThrowException"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -917,57 +1027,64 @@ private static class MagickQueryFormats { /** * Function descriptor for: * {@snippet lang=c : - * extern char **MagickQueryFormats(const char *, size_t *) + * extern MagickBooleanType ThrowException(ExceptionInfo *, const ExceptionType, const char *, const char *) * } */ - public static FunctionDescriptor MagickQueryFormats$descriptor() { - return MagickQueryFormats.DESC; + public static FunctionDescriptor ThrowException$descriptor() { + return ThrowException.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char **MagickQueryFormats(const char *, size_t *) + * extern MagickBooleanType ThrowException(ExceptionInfo *, const ExceptionType, const char *, const char *) * } */ - public static MethodHandle MagickQueryFormats$handle() { - return MagickQueryFormats.HANDLE; + public static MethodHandle ThrowException$handle() { + return ThrowException.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char **MagickQueryFormats(const char *, size_t *) + * extern MagickBooleanType ThrowException(ExceptionInfo *, const ExceptionType, const char *, const char *) * } */ - public static MemorySegment MagickQueryFormats$address() { - return MagickQueryFormats.ADDR; + public static MemorySegment ThrowException$address() { + return ThrowException.ADDR; } /** * {@snippet lang=c : - * extern char **MagickQueryFormats(const char *, size_t *) + * extern MagickBooleanType ThrowException(ExceptionInfo *, const ExceptionType, const char *, const char *) * } */ - public static MemorySegment MagickQueryFormats(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickQueryFormats.HANDLE; + public static int ThrowException(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3) { + var mh$ = ThrowException.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickQueryFormats", x0, x1); + traceDowncall("ThrowException", x0, x1, x2, x3); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetColorspace { + private static class ThrowMagickExceptionList { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetColorspace"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ThrowMagickExceptionList"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -975,57 +1092,134 @@ private static class MagickGetColorspace { /** * Function descriptor for: * {@snippet lang=c : - * extern ColorspaceType MagickGetColorspace(MagickWand *) + * extern MagickBooleanType ThrowMagickExceptionList(ExceptionInfo *, const char *, const char *, const size_t, const ExceptionType, const char *, const char *, va_list) * } */ - public static FunctionDescriptor MagickGetColorspace$descriptor() { - return MagickGetColorspace.DESC; + public static FunctionDescriptor ThrowMagickExceptionList$descriptor() { + return ThrowMagickExceptionList.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern ColorspaceType MagickGetColorspace(MagickWand *) + * extern MagickBooleanType ThrowMagickExceptionList(ExceptionInfo *, const char *, const char *, const size_t, const ExceptionType, const char *, const char *, va_list) * } */ - public static MethodHandle MagickGetColorspace$handle() { - return MagickGetColorspace.HANDLE; + public static MethodHandle ThrowMagickExceptionList$handle() { + return ThrowMagickExceptionList.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern ColorspaceType MagickGetColorspace(MagickWand *) + * extern MagickBooleanType ThrowMagickExceptionList(ExceptionInfo *, const char *, const char *, const size_t, const ExceptionType, const char *, const char *, va_list) * } */ - public static MemorySegment MagickGetColorspace$address() { - return MagickGetColorspace.ADDR; + public static MemorySegment ThrowMagickExceptionList$address() { + return ThrowMagickExceptionList.ADDR; } /** * {@snippet lang=c : - * extern ColorspaceType MagickGetColorspace(MagickWand *) + * extern MagickBooleanType ThrowMagickExceptionList(ExceptionInfo *, const char *, const char *, const size_t, const ExceptionType, const char *, const char *, va_list) * } */ - public static int MagickGetColorspace(MemorySegment x0) { - var mh$ = MagickGetColorspace.HANDLE; + public static int ThrowMagickExceptionList(MemorySegment x0, MemorySegment x1, MemorySegment x2, long x3, int x4, MemorySegment x5, MemorySegment x6, MemorySegment x7) { + var mh$ = ThrowMagickExceptionList.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetColorspace", x0); + traceDowncall("ThrowMagickExceptionList", x0, x1, x2, x3, x4, x5, x6, x7); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5, x6, x7); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetCompression { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + /** + * Variadic invoker class for: + * {@snippet lang=c : + * extern MagickBooleanType ThrowMagickException(ExceptionInfo *, const char *, const char *, const size_t, const ExceptionType, const char *, const char *, ...) + * } + */ + public static class ThrowMagickException { + private static final FunctionDescriptor BASE_DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + private static final MemorySegment ADDR = MagickWand_h.findOrThrow("ThrowMagickException"); + + private final MethodHandle handle; + private final FunctionDescriptor descriptor; + private final MethodHandle spreader; + + private ThrowMagickException(MethodHandle handle, FunctionDescriptor descriptor, MethodHandle spreader) { + this.handle = handle; + this.descriptor = descriptor; + this.spreader = spreader; + } + + /** + * Variadic invoker factory for: + * {@snippet lang=c : + * extern MagickBooleanType ThrowMagickException(ExceptionInfo *, const char *, const char *, const size_t, const ExceptionType, const char *, const char *, ...) + * } + */ + public static ThrowMagickException makeInvoker(MemoryLayout... layouts) { + FunctionDescriptor desc$ = BASE_DESC.appendArgumentLayouts(layouts); + Linker.Option fva$ = Linker.Option.firstVariadicArg(BASE_DESC.argumentLayouts().size()); + var mh$ = Linker.nativeLinker().downcallHandle(ADDR, desc$, fva$); + var spreader$ = mh$.asSpreader(Object[].class, layouts.length); + return new ThrowMagickException(mh$, desc$, spreader$); + } + + /** + * {@return the address} + */ + public static MemorySegment address() { + return ADDR; + } + + /** + * {@return the specialized method handle} + */ + public MethodHandle handle() { + return handle; + } + + /** + * {@return the specialized descriptor} + */ + public FunctionDescriptor descriptor() { + return descriptor; + } + + public int apply(MemorySegment x0, MemorySegment x1, MemorySegment x2, long x3, int x4, MemorySegment x5, MemorySegment x6, Object... x7) { + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ThrowMagickException", x0, x1, x2, x3, x4, x5, x6, x7); + } + return (int)spreader.invokeExact(x0, x1, x2, x3, x4, x5, x6, x7); + } catch(IllegalArgumentException | ClassCastException ex$) { + throw ex$; // rethrow IAE from passing wrong number/type of args + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static class CatchException { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetCompression"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("CatchException"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1033,55 +1227,56 @@ private static class MagickGetCompression { /** * Function descriptor for: * {@snippet lang=c : - * extern CompressionType MagickGetCompression(MagickWand *) + * extern void CatchException(ExceptionInfo *) * } */ - public static FunctionDescriptor MagickGetCompression$descriptor() { - return MagickGetCompression.DESC; + public static FunctionDescriptor CatchException$descriptor() { + return CatchException.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern CompressionType MagickGetCompression(MagickWand *) + * extern void CatchException(ExceptionInfo *) * } */ - public static MethodHandle MagickGetCompression$handle() { - return MagickGetCompression.HANDLE; + public static MethodHandle CatchException$handle() { + return CatchException.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern CompressionType MagickGetCompression(MagickWand *) + * extern void CatchException(ExceptionInfo *) * } */ - public static MemorySegment MagickGetCompression$address() { - return MagickGetCompression.ADDR; + public static MemorySegment CatchException$address() { + return CatchException.ADDR; } /** * {@snippet lang=c : - * extern CompressionType MagickGetCompression(MagickWand *) + * extern void CatchException(ExceptionInfo *) * } */ - public static int MagickGetCompression(MemorySegment x0) { - var mh$ = MagickGetCompression.HANDLE; + public static void CatchException(MemorySegment x0) { + var mh$ = CatchException.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetCompression", x0); + traceDowncall("CatchException", x0); } - return (int)mh$.invokeExact(x0); + mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetCopyright { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER ); + private static class ClearMagickException { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER + ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetCopyright"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ClearMagickException"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1089,55 +1284,57 @@ private static class MagickGetCopyright { /** * Function descriptor for: * {@snippet lang=c : - * extern const char *MagickGetCopyright() + * extern void ClearMagickException(ExceptionInfo *) * } */ - public static FunctionDescriptor MagickGetCopyright$descriptor() { - return MagickGetCopyright.DESC; + public static FunctionDescriptor ClearMagickException$descriptor() { + return ClearMagickException.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern const char *MagickGetCopyright() + * extern void ClearMagickException(ExceptionInfo *) * } */ - public static MethodHandle MagickGetCopyright$handle() { - return MagickGetCopyright.HANDLE; + public static MethodHandle ClearMagickException$handle() { + return ClearMagickException.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern const char *MagickGetCopyright() + * extern void ClearMagickException(ExceptionInfo *) * } */ - public static MemorySegment MagickGetCopyright$address() { - return MagickGetCopyright.ADDR; + public static MemorySegment ClearMagickException$address() { + return ClearMagickException.ADDR; } /** * {@snippet lang=c : - * extern const char *MagickGetCopyright() + * extern void ClearMagickException(ExceptionInfo *) * } */ - public static MemorySegment MagickGetCopyright() { - var mh$ = MagickGetCopyright.HANDLE; + public static void ClearMagickException(MemorySegment x0) { + var mh$ = ClearMagickException.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetCopyright"); + traceDowncall("ClearMagickException", x0); } - return (MemorySegment)mh$.invokeExact(); + mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetPackageName { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER ); - - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetPackageName"); + private static class InheritException { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("InheritException"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1145,57 +1342,58 @@ private static class MagickGetPackageName { /** * Function descriptor for: * {@snippet lang=c : - * extern const char *MagickGetPackageName() + * extern void InheritException(ExceptionInfo *, const ExceptionInfo *) * } */ - public static FunctionDescriptor MagickGetPackageName$descriptor() { - return MagickGetPackageName.DESC; + public static FunctionDescriptor InheritException$descriptor() { + return InheritException.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern const char *MagickGetPackageName() + * extern void InheritException(ExceptionInfo *, const ExceptionInfo *) * } */ - public static MethodHandle MagickGetPackageName$handle() { - return MagickGetPackageName.HANDLE; + public static MethodHandle InheritException$handle() { + return InheritException.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern const char *MagickGetPackageName() + * extern void InheritException(ExceptionInfo *, const ExceptionInfo *) * } */ - public static MemorySegment MagickGetPackageName$address() { - return MagickGetPackageName.ADDR; + public static MemorySegment InheritException$address() { + return InheritException.ADDR; } /** * {@snippet lang=c : - * extern const char *MagickGetPackageName() + * extern void InheritException(ExceptionInfo *, const ExceptionInfo *) * } */ - public static MemorySegment MagickGetPackageName() { - var mh$ = MagickGetPackageName.HANDLE; + public static void InheritException(MemorySegment x0, MemorySegment x1) { + var mh$ = InheritException.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetPackageName"); + traceDowncall("InheritException", x0, x1); } - return (MemorySegment)mh$.invokeExact(); + mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetQuantumDepth { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( + private static class MagickError { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetQuantumDepth"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickError"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1203,57 +1401,58 @@ private static class MagickGetQuantumDepth { /** * Function descriptor for: * {@snippet lang=c : - * extern const char *MagickGetQuantumDepth(size_t *) + * extern void MagickError(const ExceptionType, const char *, const char *) * } */ - public static FunctionDescriptor MagickGetQuantumDepth$descriptor() { - return MagickGetQuantumDepth.DESC; + public static FunctionDescriptor MagickError$descriptor() { + return MagickError.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern const char *MagickGetQuantumDepth(size_t *) + * extern void MagickError(const ExceptionType, const char *, const char *) * } */ - public static MethodHandle MagickGetQuantumDepth$handle() { - return MagickGetQuantumDepth.HANDLE; + public static MethodHandle MagickError$handle() { + return MagickError.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern const char *MagickGetQuantumDepth(size_t *) + * extern void MagickError(const ExceptionType, const char *, const char *) * } */ - public static MemorySegment MagickGetQuantumDepth$address() { - return MagickGetQuantumDepth.ADDR; + public static MemorySegment MagickError$address() { + return MagickError.ADDR; } /** * {@snippet lang=c : - * extern const char *MagickGetQuantumDepth(size_t *) + * extern void MagickError(const ExceptionType, const char *, const char *) * } */ - public static MemorySegment MagickGetQuantumDepth(MemorySegment x0) { - var mh$ = MagickGetQuantumDepth.HANDLE; + public static void MagickError(int x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickError.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetQuantumDepth", x0); + traceDowncall("MagickError", x0, x1, x2); } - return (MemorySegment)mh$.invokeExact(x0); + mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetQuantumRange { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( + private static class MagickFatalError { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetQuantumRange"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickFatalError"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1261,55 +1460,58 @@ private static class MagickGetQuantumRange { /** * Function descriptor for: * {@snippet lang=c : - * extern const char *MagickGetQuantumRange(size_t *) + * extern void MagickFatalError(const ExceptionType, const char *, const char *) * } */ - public static FunctionDescriptor MagickGetQuantumRange$descriptor() { - return MagickGetQuantumRange.DESC; + public static FunctionDescriptor MagickFatalError$descriptor() { + return MagickFatalError.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern const char *MagickGetQuantumRange(size_t *) + * extern void MagickFatalError(const ExceptionType, const char *, const char *) * } */ - public static MethodHandle MagickGetQuantumRange$handle() { - return MagickGetQuantumRange.HANDLE; + public static MethodHandle MagickFatalError$handle() { + return MagickFatalError.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern const char *MagickGetQuantumRange(size_t *) + * extern void MagickFatalError(const ExceptionType, const char *, const char *) * } */ - public static MemorySegment MagickGetQuantumRange$address() { - return MagickGetQuantumRange.ADDR; + public static MemorySegment MagickFatalError$address() { + return MagickFatalError.ADDR; } /** * {@snippet lang=c : - * extern const char *MagickGetQuantumRange(size_t *) + * extern void MagickFatalError(const ExceptionType, const char *, const char *) * } */ - public static MemorySegment MagickGetQuantumRange(MemorySegment x0) { - var mh$ = MagickGetQuantumRange.HANDLE; + public static void MagickFatalError(int x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickFatalError.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetQuantumRange", x0); + traceDowncall("MagickFatalError", x0, x1, x2); } - return (MemorySegment)mh$.invokeExact(x0); + mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetReleaseDate { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER ); + private static class MagickWarning { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetReleaseDate"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWarning"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1317,57 +1519,56 @@ private static class MagickGetReleaseDate { /** * Function descriptor for: * {@snippet lang=c : - * extern const char *MagickGetReleaseDate() + * extern void MagickWarning(const ExceptionType, const char *, const char *) * } */ - public static FunctionDescriptor MagickGetReleaseDate$descriptor() { - return MagickGetReleaseDate.DESC; + public static FunctionDescriptor MagickWarning$descriptor() { + return MagickWarning.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern const char *MagickGetReleaseDate() + * extern void MagickWarning(const ExceptionType, const char *, const char *) * } */ - public static MethodHandle MagickGetReleaseDate$handle() { - return MagickGetReleaseDate.HANDLE; + public static MethodHandle MagickWarning$handle() { + return MagickWarning.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern const char *MagickGetReleaseDate() + * extern void MagickWarning(const ExceptionType, const char *, const char *) * } */ - public static MemorySegment MagickGetReleaseDate$address() { - return MagickGetReleaseDate.ADDR; + public static MemorySegment MagickWarning$address() { + return MagickWarning.ADDR; } /** * {@snippet lang=c : - * extern const char *MagickGetReleaseDate() + * extern void MagickWarning(const ExceptionType, const char *, const char *) * } */ - public static MemorySegment MagickGetReleaseDate() { - var mh$ = MagickGetReleaseDate.HANDLE; + public static void MagickWarning(int x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickWarning.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetReleaseDate"); + traceDowncall("MagickWarning", x0, x1, x2); } - return (MemorySegment)mh$.invokeExact(); + mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetVersion { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, + private static class ResetLinkedListIterator { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetVersion"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ResetLinkedListIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1375,57 +1576,59 @@ private static class MagickGetVersion { /** * Function descriptor for: * {@snippet lang=c : - * extern const char *MagickGetVersion(size_t *) + * extern void ResetLinkedListIterator(LinkedListInfo *) * } */ - public static FunctionDescriptor MagickGetVersion$descriptor() { - return MagickGetVersion.DESC; + public static FunctionDescriptor ResetLinkedListIterator$descriptor() { + return ResetLinkedListIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern const char *MagickGetVersion(size_t *) + * extern void ResetLinkedListIterator(LinkedListInfo *) * } */ - public static MethodHandle MagickGetVersion$handle() { - return MagickGetVersion.HANDLE; + public static MethodHandle ResetLinkedListIterator$handle() { + return ResetLinkedListIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern const char *MagickGetVersion(size_t *) + * extern void ResetLinkedListIterator(LinkedListInfo *) * } */ - public static MemorySegment MagickGetVersion$address() { - return MagickGetVersion.ADDR; + public static MemorySegment ResetLinkedListIterator$address() { + return ResetLinkedListIterator.ADDR; } /** * {@snippet lang=c : - * extern const char *MagickGetVersion(size_t *) + * extern void ResetLinkedListIterator(LinkedListInfo *) * } */ - public static MemorySegment MagickGetVersion(MemorySegment x0) { - var mh$ = MagickGetVersion.HANDLE; + public static void ResetLinkedListIterator(MemorySegment x0) { + var mh$ = ResetLinkedListIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetVersion", x0); + traceDowncall("ResetLinkedListIterator", x0); } - return (MemorySegment)mh$.invokeExact(x0); + mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetPointsize { + private static class ConcatenateMagickString { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_DOUBLE, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetPointsize"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ConcatenateMagickString"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1433,58 +1636,59 @@ private static class MagickGetPointsize { /** * Function descriptor for: * {@snippet lang=c : - * extern double MagickGetPointsize(MagickWand *) + * extern size_t ConcatenateMagickString(char *restrict, const char *restrict, const size_t) * } */ - public static FunctionDescriptor MagickGetPointsize$descriptor() { - return MagickGetPointsize.DESC; + public static FunctionDescriptor ConcatenateMagickString$descriptor() { + return ConcatenateMagickString.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern double MagickGetPointsize(MagickWand *) + * extern size_t ConcatenateMagickString(char *restrict, const char *restrict, const size_t) * } */ - public static MethodHandle MagickGetPointsize$handle() { - return MagickGetPointsize.HANDLE; + public static MethodHandle ConcatenateMagickString$handle() { + return ConcatenateMagickString.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern double MagickGetPointsize(MagickWand *) + * extern size_t ConcatenateMagickString(char *restrict, const char *restrict, const size_t) * } */ - public static MemorySegment MagickGetPointsize$address() { - return MagickGetPointsize.ADDR; + public static MemorySegment ConcatenateMagickString$address() { + return ConcatenateMagickString.ADDR; } /** * {@snippet lang=c : - * extern double MagickGetPointsize(MagickWand *) + * extern size_t ConcatenateMagickString(char *restrict, const char *restrict, const size_t) * } */ - public static double MagickGetPointsize(MemorySegment x0) { - var mh$ = MagickGetPointsize.HANDLE; + public static long ConcatenateMagickString(MemorySegment x0, MemorySegment x1, long x2) { + var mh$ = ConcatenateMagickString.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetPointsize", x0); + traceDowncall("ConcatenateMagickString", x0, x1, x2); } - return (double)mh$.invokeExact(x0); + return (long)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetSamplingFactors { + private static class CopyMagickString { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_LONG, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetSamplingFactors"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("CopyMagickString"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1492,59 +1696,57 @@ private static class MagickGetSamplingFactors { /** * Function descriptor for: * {@snippet lang=c : - * extern double *MagickGetSamplingFactors(MagickWand *, size_t *) + * extern size_t CopyMagickString(char *restrict, const char *restrict, const size_t) * } */ - public static FunctionDescriptor MagickGetSamplingFactors$descriptor() { - return MagickGetSamplingFactors.DESC; + public static FunctionDescriptor CopyMagickString$descriptor() { + return CopyMagickString.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern double *MagickGetSamplingFactors(MagickWand *, size_t *) + * extern size_t CopyMagickString(char *restrict, const char *restrict, const size_t) * } */ - public static MethodHandle MagickGetSamplingFactors$handle() { - return MagickGetSamplingFactors.HANDLE; + public static MethodHandle CopyMagickString$handle() { + return CopyMagickString.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern double *MagickGetSamplingFactors(MagickWand *, size_t *) + * extern size_t CopyMagickString(char *restrict, const char *restrict, const size_t) * } */ - public static MemorySegment MagickGetSamplingFactors$address() { - return MagickGetSamplingFactors.ADDR; + public static MemorySegment CopyMagickString$address() { + return CopyMagickString.ADDR; } /** * {@snippet lang=c : - * extern double *MagickGetSamplingFactors(MagickWand *, size_t *) + * extern size_t CopyMagickString(char *restrict, const char *restrict, const size_t) * } */ - public static MemorySegment MagickGetSamplingFactors(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickGetSamplingFactors.HANDLE; + public static long CopyMagickString(MemorySegment x0, MemorySegment x1, long x2) { + var mh$ = CopyMagickString.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetSamplingFactors", x0, x1); + traceDowncall("CopyMagickString", x0, x1, x2); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (long)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickQueryFontMetrics { + private static class StripMagickString { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQueryFontMetrics"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("StripMagickString"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1552,59 +1754,61 @@ private static class MagickQueryFontMetrics { /** * Function descriptor for: * {@snippet lang=c : - * extern double *MagickQueryFontMetrics(MagickWand *, const DrawingWand *, const char *) + * extern size_t StripMagickString(char *) * } */ - public static FunctionDescriptor MagickQueryFontMetrics$descriptor() { - return MagickQueryFontMetrics.DESC; + public static FunctionDescriptor StripMagickString$descriptor() { + return StripMagickString.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern double *MagickQueryFontMetrics(MagickWand *, const DrawingWand *, const char *) + * extern size_t StripMagickString(char *) * } */ - public static MethodHandle MagickQueryFontMetrics$handle() { - return MagickQueryFontMetrics.HANDLE; + public static MethodHandle StripMagickString$handle() { + return StripMagickString.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern double *MagickQueryFontMetrics(MagickWand *, const DrawingWand *, const char *) + * extern size_t StripMagickString(char *) * } */ - public static MemorySegment MagickQueryFontMetrics$address() { - return MagickQueryFontMetrics.ADDR; + public static MemorySegment StripMagickString$address() { + return StripMagickString.ADDR; } /** * {@snippet lang=c : - * extern double *MagickQueryFontMetrics(MagickWand *, const DrawingWand *, const char *) + * extern size_t StripMagickString(char *) * } */ - public static MemorySegment MagickQueryFontMetrics(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickQueryFontMetrics.HANDLE; + public static long StripMagickString(MemorySegment x0) { + var mh$ = StripMagickString.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickQueryFontMetrics", x0, x1, x2); + traceDowncall("StripMagickString", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2); + return (long)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickQueryMultilineFontMetrics { + private static class FormatMagickSize { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_LONG, + MagickWand_h.C_LONG_LONG, + MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQueryMultilineFontMetrics"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("FormatMagickSize"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1612,57 +1816,56 @@ private static class MagickQueryMultilineFontMetrics { /** * Function descriptor for: * {@snippet lang=c : - * extern double *MagickQueryMultilineFontMetrics(MagickWand *, const DrawingWand *, const char *) + * extern ssize_t FormatMagickSize(const MagickSizeType, const MagickBooleanType, const char *, const size_t, char *) * } */ - public static FunctionDescriptor MagickQueryMultilineFontMetrics$descriptor() { - return MagickQueryMultilineFontMetrics.DESC; + public static FunctionDescriptor FormatMagickSize$descriptor() { + return FormatMagickSize.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern double *MagickQueryMultilineFontMetrics(MagickWand *, const DrawingWand *, const char *) + * extern ssize_t FormatMagickSize(const MagickSizeType, const MagickBooleanType, const char *, const size_t, char *) * } */ - public static MethodHandle MagickQueryMultilineFontMetrics$handle() { - return MagickQueryMultilineFontMetrics.HANDLE; + public static MethodHandle FormatMagickSize$handle() { + return FormatMagickSize.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern double *MagickQueryMultilineFontMetrics(MagickWand *, const DrawingWand *, const char *) + * extern ssize_t FormatMagickSize(const MagickSizeType, const MagickBooleanType, const char *, const size_t, char *) * } */ - public static MemorySegment MagickQueryMultilineFontMetrics$address() { - return MagickQueryMultilineFontMetrics.ADDR; + public static MemorySegment FormatMagickSize$address() { + return FormatMagickSize.ADDR; } /** * {@snippet lang=c : - * extern double *MagickQueryMultilineFontMetrics(MagickWand *, const DrawingWand *, const char *) + * extern ssize_t FormatMagickSize(const MagickSizeType, const MagickBooleanType, const char *, const size_t, char *) * } */ - public static MemorySegment MagickQueryMultilineFontMetrics(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickQueryMultilineFontMetrics.HANDLE; + public static long FormatMagickSize(long x0, int x1, MemorySegment x2, long x3, MemorySegment x4) { + var mh$ = FormatMagickSize.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickQueryMultilineFontMetrics", x0, x1, x2); + traceDowncall("FormatMagickSize", x0, x1, x2, x3, x4); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2); + return (long)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetFilter { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + private static class ResetImageProfileIterator { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetFilter"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ResetImageProfileIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1670,159 +1873,14339 @@ private static class MagickGetFilter { /** * Function descriptor for: * {@snippet lang=c : - * extern FilterType MagickGetFilter(MagickWand *) + * extern void ResetImageProfileIterator(const Image *) * } */ - public static FunctionDescriptor MagickGetFilter$descriptor() { - return MagickGetFilter.DESC; + public static FunctionDescriptor ResetImageProfileIterator$descriptor() { + return ResetImageProfileIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern FilterType MagickGetFilter(MagickWand *) + * extern void ResetImageProfileIterator(const Image *) * } */ - public static MethodHandle MagickGetFilter$handle() { - return MagickGetFilter.HANDLE; + public static MethodHandle ResetImageProfileIterator$handle() { + return ResetImageProfileIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern FilterType MagickGetFilter(MagickWand *) + * extern void ResetImageProfileIterator(const Image *) * } */ - public static MemorySegment MagickGetFilter$address() { - return MagickGetFilter.ADDR; + public static MemorySegment ResetImageProfileIterator$address() { + return ResetImageProfileIterator.ADDR; } /** * {@snippet lang=c : - * extern FilterType MagickGetFilter(MagickWand *) + * extern void ResetImageProfileIterator(const Image *) * } */ - public static int MagickGetFilter(MemorySegment x0) { - var mh$ = MagickGetFilter.HANDLE; + public static void ResetImageProfileIterator(MemorySegment x0) { + var mh$ = ResetImageProfileIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetFilter", x0); + traceDowncall("ResetImageProfileIterator", x0); } - return (int)mh$.invokeExact(x0); + mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - - private static class MagickGetGravity { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER - ); - - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetGravity"); - - public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); - } - + private static final int UndefinedFilter = (int)0L; /** - * Function descriptor for: * {@snippet lang=c : - * extern GravityType MagickGetGravity(MagickWand *) + * enum .UndefinedFilter = 0 * } */ - public static FunctionDescriptor MagickGetGravity$descriptor() { - return MagickGetGravity.DESC; + public static int UndefinedFilter() { + return UndefinedFilter; } - + private static final int PointFilter = (int)1L; /** - * Downcall method handle for: * {@snippet lang=c : - * extern GravityType MagickGetGravity(MagickWand *) + * enum .PointFilter = 1 * } */ - public static MethodHandle MagickGetGravity$handle() { - return MagickGetGravity.HANDLE; + public static int PointFilter() { + return PointFilter; } - + private static final int BoxFilter = (int)2L; /** - * Address for: * {@snippet lang=c : - * extern GravityType MagickGetGravity(MagickWand *) + * enum .BoxFilter = 2 * } */ - public static MemorySegment MagickGetGravity$address() { - return MagickGetGravity.ADDR; + public static int BoxFilter() { + return BoxFilter; } - + private static final int TriangleFilter = (int)3L; /** * {@snippet lang=c : - * extern GravityType MagickGetGravity(MagickWand *) + * enum .TriangleFilter = 3 * } */ - public static int MagickGetGravity(MemorySegment x0) { - var mh$ = MagickGetGravity.HANDLE; - try { - if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetGravity", x0); - } - return (int)mh$.invokeExact(x0); - } catch (Throwable ex$) { - throw new AssertionError("should not reach here", ex$); - } - } - - private static class MagickGetType { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER - ); - - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetType"); - - public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + public static int TriangleFilter() { + return TriangleFilter; } - + private static final int HermiteFilter = (int)4L; + /** + * {@snippet lang=c : + * enum .HermiteFilter = 4 + * } + */ + public static int HermiteFilter() { + return HermiteFilter; + } + private static final int HannFilter = (int)5L; + /** + * {@snippet lang=c : + * enum .HannFilter = 5 + * } + */ + public static int HannFilter() { + return HannFilter; + } + private static final int HammingFilter = (int)6L; + /** + * {@snippet lang=c : + * enum .HammingFilter = 6 + * } + */ + public static int HammingFilter() { + return HammingFilter; + } + private static final int BlackmanFilter = (int)7L; + /** + * {@snippet lang=c : + * enum .BlackmanFilter = 7 + * } + */ + public static int BlackmanFilter() { + return BlackmanFilter; + } + private static final int GaussianFilter = (int)8L; + /** + * {@snippet lang=c : + * enum .GaussianFilter = 8 + * } + */ + public static int GaussianFilter() { + return GaussianFilter; + } + private static final int QuadraticFilter = (int)9L; + /** + * {@snippet lang=c : + * enum .QuadraticFilter = 9 + * } + */ + public static int QuadraticFilter() { + return QuadraticFilter; + } + private static final int CubicFilter = (int)10L; + /** + * {@snippet lang=c : + * enum .CubicFilter = 10 + * } + */ + public static int CubicFilter() { + return CubicFilter; + } + private static final int CatromFilter = (int)11L; + /** + * {@snippet lang=c : + * enum .CatromFilter = 11 + * } + */ + public static int CatromFilter() { + return CatromFilter; + } + private static final int MitchellFilter = (int)12L; + /** + * {@snippet lang=c : + * enum .MitchellFilter = 12 + * } + */ + public static int MitchellFilter() { + return MitchellFilter; + } + private static final int JincFilter = (int)13L; + /** + * {@snippet lang=c : + * enum .JincFilter = 13 + * } + */ + public static int JincFilter() { + return JincFilter; + } + private static final int SincFilter = (int)14L; + /** + * {@snippet lang=c : + * enum .SincFilter = 14 + * } + */ + public static int SincFilter() { + return SincFilter; + } + private static final int SincFastFilter = (int)15L; + /** + * {@snippet lang=c : + * enum .SincFastFilter = 15 + * } + */ + public static int SincFastFilter() { + return SincFastFilter; + } + private static final int KaiserFilter = (int)16L; + /** + * {@snippet lang=c : + * enum .KaiserFilter = 16 + * } + */ + public static int KaiserFilter() { + return KaiserFilter; + } + private static final int WelchFilter = (int)17L; + /** + * {@snippet lang=c : + * enum .WelchFilter = 17 + * } + */ + public static int WelchFilter() { + return WelchFilter; + } + private static final int ParzenFilter = (int)18L; + /** + * {@snippet lang=c : + * enum .ParzenFilter = 18 + * } + */ + public static int ParzenFilter() { + return ParzenFilter; + } + private static final int BohmanFilter = (int)19L; + /** + * {@snippet lang=c : + * enum .BohmanFilter = 19 + * } + */ + public static int BohmanFilter() { + return BohmanFilter; + } + private static final int BartlettFilter = (int)20L; + /** + * {@snippet lang=c : + * enum .BartlettFilter = 20 + * } + */ + public static int BartlettFilter() { + return BartlettFilter; + } + private static final int LagrangeFilter = (int)21L; + /** + * {@snippet lang=c : + * enum .LagrangeFilter = 21 + * } + */ + public static int LagrangeFilter() { + return LagrangeFilter; + } + private static final int LanczosFilter = (int)22L; + /** + * {@snippet lang=c : + * enum .LanczosFilter = 22 + * } + */ + public static int LanczosFilter() { + return LanczosFilter; + } + private static final int LanczosSharpFilter = (int)23L; + /** + * {@snippet lang=c : + * enum .LanczosSharpFilter = 23 + * } + */ + public static int LanczosSharpFilter() { + return LanczosSharpFilter; + } + private static final int Lanczos2Filter = (int)24L; + /** + * {@snippet lang=c : + * enum .Lanczos2Filter = 24 + * } + */ + public static int Lanczos2Filter() { + return Lanczos2Filter; + } + private static final int Lanczos2SharpFilter = (int)25L; + /** + * {@snippet lang=c : + * enum .Lanczos2SharpFilter = 25 + * } + */ + public static int Lanczos2SharpFilter() { + return Lanczos2SharpFilter; + } + private static final int RobidouxFilter = (int)26L; + /** + * {@snippet lang=c : + * enum .RobidouxFilter = 26 + * } + */ + public static int RobidouxFilter() { + return RobidouxFilter; + } + private static final int RobidouxSharpFilter = (int)27L; + /** + * {@snippet lang=c : + * enum .RobidouxSharpFilter = 27 + * } + */ + public static int RobidouxSharpFilter() { + return RobidouxSharpFilter; + } + private static final int CosineFilter = (int)28L; + /** + * {@snippet lang=c : + * enum .CosineFilter = 28 + * } + */ + public static int CosineFilter() { + return CosineFilter; + } + private static final int SplineFilter = (int)29L; + /** + * {@snippet lang=c : + * enum .SplineFilter = 29 + * } + */ + public static int SplineFilter() { + return SplineFilter; + } + private static final int LanczosRadiusFilter = (int)30L; + /** + * {@snippet lang=c : + * enum .LanczosRadiusFilter = 30 + * } + */ + public static int LanczosRadiusFilter() { + return LanczosRadiusFilter; + } + private static final int CubicSplineFilter = (int)31L; + /** + * {@snippet lang=c : + * enum .CubicSplineFilter = 31 + * } + */ + public static int CubicSplineFilter() { + return CubicSplineFilter; + } + private static final int SentinelFilter = (int)32L; + /** + * {@snippet lang=c : + * enum .SentinelFilter = 32 + * } + */ + public static int SentinelFilter() { + return SentinelFilter; + } + + private static class SetResampleFilterInterpolateMethod { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("SetResampleFilterInterpolateMethod"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType SetResampleFilterInterpolateMethod(ResampleFilter *, const PixelInterpolateMethod) + * } + */ + public static FunctionDescriptor SetResampleFilterInterpolateMethod$descriptor() { + return SetResampleFilterInterpolateMethod.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType SetResampleFilterInterpolateMethod(ResampleFilter *, const PixelInterpolateMethod) + * } + */ + public static MethodHandle SetResampleFilterInterpolateMethod$handle() { + return SetResampleFilterInterpolateMethod.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType SetResampleFilterInterpolateMethod(ResampleFilter *, const PixelInterpolateMethod) + * } + */ + public static MemorySegment SetResampleFilterInterpolateMethod$address() { + return SetResampleFilterInterpolateMethod.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType SetResampleFilterInterpolateMethod(ResampleFilter *, const PixelInterpolateMethod) + * } + */ + public static int SetResampleFilterInterpolateMethod(MemorySegment x0, int x1) { + var mh$ = SetResampleFilterInterpolateMethod.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("SetResampleFilterInterpolateMethod", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class SetResampleFilterVirtualPixelMethod { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("SetResampleFilterVirtualPixelMethod"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType SetResampleFilterVirtualPixelMethod(ResampleFilter *, const VirtualPixelMethod) + * } + */ + public static FunctionDescriptor SetResampleFilterVirtualPixelMethod$descriptor() { + return SetResampleFilterVirtualPixelMethod.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType SetResampleFilterVirtualPixelMethod(ResampleFilter *, const VirtualPixelMethod) + * } + */ + public static MethodHandle SetResampleFilterVirtualPixelMethod$handle() { + return SetResampleFilterVirtualPixelMethod.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType SetResampleFilterVirtualPixelMethod(ResampleFilter *, const VirtualPixelMethod) + * } + */ + public static MemorySegment SetResampleFilterVirtualPixelMethod$address() { + return SetResampleFilterVirtualPixelMethod.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType SetResampleFilterVirtualPixelMethod(ResampleFilter *, const VirtualPixelMethod) + * } + */ + public static int SetResampleFilterVirtualPixelMethod(MemorySegment x0, int x1) { + var mh$ = SetResampleFilterVirtualPixelMethod.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("SetResampleFilterVirtualPixelMethod", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class AcquireResampleFilter { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("AcquireResampleFilter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern ResampleFilter *AcquireResampleFilter(const Image *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor AcquireResampleFilter$descriptor() { + return AcquireResampleFilter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern ResampleFilter *AcquireResampleFilter(const Image *, ExceptionInfo *) + * } + */ + public static MethodHandle AcquireResampleFilter$handle() { + return AcquireResampleFilter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern ResampleFilter *AcquireResampleFilter(const Image *, ExceptionInfo *) + * } + */ + public static MemorySegment AcquireResampleFilter$address() { + return AcquireResampleFilter.ADDR; + } + + /** + * {@snippet lang=c : + * extern ResampleFilter *AcquireResampleFilter(const Image *, ExceptionInfo *) + * } + */ + public static MemorySegment AcquireResampleFilter(MemorySegment x0, MemorySegment x1) { + var mh$ = AcquireResampleFilter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("AcquireResampleFilter", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class DestroyResampleFilter { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DestroyResampleFilter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern ResampleFilter *DestroyResampleFilter(ResampleFilter *) + * } + */ + public static FunctionDescriptor DestroyResampleFilter$descriptor() { + return DestroyResampleFilter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern ResampleFilter *DestroyResampleFilter(ResampleFilter *) + * } + */ + public static MethodHandle DestroyResampleFilter$handle() { + return DestroyResampleFilter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern ResampleFilter *DestroyResampleFilter(ResampleFilter *) + * } + */ + public static MemorySegment DestroyResampleFilter$address() { + return DestroyResampleFilter.ADDR; + } + + /** + * {@snippet lang=c : + * extern ResampleFilter *DestroyResampleFilter(ResampleFilter *) + * } + */ + public static MemorySegment DestroyResampleFilter(MemorySegment x0) { + var mh$ = DestroyResampleFilter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("DestroyResampleFilter", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ScaleResampleFilter { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ScaleResampleFilter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void ScaleResampleFilter(ResampleFilter *, const double, const double, const double, const double) + * } + */ + public static FunctionDescriptor ScaleResampleFilter$descriptor() { + return ScaleResampleFilter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void ScaleResampleFilter(ResampleFilter *, const double, const double, const double, const double) + * } + */ + public static MethodHandle ScaleResampleFilter$handle() { + return ScaleResampleFilter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void ScaleResampleFilter(ResampleFilter *, const double, const double, const double, const double) + * } + */ + public static MemorySegment ScaleResampleFilter$address() { + return ScaleResampleFilter.ADDR; + } + + /** + * {@snippet lang=c : + * extern void ScaleResampleFilter(ResampleFilter *, const double, const double, const double, const double) + * } + */ + public static void ScaleResampleFilter(MemorySegment x0, double x1, double x2, double x3, double x4) { + var mh$ = ScaleResampleFilter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ScaleResampleFilter", x0, x1, x2, x3, x4); + } + mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class SetResampleFilter { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("SetResampleFilter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void SetResampleFilter(ResampleFilter *, const FilterType) + * } + */ + public static FunctionDescriptor SetResampleFilter$descriptor() { + return SetResampleFilter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void SetResampleFilter(ResampleFilter *, const FilterType) + * } + */ + public static MethodHandle SetResampleFilter$handle() { + return SetResampleFilter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void SetResampleFilter(ResampleFilter *, const FilterType) + * } + */ + public static MemorySegment SetResampleFilter$address() { + return SetResampleFilter.ADDR; + } + + /** + * {@snippet lang=c : + * extern void SetResampleFilter(ResampleFilter *, const FilterType) + * } + */ + public static void SetResampleFilter(MemorySegment x0, int x1) { + var mh$ = SetResampleFilter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("SetResampleFilter", x0, x1); + } + mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class FormatMagickTime { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("FormatMagickTime"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern ssize_t FormatMagickTime(const time_t, const size_t, char *) + * } + */ + public static FunctionDescriptor FormatMagickTime$descriptor() { + return FormatMagickTime.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern ssize_t FormatMagickTime(const time_t, const size_t, char *) + * } + */ + public static MethodHandle FormatMagickTime$handle() { + return FormatMagickTime.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern ssize_t FormatMagickTime(const time_t, const size_t, char *) + * } + */ + public static MemorySegment FormatMagickTime$address() { + return FormatMagickTime.ADDR; + } + + /** + * {@snippet lang=c : + * extern ssize_t FormatMagickTime(const time_t, const size_t, char *) + * } + */ + public static long FormatMagickTime(long x0, long x1, MemorySegment x2) { + var mh$ = FormatMagickTime.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("FormatMagickTime", x0, x1, x2); + } + return (long)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class CatchImageException { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("CatchImageException"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern ExceptionType CatchImageException(Image *) + * } + */ + public static FunctionDescriptor CatchImageException$descriptor() { + return CatchImageException.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern ExceptionType CatchImageException(Image *) + * } + */ + public static MethodHandle CatchImageException$handle() { + return CatchImageException.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern ExceptionType CatchImageException(Image *) + * } + */ + public static MemorySegment CatchImageException$address() { + return CatchImageException.ADDR; + } + + /** + * {@snippet lang=c : + * extern ExceptionType CatchImageException(Image *) + * } + */ + public static int CatchImageException(MemorySegment x0) { + var mh$ = CatchImageException.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("CatchImageException", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class NewMagickImage { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("NewMagickImage"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern Image *NewMagickImage(const ImageInfo *, const size_t, const size_t, const PixelInfo *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor NewMagickImage$descriptor() { + return NewMagickImage.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern Image *NewMagickImage(const ImageInfo *, const size_t, const size_t, const PixelInfo *, ExceptionInfo *) + * } + */ + public static MethodHandle NewMagickImage$handle() { + return NewMagickImage.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern Image *NewMagickImage(const ImageInfo *, const size_t, const size_t, const PixelInfo *, ExceptionInfo *) + * } + */ + public static MemorySegment NewMagickImage$address() { + return NewMagickImage.ADDR; + } + + /** + * {@snippet lang=c : + * extern Image *NewMagickImage(const ImageInfo *, const size_t, const size_t, const PixelInfo *, ExceptionInfo *) + * } + */ + public static MemorySegment NewMagickImage(MemorySegment x0, long x1, long x2, MemorySegment x3, MemorySegment x4) { + var mh$ = NewMagickImage.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("NewMagickImage", x0, x1, x2, x3, x4); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ListMagickInfo { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ListMagickInfo"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType ListMagickInfo(FILE *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor ListMagickInfo$descriptor() { + return ListMagickInfo.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType ListMagickInfo(FILE *, ExceptionInfo *) + * } + */ + public static MethodHandle ListMagickInfo$handle() { + return ListMagickInfo.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType ListMagickInfo(FILE *, ExceptionInfo *) + * } + */ + public static MemorySegment ListMagickInfo$address() { + return ListMagickInfo.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType ListMagickInfo(FILE *, ExceptionInfo *) + * } + */ + public static int ListMagickInfo(MemorySegment x0, MemorySegment x1) { + var mh$ = ListMagickInfo.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ListMagickInfo", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class FormatMagickCaption { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("FormatMagickCaption"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern ssize_t FormatMagickCaption(Image *, DrawInfo *, const MagickBooleanType, TypeMetric *, char **, ExceptionInfo *) + * } + */ + public static FunctionDescriptor FormatMagickCaption$descriptor() { + return FormatMagickCaption.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern ssize_t FormatMagickCaption(Image *, DrawInfo *, const MagickBooleanType, TypeMetric *, char **, ExceptionInfo *) + * } + */ + public static MethodHandle FormatMagickCaption$handle() { + return FormatMagickCaption.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern ssize_t FormatMagickCaption(Image *, DrawInfo *, const MagickBooleanType, TypeMetric *, char **, ExceptionInfo *) + * } + */ + public static MemorySegment FormatMagickCaption$address() { + return FormatMagickCaption.ADDR; + } + + /** + * {@snippet lang=c : + * extern ssize_t FormatMagickCaption(Image *, DrawInfo *, const MagickBooleanType, TypeMetric *, char **, ExceptionInfo *) + * } + */ + public static long FormatMagickCaption(MemorySegment x0, MemorySegment x1, int x2, MemorySegment x3, MemorySegment x4, MemorySegment x5) { + var mh$ = FormatMagickCaption.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("FormatMagickCaption", x0, x1, x2, x3, x4, x5); + } + return (long)mh$.invokeExact(x0, x1, x2, x3, x4, x5); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ResetImageArtifactIterator { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ResetImageArtifactIterator"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void ResetImageArtifactIterator(const Image *) + * } + */ + public static FunctionDescriptor ResetImageArtifactIterator$descriptor() { + return ResetImageArtifactIterator.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void ResetImageArtifactIterator(const Image *) + * } + */ + public static MethodHandle ResetImageArtifactIterator$handle() { + return ResetImageArtifactIterator.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void ResetImageArtifactIterator(const Image *) + * } + */ + public static MemorySegment ResetImageArtifactIterator$address() { + return ResetImageArtifactIterator.ADDR; + } + + /** + * {@snippet lang=c : + * extern void ResetImageArtifactIterator(const Image *) + * } + */ + public static void ResetImageArtifactIterator(MemorySegment x0) { + var mh$ = ResetImageArtifactIterator.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ResetImageArtifactIterator", x0); + } + mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetOneVirtualPixelInfo { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetOneVirtualPixelInfo"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType GetOneVirtualPixelInfo(const Image *, const VirtualPixelMethod, const ssize_t, const ssize_t, PixelInfo *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor GetOneVirtualPixelInfo$descriptor() { + return GetOneVirtualPixelInfo.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType GetOneVirtualPixelInfo(const Image *, const VirtualPixelMethod, const ssize_t, const ssize_t, PixelInfo *, ExceptionInfo *) + * } + */ + public static MethodHandle GetOneVirtualPixelInfo$handle() { + return GetOneVirtualPixelInfo.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType GetOneVirtualPixelInfo(const Image *, const VirtualPixelMethod, const ssize_t, const ssize_t, PixelInfo *, ExceptionInfo *) + * } + */ + public static MemorySegment GetOneVirtualPixelInfo$address() { + return GetOneVirtualPixelInfo.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType GetOneVirtualPixelInfo(const Image *, const VirtualPixelMethod, const ssize_t, const ssize_t, PixelInfo *, ExceptionInfo *) + * } + */ + public static int GetOneVirtualPixelInfo(MemorySegment x0, int x1, long x2, long x3, MemorySegment x4, MemorySegment x5) { + var mh$ = GetOneVirtualPixelInfo.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetOneVirtualPixelInfo", x0, x1, x2, x3, x4, x5); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetDelegateCommand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetDelegateCommand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char *GetDelegateCommand(const ImageInfo *, Image *, const char *, const char *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor GetDelegateCommand$descriptor() { + return GetDelegateCommand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char *GetDelegateCommand(const ImageInfo *, Image *, const char *, const char *, ExceptionInfo *) + * } + */ + public static MethodHandle GetDelegateCommand$handle() { + return GetDelegateCommand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char *GetDelegateCommand(const ImageInfo *, Image *, const char *, const char *, ExceptionInfo *) + * } + */ + public static MemorySegment GetDelegateCommand$address() { + return GetDelegateCommand.ADDR; + } + + /** + * {@snippet lang=c : + * extern char *GetDelegateCommand(const ImageInfo *, Image *, const char *, const char *, ExceptionInfo *) + * } + */ + public static MemorySegment GetDelegateCommand(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = GetDelegateCommand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetDelegateCommand", x0, x1, x2, x3, x4); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetDelegateCommands { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetDelegateCommands"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetDelegateCommands(const DelegateInfo *) + * } + */ + public static FunctionDescriptor GetDelegateCommands$descriptor() { + return GetDelegateCommands.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetDelegateCommands(const DelegateInfo *) + * } + */ + public static MethodHandle GetDelegateCommands$handle() { + return GetDelegateCommands.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetDelegateCommands(const DelegateInfo *) + * } + */ + public static MemorySegment GetDelegateCommands$address() { + return GetDelegateCommands.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetDelegateCommands(const DelegateInfo *) + * } + */ + public static MemorySegment GetDelegateCommands(MemorySegment x0) { + var mh$ = GetDelegateCommands.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetDelegateCommands", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ExternalDelegateCommand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_INT, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ExternalDelegateCommand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int ExternalDelegateCommand(const MagickBooleanType, const MagickBooleanType, const char *, char *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor ExternalDelegateCommand$descriptor() { + return ExternalDelegateCommand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int ExternalDelegateCommand(const MagickBooleanType, const MagickBooleanType, const char *, char *, ExceptionInfo *) + * } + */ + public static MethodHandle ExternalDelegateCommand$handle() { + return ExternalDelegateCommand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int ExternalDelegateCommand(const MagickBooleanType, const MagickBooleanType, const char *, char *, ExceptionInfo *) + * } + */ + public static MemorySegment ExternalDelegateCommand$address() { + return ExternalDelegateCommand.ADDR; + } + + /** + * {@snippet lang=c : + * extern int ExternalDelegateCommand(const MagickBooleanType, const MagickBooleanType, const char *, char *, ExceptionInfo *) + * } + */ + public static int ExternalDelegateCommand(int x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = ExternalDelegateCommand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ExternalDelegateCommand", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickList { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickList"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char **GetMagickList(const char *, size_t *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor GetMagickList$descriptor() { + return GetMagickList.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char **GetMagickList(const char *, size_t *, ExceptionInfo *) + * } + */ + public static MethodHandle GetMagickList$handle() { + return GetMagickList.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char **GetMagickList(const char *, size_t *, ExceptionInfo *) + * } + */ + public static MemorySegment GetMagickList$address() { + return GetMagickList.ADDR; + } + + /** + * {@snippet lang=c : + * extern char **GetMagickList(const char *, size_t *, ExceptionInfo *) + * } + */ + public static MemorySegment GetMagickList(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = GetMagickList.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickList", x0, x1, x2); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickDescription { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickDescription"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetMagickDescription(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickDescription$descriptor() { + return GetMagickDescription.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetMagickDescription(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickDescription$handle() { + return GetMagickDescription.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetMagickDescription(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickDescription$address() { + return GetMagickDescription.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetMagickDescription(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickDescription(MemorySegment x0) { + var mh$ = GetMagickDescription.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickDescription", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickMimeType { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickMimeType"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetMagickMimeType(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickMimeType$descriptor() { + return GetMagickMimeType.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetMagickMimeType(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickMimeType$handle() { + return GetMagickMimeType.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetMagickMimeType(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickMimeType$address() { + return GetMagickMimeType.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetMagickMimeType(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickMimeType(MemorySegment x0) { + var mh$ = GetMagickMimeType.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickMimeType", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickModuleName { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickModuleName"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetMagickModuleName(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickModuleName$descriptor() { + return GetMagickModuleName.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetMagickModuleName(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickModuleName$handle() { + return GetMagickModuleName.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetMagickModuleName(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickModuleName$address() { + return GetMagickModuleName.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetMagickModuleName(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickModuleName(MemorySegment x0) { + var mh$ = GetMagickModuleName.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickModuleName", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickName { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickName"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetMagickName(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickName$descriptor() { + return GetMagickName.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetMagickName(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickName$handle() { + return GetMagickName.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetMagickName(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickName$address() { + return GetMagickName.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetMagickName(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickName(MemorySegment x0) { + var mh$ = GetMagickName.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickName", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickPrecision { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickPrecision"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int GetMagickPrecision() + * } + */ + public static FunctionDescriptor GetMagickPrecision$descriptor() { + return GetMagickPrecision.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int GetMagickPrecision() + * } + */ + public static MethodHandle GetMagickPrecision$handle() { + return GetMagickPrecision.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int GetMagickPrecision() + * } + */ + public static MemorySegment GetMagickPrecision$address() { + return GetMagickPrecision.ADDR; + } + + /** + * {@snippet lang=c : + * extern int GetMagickPrecision() + * } + */ + public static int GetMagickPrecision() { + var mh$ = GetMagickPrecision.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickPrecision"); + } + return (int)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class SetMagickPrecision { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("SetMagickPrecision"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int SetMagickPrecision(const int) + * } + */ + public static FunctionDescriptor SetMagickPrecision$descriptor() { + return SetMagickPrecision.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int SetMagickPrecision(const int) + * } + */ + public static MethodHandle SetMagickPrecision$handle() { + return SetMagickPrecision.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int SetMagickPrecision(const int) + * } + */ + public static MemorySegment SetMagickPrecision$address() { + return SetMagickPrecision.ADDR; + } + + /** + * {@snippet lang=c : + * extern int SetMagickPrecision(const int) + * } + */ + public static int SetMagickPrecision(int x0) { + var mh$ = SetMagickPrecision.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("SetMagickPrecision", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetImageMagick { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetImageMagick"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType GetImageMagick(const unsigned char *, const size_t, char *) + * } + */ + public static FunctionDescriptor GetImageMagick$descriptor() { + return GetImageMagick.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType GetImageMagick(const unsigned char *, const size_t, char *) + * } + */ + public static MethodHandle GetImageMagick$handle() { + return GetImageMagick.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType GetImageMagick(const unsigned char *, const size_t, char *) + * } + */ + public static MemorySegment GetImageMagick$address() { + return GetImageMagick.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType GetImageMagick(const unsigned char *, const size_t, char *) + * } + */ + public static int GetImageMagick(MemorySegment x0, long x1, MemorySegment x2) { + var mh$ = GetImageMagick.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetImageMagick", x0, x1, x2); + } + return (int)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickAdjoin { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickAdjoin"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickAdjoin(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickAdjoin$descriptor() { + return GetMagickAdjoin.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickAdjoin(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickAdjoin$handle() { + return GetMagickAdjoin.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickAdjoin(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickAdjoin$address() { + return GetMagickAdjoin.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType GetMagickAdjoin(const MagickInfo *) + * } + */ + public static int GetMagickAdjoin(MemorySegment x0) { + var mh$ = GetMagickAdjoin.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickAdjoin", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickBlobSupport { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickBlobSupport"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickBlobSupport(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickBlobSupport$descriptor() { + return GetMagickBlobSupport.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickBlobSupport(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickBlobSupport$handle() { + return GetMagickBlobSupport.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickBlobSupport(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickBlobSupport$address() { + return GetMagickBlobSupport.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType GetMagickBlobSupport(const MagickInfo *) + * } + */ + public static int GetMagickBlobSupport(MemorySegment x0) { + var mh$ = GetMagickBlobSupport.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickBlobSupport", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickDecoderSeekableStream { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickDecoderSeekableStream"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickDecoderSeekableStream(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickDecoderSeekableStream$descriptor() { + return GetMagickDecoderSeekableStream.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickDecoderSeekableStream(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickDecoderSeekableStream$handle() { + return GetMagickDecoderSeekableStream.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickDecoderSeekableStream(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickDecoderSeekableStream$address() { + return GetMagickDecoderSeekableStream.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType GetMagickDecoderSeekableStream(const MagickInfo *) + * } + */ + public static int GetMagickDecoderSeekableStream(MemorySegment x0) { + var mh$ = GetMagickDecoderSeekableStream.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickDecoderSeekableStream", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickDecoderThreadSupport { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickDecoderThreadSupport"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickDecoderThreadSupport(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickDecoderThreadSupport$descriptor() { + return GetMagickDecoderThreadSupport.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickDecoderThreadSupport(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickDecoderThreadSupport$handle() { + return GetMagickDecoderThreadSupport.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickDecoderThreadSupport(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickDecoderThreadSupport$address() { + return GetMagickDecoderThreadSupport.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType GetMagickDecoderThreadSupport(const MagickInfo *) + * } + */ + public static int GetMagickDecoderThreadSupport(MemorySegment x0) { + var mh$ = GetMagickDecoderThreadSupport.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickDecoderThreadSupport", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickEncoderSeekableStream { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickEncoderSeekableStream"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickEncoderSeekableStream(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickEncoderSeekableStream$descriptor() { + return GetMagickEncoderSeekableStream.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickEncoderSeekableStream(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickEncoderSeekableStream$handle() { + return GetMagickEncoderSeekableStream.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickEncoderSeekableStream(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickEncoderSeekableStream$address() { + return GetMagickEncoderSeekableStream.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType GetMagickEncoderSeekableStream(const MagickInfo *) + * } + */ + public static int GetMagickEncoderSeekableStream(MemorySegment x0) { + var mh$ = GetMagickEncoderSeekableStream.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickEncoderSeekableStream", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickEncoderThreadSupport { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickEncoderThreadSupport"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickEncoderThreadSupport(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickEncoderThreadSupport$descriptor() { + return GetMagickEncoderThreadSupport.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickEncoderThreadSupport(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickEncoderThreadSupport$handle() { + return GetMagickEncoderThreadSupport.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickEncoderThreadSupport(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickEncoderThreadSupport$address() { + return GetMagickEncoderThreadSupport.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType GetMagickEncoderThreadSupport(const MagickInfo *) + * } + */ + public static int GetMagickEncoderThreadSupport(MemorySegment x0) { + var mh$ = GetMagickEncoderThreadSupport.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickEncoderThreadSupport", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickEndianSupport { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickEndianSupport"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickEndianSupport(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickEndianSupport$descriptor() { + return GetMagickEndianSupport.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickEndianSupport(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickEndianSupport$handle() { + return GetMagickEndianSupport.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickEndianSupport(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickEndianSupport$address() { + return GetMagickEndianSupport.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType GetMagickEndianSupport(const MagickInfo *) + * } + */ + public static int GetMagickEndianSupport(MemorySegment x0) { + var mh$ = GetMagickEndianSupport.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickEndianSupport", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickRawSupport { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickRawSupport"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickRawSupport(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickRawSupport$descriptor() { + return GetMagickRawSupport.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickRawSupport(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickRawSupport$handle() { + return GetMagickRawSupport.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickRawSupport(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickRawSupport$address() { + return GetMagickRawSupport.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType GetMagickRawSupport(const MagickInfo *) + * } + */ + public static int GetMagickRawSupport(MemorySegment x0) { + var mh$ = GetMagickRawSupport.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickRawSupport", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickStealth { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickStealth"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickStealth(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickStealth$descriptor() { + return GetMagickStealth.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickStealth(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickStealth$handle() { + return GetMagickStealth.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickStealth(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickStealth$address() { + return GetMagickStealth.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType GetMagickStealth(const MagickInfo *) + * } + */ + public static int GetMagickStealth(MemorySegment x0) { + var mh$ = GetMagickStealth.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickStealth", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickUseExtension { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickUseExtension"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickUseExtension(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickUseExtension$descriptor() { + return GetMagickUseExtension.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickUseExtension(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickUseExtension$handle() { + return GetMagickUseExtension.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickUseExtension(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickUseExtension$address() { + return GetMagickUseExtension.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType GetMagickUseExtension(const MagickInfo *) + * } + */ + public static int GetMagickUseExtension(MemorySegment x0) { + var mh$ = GetMagickUseExtension.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickUseExtension", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class IsMagickCoreInstantiated { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("IsMagickCoreInstantiated"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType IsMagickCoreInstantiated() + * } + */ + public static FunctionDescriptor IsMagickCoreInstantiated$descriptor() { + return IsMagickCoreInstantiated.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType IsMagickCoreInstantiated() + * } + */ + public static MethodHandle IsMagickCoreInstantiated$handle() { + return IsMagickCoreInstantiated.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType IsMagickCoreInstantiated() + * } + */ + public static MemorySegment IsMagickCoreInstantiated$address() { + return IsMagickCoreInstantiated.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType IsMagickCoreInstantiated() + * } + */ + public static int IsMagickCoreInstantiated() { + var mh$ = IsMagickCoreInstantiated.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("IsMagickCoreInstantiated"); + } + return (int)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class RegisterMagickInfo { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("RegisterMagickInfo"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType RegisterMagickInfo(MagickInfo *) + * } + */ + public static FunctionDescriptor RegisterMagickInfo$descriptor() { + return RegisterMagickInfo.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType RegisterMagickInfo(MagickInfo *) + * } + */ + public static MethodHandle RegisterMagickInfo$handle() { + return RegisterMagickInfo.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType RegisterMagickInfo(MagickInfo *) + * } + */ + public static MemorySegment RegisterMagickInfo$address() { + return RegisterMagickInfo.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType RegisterMagickInfo(MagickInfo *) + * } + */ + public static int RegisterMagickInfo(MemorySegment x0) { + var mh$ = RegisterMagickInfo.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("RegisterMagickInfo", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class UnregisterMagickInfo { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("UnregisterMagickInfo"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType UnregisterMagickInfo(const char *) + * } + */ + public static FunctionDescriptor UnregisterMagickInfo$descriptor() { + return UnregisterMagickInfo.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType UnregisterMagickInfo(const char *) + * } + */ + public static MethodHandle UnregisterMagickInfo$handle() { + return UnregisterMagickInfo.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType UnregisterMagickInfo(const char *) + * } + */ + public static MemorySegment UnregisterMagickInfo$address() { + return UnregisterMagickInfo.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType UnregisterMagickInfo(const char *) + * } + */ + public static int UnregisterMagickInfo(MemorySegment x0) { + var mh$ = UnregisterMagickInfo.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("UnregisterMagickInfo", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickInfo { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickInfo"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const MagickInfo *GetMagickInfo(const char *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor GetMagickInfo$descriptor() { + return GetMagickInfo.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const MagickInfo *GetMagickInfo(const char *, ExceptionInfo *) + * } + */ + public static MethodHandle GetMagickInfo$handle() { + return GetMagickInfo.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const MagickInfo *GetMagickInfo(const char *, ExceptionInfo *) + * } + */ + public static MemorySegment GetMagickInfo$address() { + return GetMagickInfo.ADDR; + } + + /** + * {@snippet lang=c : + * extern const MagickInfo *GetMagickInfo(const char *, ExceptionInfo *) + * } + */ + public static MemorySegment GetMagickInfo(MemorySegment x0, MemorySegment x1) { + var mh$ = GetMagickInfo.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickInfo", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickInfoList { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickInfoList"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const MagickInfo **GetMagickInfoList(const char *, size_t *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor GetMagickInfoList$descriptor() { + return GetMagickInfoList.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const MagickInfo **GetMagickInfoList(const char *, size_t *, ExceptionInfo *) + * } + */ + public static MethodHandle GetMagickInfoList$handle() { + return GetMagickInfoList.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const MagickInfo **GetMagickInfoList(const char *, size_t *, ExceptionInfo *) + * } + */ + public static MemorySegment GetMagickInfoList$address() { + return GetMagickInfoList.ADDR; + } + + /** + * {@snippet lang=c : + * extern const MagickInfo **GetMagickInfoList(const char *, size_t *, ExceptionInfo *) + * } + */ + public static MemorySegment GetMagickInfoList(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = GetMagickInfoList.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickInfoList", x0, x1, x2); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class AcquireMagickInfo { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("AcquireMagickInfo"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickInfo *AcquireMagickInfo(const char *, const char *, const char *) + * } + */ + public static FunctionDescriptor AcquireMagickInfo$descriptor() { + return AcquireMagickInfo.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickInfo *AcquireMagickInfo(const char *, const char *, const char *) + * } + */ + public static MethodHandle AcquireMagickInfo$handle() { + return AcquireMagickInfo.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickInfo *AcquireMagickInfo(const char *, const char *, const char *) + * } + */ + public static MemorySegment AcquireMagickInfo$address() { + return AcquireMagickInfo.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickInfo *AcquireMagickInfo(const char *, const char *, const char *) + * } + */ + public static MemorySegment AcquireMagickInfo(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = AcquireMagickInfo.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("AcquireMagickInfo", x0, x1, x2); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickCoreGenesis { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCoreGenesis"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void MagickCoreGenesis(const char *, const MagickBooleanType) + * } + */ + public static FunctionDescriptor MagickCoreGenesis$descriptor() { + return MagickCoreGenesis.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void MagickCoreGenesis(const char *, const MagickBooleanType) + * } + */ + public static MethodHandle MagickCoreGenesis$handle() { + return MagickCoreGenesis.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void MagickCoreGenesis(const char *, const MagickBooleanType) + * } + */ + public static MemorySegment MagickCoreGenesis$address() { + return MagickCoreGenesis.ADDR; + } + + /** + * {@snippet lang=c : + * extern void MagickCoreGenesis(const char *, const MagickBooleanType) + * } + */ + public static void MagickCoreGenesis(MemorySegment x0, int x1) { + var mh$ = MagickCoreGenesis.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickCoreGenesis", x0, x1); + } + mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickCoreTerminus { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCoreTerminus"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void MagickCoreTerminus() + * } + */ + public static FunctionDescriptor MagickCoreTerminus$descriptor() { + return MagickCoreTerminus.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void MagickCoreTerminus() + * } + */ + public static MethodHandle MagickCoreTerminus$handle() { + return MagickCoreTerminus.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void MagickCoreTerminus() + * } + */ + public static MemorySegment MagickCoreTerminus$address() { + return MagickCoreTerminus.ADDR; + } + + /** + * {@snippet lang=c : + * extern void MagickCoreTerminus() + * } + */ + public static void MagickCoreTerminus() { + var mh$ = MagickCoreTerminus.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickCoreTerminus"); + } + mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickSeekableStream { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickSeekableStream"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickSeekableStream(const MagickInfo *) + * } + */ + public static FunctionDescriptor GetMagickSeekableStream$descriptor() { + return GetMagickSeekableStream.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickSeekableStream(const MagickInfo *) + * } + */ + public static MethodHandle GetMagickSeekableStream$handle() { + return GetMagickSeekableStream.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType GetMagickSeekableStream(const MagickInfo *) + * } + */ + public static MemorySegment GetMagickSeekableStream$address() { + return GetMagickSeekableStream.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType GetMagickSeekableStream(const MagickInfo *) + * } + */ + public static int GetMagickSeekableStream(MemorySegment x0) { + var mh$ = GetMagickSeekableStream.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickSeekableStream", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class RemoteDisplayCommand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("RemoteDisplayCommand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType RemoteDisplayCommand(const ImageInfo *, const char *, const char *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor RemoteDisplayCommand$descriptor() { + return RemoteDisplayCommand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType RemoteDisplayCommand(const ImageInfo *, const char *, const char *, ExceptionInfo *) + * } + */ + public static MethodHandle RemoteDisplayCommand$handle() { + return RemoteDisplayCommand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType RemoteDisplayCommand(const ImageInfo *, const char *, const char *, ExceptionInfo *) + * } + */ + public static MemorySegment RemoteDisplayCommand$address() { + return RemoteDisplayCommand.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType RemoteDisplayCommand(const ImageInfo *, const char *, const char *, ExceptionInfo *) + * } + */ + public static int RemoteDisplayCommand(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { + var mh$ = RemoteDisplayCommand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("RemoteDisplayCommand", x0, x1, x2, x3); + } + return (int)mh$.invokeExact(x0, x1, x2, x3); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetImageViewException { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetImageViewException"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char *GetImageViewException(const ImageView *, ExceptionType *) + * } + */ + public static FunctionDescriptor GetImageViewException$descriptor() { + return GetImageViewException.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char *GetImageViewException(const ImageView *, ExceptionType *) + * } + */ + public static MethodHandle GetImageViewException$handle() { + return GetImageViewException.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char *GetImageViewException(const ImageView *, ExceptionType *) + * } + */ + public static MemorySegment GetImageViewException$address() { + return GetImageViewException.ADDR; + } + + /** + * {@snippet lang=c : + * extern char *GetImageViewException(const ImageView *, ExceptionType *) + * } + */ + public static MemorySegment GetImageViewException(MemorySegment x0, MemorySegment x1) { + var mh$ = GetImageViewException.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetImageViewException", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class DuplexTransferImageViewIterator { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DuplexTransferImageViewIterator"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType DuplexTransferImageViewIterator(ImageView *, ImageView *, ImageView *, DuplexTransferImageViewMethod, void *) + * } + */ + public static FunctionDescriptor DuplexTransferImageViewIterator$descriptor() { + return DuplexTransferImageViewIterator.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType DuplexTransferImageViewIterator(ImageView *, ImageView *, ImageView *, DuplexTransferImageViewMethod, void *) + * } + */ + public static MethodHandle DuplexTransferImageViewIterator$handle() { + return DuplexTransferImageViewIterator.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType DuplexTransferImageViewIterator(ImageView *, ImageView *, ImageView *, DuplexTransferImageViewMethod, void *) + * } + */ + public static MemorySegment DuplexTransferImageViewIterator$address() { + return DuplexTransferImageViewIterator.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType DuplexTransferImageViewIterator(ImageView *, ImageView *, ImageView *, DuplexTransferImageViewMethod, void *) + * } + */ + public static int DuplexTransferImageViewIterator(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = DuplexTransferImageViewIterator.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("DuplexTransferImageViewIterator", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetImageViewIterator { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetImageViewIterator"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType GetImageViewIterator(ImageView *, GetImageViewMethod, void *) + * } + */ + public static FunctionDescriptor GetImageViewIterator$descriptor() { + return GetImageViewIterator.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType GetImageViewIterator(ImageView *, GetImageViewMethod, void *) + * } + */ + public static MethodHandle GetImageViewIterator$handle() { + return GetImageViewIterator.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType GetImageViewIterator(ImageView *, GetImageViewMethod, void *) + * } + */ + public static MemorySegment GetImageViewIterator$address() { + return GetImageViewIterator.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType GetImageViewIterator(ImageView *, GetImageViewMethod, void *) + * } + */ + public static int GetImageViewIterator(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = GetImageViewIterator.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetImageViewIterator", x0, x1, x2); + } + return (int)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class SetImageViewIterator { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("SetImageViewIterator"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType SetImageViewIterator(ImageView *, SetImageViewMethod, void *) + * } + */ + public static FunctionDescriptor SetImageViewIterator$descriptor() { + return SetImageViewIterator.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType SetImageViewIterator(ImageView *, SetImageViewMethod, void *) + * } + */ + public static MethodHandle SetImageViewIterator$handle() { + return SetImageViewIterator.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType SetImageViewIterator(ImageView *, SetImageViewMethod, void *) + * } + */ + public static MemorySegment SetImageViewIterator$address() { + return SetImageViewIterator.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType SetImageViewIterator(ImageView *, SetImageViewMethod, void *) + * } + */ + public static int SetImageViewIterator(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = SetImageViewIterator.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("SetImageViewIterator", x0, x1, x2); + } + return (int)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class TransferImageViewIterator { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("TransferImageViewIterator"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType TransferImageViewIterator(ImageView *, ImageView *, TransferImageViewMethod, void *) + * } + */ + public static FunctionDescriptor TransferImageViewIterator$descriptor() { + return TransferImageViewIterator.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType TransferImageViewIterator(ImageView *, ImageView *, TransferImageViewMethod, void *) + * } + */ + public static MethodHandle TransferImageViewIterator$handle() { + return TransferImageViewIterator.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType TransferImageViewIterator(ImageView *, ImageView *, TransferImageViewMethod, void *) + * } + */ + public static MemorySegment TransferImageViewIterator$address() { + return TransferImageViewIterator.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType TransferImageViewIterator(ImageView *, ImageView *, TransferImageViewMethod, void *) + * } + */ + public static int TransferImageViewIterator(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { + var mh$ = TransferImageViewIterator.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("TransferImageViewIterator", x0, x1, x2, x3); + } + return (int)mh$.invokeExact(x0, x1, x2, x3); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class UpdateImageViewIterator { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("UpdateImageViewIterator"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType UpdateImageViewIterator(ImageView *, UpdateImageViewMethod, void *) + * } + */ + public static FunctionDescriptor UpdateImageViewIterator$descriptor() { + return UpdateImageViewIterator.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType UpdateImageViewIterator(ImageView *, UpdateImageViewMethod, void *) + * } + */ + public static MethodHandle UpdateImageViewIterator$handle() { + return UpdateImageViewIterator.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType UpdateImageViewIterator(ImageView *, UpdateImageViewMethod, void *) + * } + */ + public static MemorySegment UpdateImageViewIterator$address() { + return UpdateImageViewIterator.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType UpdateImageViewIterator(ImageView *, UpdateImageViewMethod, void *) + * } + */ + public static int UpdateImageViewIterator(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = UpdateImageViewIterator.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("UpdateImageViewIterator", x0, x1, x2); + } + return (int)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + private static final int ExceptionEvent = (int)256L; + /** + * {@snippet lang=c : + * enum .ExceptionEvent = 256 + * } + */ + public static int ExceptionEvent() { + return ExceptionEvent; + } + private static final int WandEvent = (int)262144L; + /** + * {@snippet lang=c : + * enum .WandEvent = 262144 + * } + */ + public static int WandEvent() { + return WandEvent; + } + + /** + * Variadic invoker class for: + * {@snippet lang=c : + * extern MagickBooleanType LogMagickEvent(const LogEventType, const char *, const char *, const size_t, const char *, ...) + * } + */ + public static class LogMagickEvent { + private static final FunctionDescriptor BASE_DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER + ); + private static final MemorySegment ADDR = MagickWand_h.findOrThrow("LogMagickEvent"); + + private final MethodHandle handle; + private final FunctionDescriptor descriptor; + private final MethodHandle spreader; + + private LogMagickEvent(MethodHandle handle, FunctionDescriptor descriptor, MethodHandle spreader) { + this.handle = handle; + this.descriptor = descriptor; + this.spreader = spreader; + } + + /** + * Variadic invoker factory for: + * {@snippet lang=c : + * extern MagickBooleanType LogMagickEvent(const LogEventType, const char *, const char *, const size_t, const char *, ...) + * } + */ + public static LogMagickEvent makeInvoker(MemoryLayout... layouts) { + FunctionDescriptor desc$ = BASE_DESC.appendArgumentLayouts(layouts); + Linker.Option fva$ = Linker.Option.firstVariadicArg(BASE_DESC.argumentLayouts().size()); + var mh$ = Linker.nativeLinker().downcallHandle(ADDR, desc$, fva$); + var spreader$ = mh$.asSpreader(Object[].class, layouts.length); + return new LogMagickEvent(mh$, desc$, spreader$); + } + + /** + * {@return the address} + */ + public static MemorySegment address() { + return ADDR; + } + + /** + * {@return the specialized method handle} + */ + public MethodHandle handle() { + return handle; + } + + /** + * {@return the specialized descriptor} + */ + public FunctionDescriptor descriptor() { + return descriptor; + } + + public int apply(int x0, MemorySegment x1, MemorySegment x2, long x3, MemorySegment x4, Object... x5) { + try { + if (TRACE_DOWNCALLS) { + traceDowncall("LogMagickEvent", x0, x1, x2, x3, x4, x5); + } + return (int)spreader.invokeExact(x0, x1, x2, x3, x4, x5); + } catch(IllegalArgumentException | ClassCastException ex$) { + throw ex$; // rethrow IAE from passing wrong number/type of args + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static class LogMagickEventList { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("LogMagickEventList"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType LogMagickEventList(const LogEventType, const char *, const char *, const size_t, const char *, va_list) + * } + */ + public static FunctionDescriptor LogMagickEventList$descriptor() { + return LogMagickEventList.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType LogMagickEventList(const LogEventType, const char *, const char *, const size_t, const char *, va_list) + * } + */ + public static MethodHandle LogMagickEventList$handle() { + return LogMagickEventList.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType LogMagickEventList(const LogEventType, const char *, const char *, const size_t, const char *, va_list) + * } + */ + public static MemorySegment LogMagickEventList$address() { + return LogMagickEventList.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType LogMagickEventList(const LogEventType, const char *, const char *, const size_t, const char *, va_list) + * } + */ + public static int LogMagickEventList(int x0, MemorySegment x1, MemorySegment x2, long x3, MemorySegment x4, MemorySegment x5) { + var mh$ = LogMagickEventList.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("LogMagickEventList", x0, x1, x2, x3, x4, x5); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class CloseMagickLog { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("CloseMagickLog"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void CloseMagickLog() + * } + */ + public static FunctionDescriptor CloseMagickLog$descriptor() { + return CloseMagickLog.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void CloseMagickLog() + * } + */ + public static MethodHandle CloseMagickLog$handle() { + return CloseMagickLog.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void CloseMagickLog() + * } + */ + public static MemorySegment CloseMagickLog$address() { + return CloseMagickLog.ADDR; + } + + /** + * {@snippet lang=c : + * extern void CloseMagickLog() + * } + */ + public static void CloseMagickLog() { + var mh$ = CloseMagickLog.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("CloseMagickLog"); + } + mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class AcquireMagickMatrix { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("AcquireMagickMatrix"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double **AcquireMagickMatrix(const size_t, const size_t) + * } + */ + public static FunctionDescriptor AcquireMagickMatrix$descriptor() { + return AcquireMagickMatrix.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double **AcquireMagickMatrix(const size_t, const size_t) + * } + */ + public static MethodHandle AcquireMagickMatrix$handle() { + return AcquireMagickMatrix.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double **AcquireMagickMatrix(const size_t, const size_t) + * } + */ + public static MemorySegment AcquireMagickMatrix$address() { + return AcquireMagickMatrix.ADDR; + } + + /** + * {@snippet lang=c : + * extern double **AcquireMagickMatrix(const size_t, const size_t) + * } + */ + public static MemorySegment AcquireMagickMatrix(long x0, long x1) { + var mh$ = AcquireMagickMatrix.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("AcquireMagickMatrix", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class RelinquishMagickMatrix { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("RelinquishMagickMatrix"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double **RelinquishMagickMatrix(double **, const size_t) + * } + */ + public static FunctionDescriptor RelinquishMagickMatrix$descriptor() { + return RelinquishMagickMatrix.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double **RelinquishMagickMatrix(double **, const size_t) + * } + */ + public static MethodHandle RelinquishMagickMatrix$handle() { + return RelinquishMagickMatrix.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double **RelinquishMagickMatrix(double **, const size_t) + * } + */ + public static MemorySegment RelinquishMagickMatrix$address() { + return RelinquishMagickMatrix.ADDR; + } + + /** + * {@snippet lang=c : + * extern double **RelinquishMagickMatrix(double **, const size_t) + * } + */ + public static MemorySegment RelinquishMagickMatrix(MemorySegment x0, long x1) { + var mh$ = RelinquishMagickMatrix.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("RelinquishMagickMatrix", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class AcquireMagickMemory { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("AcquireMagickMemory"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void *AcquireMagickMemory(const size_t) + * } + */ + public static FunctionDescriptor AcquireMagickMemory$descriptor() { + return AcquireMagickMemory.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void *AcquireMagickMemory(const size_t) + * } + */ + public static MethodHandle AcquireMagickMemory$handle() { + return AcquireMagickMemory.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void *AcquireMagickMemory(const size_t) + * } + */ + public static MemorySegment AcquireMagickMemory$address() { + return AcquireMagickMemory.ADDR; + } + + /** + * {@snippet lang=c : + * extern void *AcquireMagickMemory(const size_t) + * } + */ + public static MemorySegment AcquireMagickMemory(long x0) { + var mh$ = AcquireMagickMemory.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("AcquireMagickMemory", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class CopyMagickMemory { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("CopyMagickMemory"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void *CopyMagickMemory(void *restrict, const void *restrict, const size_t) + * } + */ + public static FunctionDescriptor CopyMagickMemory$descriptor() { + return CopyMagickMemory.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void *CopyMagickMemory(void *restrict, const void *restrict, const size_t) + * } + */ + public static MethodHandle CopyMagickMemory$handle() { + return CopyMagickMemory.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void *CopyMagickMemory(void *restrict, const void *restrict, const size_t) + * } + */ + public static MemorySegment CopyMagickMemory$address() { + return CopyMagickMemory.ADDR; + } + + /** + * {@snippet lang=c : + * extern void *CopyMagickMemory(void *restrict, const void *restrict, const size_t) + * } + */ + public static MemorySegment CopyMagickMemory(MemorySegment x0, MemorySegment x1, long x2) { + var mh$ = CopyMagickMemory.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("CopyMagickMemory", x0, x1, x2); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class DestroyMagickMemory { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DestroyMagickMemory"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void DestroyMagickMemory() + * } + */ + public static FunctionDescriptor DestroyMagickMemory$descriptor() { + return DestroyMagickMemory.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void DestroyMagickMemory() + * } + */ + public static MethodHandle DestroyMagickMemory$handle() { + return DestroyMagickMemory.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void DestroyMagickMemory() + * } + */ + public static MemorySegment DestroyMagickMemory$address() { + return DestroyMagickMemory.ADDR; + } + + /** + * {@snippet lang=c : + * extern void DestroyMagickMemory() + * } + */ + public static void DestroyMagickMemory() { + var mh$ = DestroyMagickMemory.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("DestroyMagickMemory"); + } + mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickMemoryMethods { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickMemoryMethods"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void GetMagickMemoryMethods(AcquireMemoryHandler *, ResizeMemoryHandler *, DestroyMemoryHandler *) + * } + */ + public static FunctionDescriptor GetMagickMemoryMethods$descriptor() { + return GetMagickMemoryMethods.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void GetMagickMemoryMethods(AcquireMemoryHandler *, ResizeMemoryHandler *, DestroyMemoryHandler *) + * } + */ + public static MethodHandle GetMagickMemoryMethods$handle() { + return GetMagickMemoryMethods.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void GetMagickMemoryMethods(AcquireMemoryHandler *, ResizeMemoryHandler *, DestroyMemoryHandler *) + * } + */ + public static MemorySegment GetMagickMemoryMethods$address() { + return GetMagickMemoryMethods.ADDR; + } + + /** + * {@snippet lang=c : + * extern void GetMagickMemoryMethods(AcquireMemoryHandler *, ResizeMemoryHandler *, DestroyMemoryHandler *) + * } + */ + public static void GetMagickMemoryMethods(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = GetMagickMemoryMethods.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickMemoryMethods", x0, x1, x2); + } + mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class RelinquishMagickMemory { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("RelinquishMagickMemory"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void *RelinquishMagickMemory(void *) + * } + */ + public static FunctionDescriptor RelinquishMagickMemory$descriptor() { + return RelinquishMagickMemory.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void *RelinquishMagickMemory(void *) + * } + */ + public static MethodHandle RelinquishMagickMemory$handle() { + return RelinquishMagickMemory.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void *RelinquishMagickMemory(void *) + * } + */ + public static MemorySegment RelinquishMagickMemory$address() { + return RelinquishMagickMemory.ADDR; + } + + /** + * {@snippet lang=c : + * extern void *RelinquishMagickMemory(void *) + * } + */ + public static MemorySegment RelinquishMagickMemory(MemorySegment x0) { + var mh$ = RelinquishMagickMemory.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("RelinquishMagickMemory", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ResetMagickMemory { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ResetMagickMemory"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void *ResetMagickMemory(void *, int, const size_t) + * } + */ + public static FunctionDescriptor ResetMagickMemory$descriptor() { + return ResetMagickMemory.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void *ResetMagickMemory(void *, int, const size_t) + * } + */ + public static MethodHandle ResetMagickMemory$handle() { + return ResetMagickMemory.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void *ResetMagickMemory(void *, int, const size_t) + * } + */ + public static MemorySegment ResetMagickMemory$address() { + return ResetMagickMemory.ADDR; + } + + /** + * {@snippet lang=c : + * extern void *ResetMagickMemory(void *, int, const size_t) + * } + */ + public static MemorySegment ResetMagickMemory(MemorySegment x0, int x1, long x2) { + var mh$ = ResetMagickMemory.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ResetMagickMemory", x0, x1, x2); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ResizeMagickMemory { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ResizeMagickMemory"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void *ResizeMagickMemory(void *, const size_t) + * } + */ + public static FunctionDescriptor ResizeMagickMemory$descriptor() { + return ResizeMagickMemory.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void *ResizeMagickMemory(void *, const size_t) + * } + */ + public static MethodHandle ResizeMagickMemory$handle() { + return ResizeMagickMemory.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void *ResizeMagickMemory(void *, const size_t) + * } + */ + public static MemorySegment ResizeMagickMemory$address() { + return ResizeMagickMemory.ADDR; + } + + /** + * {@snippet lang=c : + * extern void *ResizeMagickMemory(void *, const size_t) + * } + */ + public static MemorySegment ResizeMagickMemory(MemorySegment x0, long x1) { + var mh$ = ResizeMagickMemory.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ResizeMagickMemory", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class SetMagickAlignedMemoryMethods { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("SetMagickAlignedMemoryMethods"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void SetMagickAlignedMemoryMethods(AcquireAlignedMemoryHandler, RelinquishAlignedMemoryHandler) + * } + */ + public static FunctionDescriptor SetMagickAlignedMemoryMethods$descriptor() { + return SetMagickAlignedMemoryMethods.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void SetMagickAlignedMemoryMethods(AcquireAlignedMemoryHandler, RelinquishAlignedMemoryHandler) + * } + */ + public static MethodHandle SetMagickAlignedMemoryMethods$handle() { + return SetMagickAlignedMemoryMethods.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void SetMagickAlignedMemoryMethods(AcquireAlignedMemoryHandler, RelinquishAlignedMemoryHandler) + * } + */ + public static MemorySegment SetMagickAlignedMemoryMethods$address() { + return SetMagickAlignedMemoryMethods.ADDR; + } + + /** + * {@snippet lang=c : + * extern void SetMagickAlignedMemoryMethods(AcquireAlignedMemoryHandler, RelinquishAlignedMemoryHandler) + * } + */ + public static void SetMagickAlignedMemoryMethods(MemorySegment x0, MemorySegment x1) { + var mh$ = SetMagickAlignedMemoryMethods.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("SetMagickAlignedMemoryMethods", x0, x1); + } + mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class SetMagickMemoryMethods { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("SetMagickMemoryMethods"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void SetMagickMemoryMethods(AcquireMemoryHandler, ResizeMemoryHandler, DestroyMemoryHandler) + * } + */ + public static FunctionDescriptor SetMagickMemoryMethods$descriptor() { + return SetMagickMemoryMethods.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void SetMagickMemoryMethods(AcquireMemoryHandler, ResizeMemoryHandler, DestroyMemoryHandler) + * } + */ + public static MethodHandle SetMagickMemoryMethods$handle() { + return SetMagickMemoryMethods.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void SetMagickMemoryMethods(AcquireMemoryHandler, ResizeMemoryHandler, DestroyMemoryHandler) + * } + */ + public static MemorySegment SetMagickMemoryMethods$address() { + return SetMagickMemoryMethods.ADDR; + } + + /** + * {@snippet lang=c : + * extern void SetMagickMemoryMethods(AcquireMemoryHandler, ResizeMemoryHandler, DestroyMemoryHandler) + * } + */ + public static void SetMagickMemoryMethods(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = SetMagickMemoryMethods.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("SetMagickMemoryMethods", x0, x1, x2); + } + mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickHomeURL { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickHomeURL"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char *GetMagickHomeURL() + * } + */ + public static FunctionDescriptor GetMagickHomeURL$descriptor() { + return GetMagickHomeURL.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char *GetMagickHomeURL() + * } + */ + public static MethodHandle GetMagickHomeURL$handle() { + return GetMagickHomeURL.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char *GetMagickHomeURL() + * } + */ + public static MemorySegment GetMagickHomeURL$address() { + return GetMagickHomeURL.ADDR; + } + + /** + * {@snippet lang=c : + * extern char *GetMagickHomeURL() + * } + */ + public static MemorySegment GetMagickHomeURL() { + var mh$ = GetMagickHomeURL.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickHomeURL"); + } + return (MemorySegment)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickCopyright { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickCopyright"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetMagickCopyright() + * } + */ + public static FunctionDescriptor GetMagickCopyright$descriptor() { + return GetMagickCopyright.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetMagickCopyright() + * } + */ + public static MethodHandle GetMagickCopyright$handle() { + return GetMagickCopyright.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetMagickCopyright() + * } + */ + public static MemorySegment GetMagickCopyright$address() { + return GetMagickCopyright.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetMagickCopyright() + * } + */ + public static MemorySegment GetMagickCopyright() { + var mh$ = GetMagickCopyright.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickCopyright"); + } + return (MemorySegment)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickDelegates { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickDelegates"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetMagickDelegates() + * } + */ + public static FunctionDescriptor GetMagickDelegates$descriptor() { + return GetMagickDelegates.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetMagickDelegates() + * } + */ + public static MethodHandle GetMagickDelegates$handle() { + return GetMagickDelegates.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetMagickDelegates() + * } + */ + public static MemorySegment GetMagickDelegates$address() { + return GetMagickDelegates.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetMagickDelegates() + * } + */ + public static MemorySegment GetMagickDelegates() { + var mh$ = GetMagickDelegates.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickDelegates"); + } + return (MemorySegment)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickFeatures { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickFeatures"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetMagickFeatures() + * } + */ + public static FunctionDescriptor GetMagickFeatures$descriptor() { + return GetMagickFeatures.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetMagickFeatures() + * } + */ + public static MethodHandle GetMagickFeatures$handle() { + return GetMagickFeatures.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetMagickFeatures() + * } + */ + public static MemorySegment GetMagickFeatures$address() { + return GetMagickFeatures.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetMagickFeatures() + * } + */ + public static MemorySegment GetMagickFeatures() { + var mh$ = GetMagickFeatures.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickFeatures"); + } + return (MemorySegment)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickLicense { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickLicense"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetMagickLicense() + * } + */ + public static FunctionDescriptor GetMagickLicense$descriptor() { + return GetMagickLicense.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetMagickLicense() + * } + */ + public static MethodHandle GetMagickLicense$handle() { + return GetMagickLicense.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetMagickLicense() + * } + */ + public static MemorySegment GetMagickLicense$address() { + return GetMagickLicense.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetMagickLicense() + * } + */ + public static MemorySegment GetMagickLicense() { + var mh$ = GetMagickLicense.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickLicense"); + } + return (MemorySegment)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickPackageName { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickPackageName"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetMagickPackageName() + * } + */ + public static FunctionDescriptor GetMagickPackageName$descriptor() { + return GetMagickPackageName.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetMagickPackageName() + * } + */ + public static MethodHandle GetMagickPackageName$handle() { + return GetMagickPackageName.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetMagickPackageName() + * } + */ + public static MemorySegment GetMagickPackageName$address() { + return GetMagickPackageName.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetMagickPackageName() + * } + */ + public static MemorySegment GetMagickPackageName() { + var mh$ = GetMagickPackageName.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickPackageName"); + } + return (MemorySegment)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickQuantumDepth { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickQuantumDepth"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetMagickQuantumDepth(size_t *) + * } + */ + public static FunctionDescriptor GetMagickQuantumDepth$descriptor() { + return GetMagickQuantumDepth.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetMagickQuantumDepth(size_t *) + * } + */ + public static MethodHandle GetMagickQuantumDepth$handle() { + return GetMagickQuantumDepth.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetMagickQuantumDepth(size_t *) + * } + */ + public static MemorySegment GetMagickQuantumDepth$address() { + return GetMagickQuantumDepth.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetMagickQuantumDepth(size_t *) + * } + */ + public static MemorySegment GetMagickQuantumDepth(MemorySegment x0) { + var mh$ = GetMagickQuantumDepth.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickQuantumDepth", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickQuantumRange { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickQuantumRange"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetMagickQuantumRange(size_t *) + * } + */ + public static FunctionDescriptor GetMagickQuantumRange$descriptor() { + return GetMagickQuantumRange.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetMagickQuantumRange(size_t *) + * } + */ + public static MethodHandle GetMagickQuantumRange$handle() { + return GetMagickQuantumRange.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetMagickQuantumRange(size_t *) + * } + */ + public static MemorySegment GetMagickQuantumRange$address() { + return GetMagickQuantumRange.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetMagickQuantumRange(size_t *) + * } + */ + public static MemorySegment GetMagickQuantumRange(MemorySegment x0) { + var mh$ = GetMagickQuantumRange.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickQuantumRange", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickReleaseDate { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickReleaseDate"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetMagickReleaseDate() + * } + */ + public static FunctionDescriptor GetMagickReleaseDate$descriptor() { + return GetMagickReleaseDate.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetMagickReleaseDate() + * } + */ + public static MethodHandle GetMagickReleaseDate$handle() { + return GetMagickReleaseDate.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetMagickReleaseDate() + * } + */ + public static MemorySegment GetMagickReleaseDate$address() { + return GetMagickReleaseDate.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetMagickReleaseDate() + * } + */ + public static MemorySegment GetMagickReleaseDate() { + var mh$ = GetMagickReleaseDate.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickReleaseDate"); + } + return (MemorySegment)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickVersion { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickVersion"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetMagickVersion(size_t *) + * } + */ + public static FunctionDescriptor GetMagickVersion$descriptor() { + return GetMagickVersion.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetMagickVersion(size_t *) + * } + */ + public static MethodHandle GetMagickVersion$handle() { + return GetMagickVersion.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetMagickVersion(size_t *) + * } + */ + public static MemorySegment GetMagickVersion$address() { + return GetMagickVersion.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetMagickVersion(size_t *) + * } + */ + public static MemorySegment GetMagickVersion(MemorySegment x0) { + var mh$ = GetMagickVersion.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickVersion", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ListMagickVersion { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ListMagickVersion"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void ListMagickVersion(FILE *) + * } + */ + public static FunctionDescriptor ListMagickVersion$descriptor() { + return ListMagickVersion.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void ListMagickVersion(FILE *) + * } + */ + public static MethodHandle ListMagickVersion$handle() { + return ListMagickVersion.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void ListMagickVersion(FILE *) + * } + */ + public static MemorySegment ListMagickVersion$address() { + return ListMagickVersion.ADDR; + } + + /** + * {@snippet lang=c : + * extern void ListMagickVersion(FILE *) + * } + */ + public static void ListMagickVersion(MemorySegment x0) { + var mh$ = ListMagickVersion.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ListMagickVersion", x0); + } + mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + private static final int MagickImageCoderModule = (int)0L; + /** + * {@snippet lang=c : + * enum .MagickImageCoderModule = 0 + * } + */ + public static int MagickImageCoderModule() { + return MagickImageCoderModule; + } + private static final int MagickImageFilterModule = (int)1L; + /** + * {@snippet lang=c : + * enum .MagickImageFilterModule = 1 + * } + */ + public static int MagickImageFilterModule() { + return MagickImageFilterModule; + } + + private static class InvokeDynamicImageFilter { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("InvokeDynamicImageFilter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType InvokeDynamicImageFilter(const char *, Image **, const int, const char **, ExceptionInfo *) + * } + */ + public static FunctionDescriptor InvokeDynamicImageFilter$descriptor() { + return InvokeDynamicImageFilter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType InvokeDynamicImageFilter(const char *, Image **, const int, const char **, ExceptionInfo *) + * } + */ + public static MethodHandle InvokeDynamicImageFilter$handle() { + return InvokeDynamicImageFilter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType InvokeDynamicImageFilter(const char *, Image **, const int, const char **, ExceptionInfo *) + * } + */ + public static MemorySegment InvokeDynamicImageFilter$address() { + return InvokeDynamicImageFilter.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType InvokeDynamicImageFilter(const char *, Image **, const int, const char **, ExceptionInfo *) + * } + */ + public static int InvokeDynamicImageFilter(MemorySegment x0, MemorySegment x1, int x2, MemorySegment x3, MemorySegment x4) { + var mh$ = InvokeDynamicImageFilter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("InvokeDynamicImageFilter", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickToMime { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickToMime"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char *MagickToMime(const char *) + * } + */ + public static FunctionDescriptor MagickToMime$descriptor() { + return MagickToMime.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char *MagickToMime(const char *) + * } + */ + public static MethodHandle MagickToMime$handle() { + return MagickToMime.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char *MagickToMime(const char *) + * } + */ + public static MemorySegment MagickToMime$address() { + return MagickToMime.ADDR; + } + + /** + * {@snippet lang=c : + * extern char *MagickToMime(const char *) + * } + */ + public static MemorySegment MagickToMime(MemorySegment x0) { + var mh$ = MagickToMime.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickToMime", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MontageImages { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MontageImages"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern Image *MontageImages(const Image *, const MontageInfo *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor MontageImages$descriptor() { + return MontageImages.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern Image *MontageImages(const Image *, const MontageInfo *, ExceptionInfo *) + * } + */ + public static MethodHandle MontageImages$handle() { + return MontageImages.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern Image *MontageImages(const Image *, const MontageInfo *, ExceptionInfo *) + * } + */ + public static MemorySegment MontageImages$address() { + return MontageImages.ADDR; + } + + /** + * {@snippet lang=c : + * extern Image *MontageImages(const Image *, const MontageInfo *, ExceptionInfo *) + * } + */ + public static MemorySegment MontageImages(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MontageImages.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MontageImages", x0, x1, x2); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MontageImageList { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MontageImageList"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern Image *MontageImageList(const ImageInfo *, const MontageInfo *, const Image *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor MontageImageList$descriptor() { + return MontageImageList.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern Image *MontageImageList(const ImageInfo *, const MontageInfo *, const Image *, ExceptionInfo *) + * } + */ + public static MethodHandle MontageImageList$handle() { + return MontageImageList.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern Image *MontageImageList(const ImageInfo *, const MontageInfo *, const Image *, ExceptionInfo *) + * } + */ + public static MemorySegment MontageImageList$address() { + return MontageImageList.ADDR; + } + + /** + * {@snippet lang=c : + * extern Image *MontageImageList(const ImageInfo *, const MontageInfo *, const Image *, ExceptionInfo *) + * } + */ + public static MemorySegment MontageImageList(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { + var mh$ = MontageImageList.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MontageImageList", x0, x1, x2, x3); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2, x3); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class CloneMontageInfo { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("CloneMontageInfo"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MontageInfo *CloneMontageInfo(const ImageInfo *, const MontageInfo *) + * } + */ + public static FunctionDescriptor CloneMontageInfo$descriptor() { + return CloneMontageInfo.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MontageInfo *CloneMontageInfo(const ImageInfo *, const MontageInfo *) + * } + */ + public static MethodHandle CloneMontageInfo$handle() { + return CloneMontageInfo.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MontageInfo *CloneMontageInfo(const ImageInfo *, const MontageInfo *) + * } + */ + public static MemorySegment CloneMontageInfo$address() { + return CloneMontageInfo.ADDR; + } + + /** + * {@snippet lang=c : + * extern MontageInfo *CloneMontageInfo(const ImageInfo *, const MontageInfo *) + * } + */ + public static MemorySegment CloneMontageInfo(MemorySegment x0, MemorySegment x1) { + var mh$ = CloneMontageInfo.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("CloneMontageInfo", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class DestroyMontageInfo { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DestroyMontageInfo"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MontageInfo *DestroyMontageInfo(MontageInfo *) + * } + */ + public static FunctionDescriptor DestroyMontageInfo$descriptor() { + return DestroyMontageInfo.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MontageInfo *DestroyMontageInfo(MontageInfo *) + * } + */ + public static MethodHandle DestroyMontageInfo$handle() { + return DestroyMontageInfo.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MontageInfo *DestroyMontageInfo(MontageInfo *) + * } + */ + public static MemorySegment DestroyMontageInfo$address() { + return DestroyMontageInfo.ADDR; + } + + /** + * {@snippet lang=c : + * extern MontageInfo *DestroyMontageInfo(MontageInfo *) + * } + */ + public static MemorySegment DestroyMontageInfo(MemorySegment x0) { + var mh$ = DestroyMontageInfo.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("DestroyMontageInfo", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMontageInfo { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMontageInfo"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void GetMontageInfo(const ImageInfo *, MontageInfo *) + * } + */ + public static FunctionDescriptor GetMontageInfo$descriptor() { + return GetMontageInfo.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void GetMontageInfo(const ImageInfo *, MontageInfo *) + * } + */ + public static MethodHandle GetMontageInfo$handle() { + return GetMontageInfo.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void GetMontageInfo(const ImageInfo *, MontageInfo *) + * } + */ + public static MemorySegment GetMontageInfo$address() { + return GetMontageInfo.ADDR; + } + + /** + * {@snippet lang=c : + * extern void GetMontageInfo(const ImageInfo *, MontageInfo *) + * } + */ + public static void GetMontageInfo(MemorySegment x0, MemorySegment x1) { + var mh$ = GetMontageInfo.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMontageInfo", x0, x1); + } + mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + /** + * {@snippet lang=c : + * typedef struct _MagickCLDevice *MagickCLDevice + * } + */ + public static final AddressLayout MagickCLDevice = MagickWand_h.C_POINTER; + private static final int MagickUndefinedOptions = (int)-1L; + /** + * {@snippet lang=c : + * enum .MagickUndefinedOptions = -1 + * } + */ + public static int MagickUndefinedOptions() { + return MagickUndefinedOptions; + } + private static final int MagickAlignOptions = (int)0L; + /** + * {@snippet lang=c : + * enum .MagickAlignOptions = 0 + * } + */ + public static int MagickAlignOptions() { + return MagickAlignOptions; + } + private static final int MagickAlphaChannelOptions = (int)1L; + /** + * {@snippet lang=c : + * enum .MagickAlphaChannelOptions = 1 + * } + */ + public static int MagickAlphaChannelOptions() { + return MagickAlphaChannelOptions; + } + private static final int MagickBooleanOptions = (int)2L; + /** + * {@snippet lang=c : + * enum .MagickBooleanOptions = 2 + * } + */ + public static int MagickBooleanOptions() { + return MagickBooleanOptions; + } + private static final int MagickCacheOptions = (int)3L; + /** + * {@snippet lang=c : + * enum .MagickCacheOptions = 3 + * } + */ + public static int MagickCacheOptions() { + return MagickCacheOptions; + } + private static final int MagickChannelOptions = (int)4L; + /** + * {@snippet lang=c : + * enum .MagickChannelOptions = 4 + * } + */ + public static int MagickChannelOptions() { + return MagickChannelOptions; + } + private static final int MagickClassOptions = (int)5L; + /** + * {@snippet lang=c : + * enum .MagickClassOptions = 5 + * } + */ + public static int MagickClassOptions() { + return MagickClassOptions; + } + private static final int MagickClipPathOptions = (int)6L; + /** + * {@snippet lang=c : + * enum .MagickClipPathOptions = 6 + * } + */ + public static int MagickClipPathOptions() { + return MagickClipPathOptions; + } + private static final int MagickCoderOptions = (int)7L; + /** + * {@snippet lang=c : + * enum .MagickCoderOptions = 7 + * } + */ + public static int MagickCoderOptions() { + return MagickCoderOptions; + } + private static final int MagickColorOptions = (int)8L; + /** + * {@snippet lang=c : + * enum .MagickColorOptions = 8 + * } + */ + public static int MagickColorOptions() { + return MagickColorOptions; + } + private static final int MagickColorspaceOptions = (int)9L; + /** + * {@snippet lang=c : + * enum .MagickColorspaceOptions = 9 + * } + */ + public static int MagickColorspaceOptions() { + return MagickColorspaceOptions; + } + private static final int MagickCommandOptions = (int)10L; + /** + * {@snippet lang=c : + * enum .MagickCommandOptions = 10 + * } + */ + public static int MagickCommandOptions() { + return MagickCommandOptions; + } + private static final int MagickComplexOptions = (int)11L; + /** + * {@snippet lang=c : + * enum .MagickComplexOptions = 11 + * } + */ + public static int MagickComplexOptions() { + return MagickComplexOptions; + } + private static final int MagickComplianceOptions = (int)12L; + /** + * {@snippet lang=c : + * enum .MagickComplianceOptions = 12 + * } + */ + public static int MagickComplianceOptions() { + return MagickComplianceOptions; + } + private static final int MagickComposeOptions = (int)13L; + /** + * {@snippet lang=c : + * enum .MagickComposeOptions = 13 + * } + */ + public static int MagickComposeOptions() { + return MagickComposeOptions; + } + private static final int MagickCompressOptions = (int)14L; + /** + * {@snippet lang=c : + * enum .MagickCompressOptions = 14 + * } + */ + public static int MagickCompressOptions() { + return MagickCompressOptions; + } + private static final int MagickConfigureOptions = (int)15L; + /** + * {@snippet lang=c : + * enum .MagickConfigureOptions = 15 + * } + */ + public static int MagickConfigureOptions() { + return MagickConfigureOptions; + } + private static final int MagickDataTypeOptions = (int)16L; + /** + * {@snippet lang=c : + * enum .MagickDataTypeOptions = 16 + * } + */ + public static int MagickDataTypeOptions() { + return MagickDataTypeOptions; + } + private static final int MagickDebugOptions = (int)17L; + /** + * {@snippet lang=c : + * enum .MagickDebugOptions = 17 + * } + */ + public static int MagickDebugOptions() { + return MagickDebugOptions; + } + private static final int MagickDecorateOptions = (int)18L; + /** + * {@snippet lang=c : + * enum .MagickDecorateOptions = 18 + * } + */ + public static int MagickDecorateOptions() { + return MagickDecorateOptions; + } + private static final int MagickDelegateOptions = (int)19L; + /** + * {@snippet lang=c : + * enum .MagickDelegateOptions = 19 + * } + */ + public static int MagickDelegateOptions() { + return MagickDelegateOptions; + } + private static final int MagickDirectionOptions = (int)20L; + /** + * {@snippet lang=c : + * enum .MagickDirectionOptions = 20 + * } + */ + public static int MagickDirectionOptions() { + return MagickDirectionOptions; + } + private static final int MagickDisposeOptions = (int)21L; + /** + * {@snippet lang=c : + * enum .MagickDisposeOptions = 21 + * } + */ + public static int MagickDisposeOptions() { + return MagickDisposeOptions; + } + private static final int MagickDistortOptions = (int)22L; + /** + * {@snippet lang=c : + * enum .MagickDistortOptions = 22 + * } + */ + public static int MagickDistortOptions() { + return MagickDistortOptions; + } + private static final int MagickDitherOptions = (int)23L; + /** + * {@snippet lang=c : + * enum .MagickDitherOptions = 23 + * } + */ + public static int MagickDitherOptions() { + return MagickDitherOptions; + } + private static final int MagickEndianOptions = (int)24L; + /** + * {@snippet lang=c : + * enum .MagickEndianOptions = 24 + * } + */ + public static int MagickEndianOptions() { + return MagickEndianOptions; + } + private static final int MagickEvaluateOptions = (int)25L; + /** + * {@snippet lang=c : + * enum .MagickEvaluateOptions = 25 + * } + */ + public static int MagickEvaluateOptions() { + return MagickEvaluateOptions; + } + private static final int MagickFillRuleOptions = (int)26L; + /** + * {@snippet lang=c : + * enum .MagickFillRuleOptions = 26 + * } + */ + public static int MagickFillRuleOptions() { + return MagickFillRuleOptions; + } + private static final int MagickFilterOptions = (int)27L; + /** + * {@snippet lang=c : + * enum .MagickFilterOptions = 27 + * } + */ + public static int MagickFilterOptions() { + return MagickFilterOptions; + } + private static final int MagickFontOptions = (int)28L; + /** + * {@snippet lang=c : + * enum .MagickFontOptions = 28 + * } + */ + public static int MagickFontOptions() { + return MagickFontOptions; + } + private static final int MagickFontsOptions = (int)29L; + /** + * {@snippet lang=c : + * enum .MagickFontsOptions = 29 + * } + */ + public static int MagickFontsOptions() { + return MagickFontsOptions; + } + private static final int MagickFormatOptions = (int)30L; + /** + * {@snippet lang=c : + * enum .MagickFormatOptions = 30 + * } + */ + public static int MagickFormatOptions() { + return MagickFormatOptions; + } + private static final int MagickFunctionOptions = (int)31L; + /** + * {@snippet lang=c : + * enum .MagickFunctionOptions = 31 + * } + */ + public static int MagickFunctionOptions() { + return MagickFunctionOptions; + } + private static final int MagickGradientOptions = (int)32L; + /** + * {@snippet lang=c : + * enum .MagickGradientOptions = 32 + * } + */ + public static int MagickGradientOptions() { + return MagickGradientOptions; + } + private static final int MagickGravityOptions = (int)33L; + /** + * {@snippet lang=c : + * enum .MagickGravityOptions = 33 + * } + */ + public static int MagickGravityOptions() { + return MagickGravityOptions; + } + private static final int MagickIntensityOptions = (int)34L; + /** + * {@snippet lang=c : + * enum .MagickIntensityOptions = 34 + * } + */ + public static int MagickIntensityOptions() { + return MagickIntensityOptions; + } + private static final int MagickIntentOptions = (int)35L; + /** + * {@snippet lang=c : + * enum .MagickIntentOptions = 35 + * } + */ + public static int MagickIntentOptions() { + return MagickIntentOptions; + } + private static final int MagickInterlaceOptions = (int)36L; + /** + * {@snippet lang=c : + * enum .MagickInterlaceOptions = 36 + * } + */ + public static int MagickInterlaceOptions() { + return MagickInterlaceOptions; + } + private static final int MagickInterpolateOptions = (int)37L; + /** + * {@snippet lang=c : + * enum .MagickInterpolateOptions = 37 + * } + */ + public static int MagickInterpolateOptions() { + return MagickInterpolateOptions; + } + private static final int MagickKernelOptions = (int)38L; + /** + * {@snippet lang=c : + * enum .MagickKernelOptions = 38 + * } + */ + public static int MagickKernelOptions() { + return MagickKernelOptions; + } + private static final int MagickLayerOptions = (int)39L; + /** + * {@snippet lang=c : + * enum .MagickLayerOptions = 39 + * } + */ + public static int MagickLayerOptions() { + return MagickLayerOptions; + } + private static final int MagickLineCapOptions = (int)40L; + /** + * {@snippet lang=c : + * enum .MagickLineCapOptions = 40 + * } + */ + public static int MagickLineCapOptions() { + return MagickLineCapOptions; + } + private static final int MagickLineJoinOptions = (int)41L; + /** + * {@snippet lang=c : + * enum .MagickLineJoinOptions = 41 + * } + */ + public static int MagickLineJoinOptions() { + return MagickLineJoinOptions; + } + private static final int MagickListOptions = (int)42L; + /** + * {@snippet lang=c : + * enum .MagickListOptions = 42 + * } + */ + public static int MagickListOptions() { + return MagickListOptions; + } + private static final int MagickLocaleOptions = (int)43L; + /** + * {@snippet lang=c : + * enum .MagickLocaleOptions = 43 + * } + */ + public static int MagickLocaleOptions() { + return MagickLocaleOptions; + } + private static final int MagickLogEventOptions = (int)44L; + /** + * {@snippet lang=c : + * enum .MagickLogEventOptions = 44 + * } + */ + public static int MagickLogEventOptions() { + return MagickLogEventOptions; + } + private static final int MagickLogOptions = (int)45L; + /** + * {@snippet lang=c : + * enum .MagickLogOptions = 45 + * } + */ + public static int MagickLogOptions() { + return MagickLogOptions; + } + private static final int MagickMagicOptions = (int)46L; + /** + * {@snippet lang=c : + * enum .MagickMagicOptions = 46 + * } + */ + public static int MagickMagicOptions() { + return MagickMagicOptions; + } + private static final int MagickMethodOptions = (int)47L; + /** + * {@snippet lang=c : + * enum .MagickMethodOptions = 47 + * } + */ + public static int MagickMethodOptions() { + return MagickMethodOptions; + } + private static final int MagickMetricOptions = (int)48L; + /** + * {@snippet lang=c : + * enum .MagickMetricOptions = 48 + * } + */ + public static int MagickMetricOptions() { + return MagickMetricOptions; + } + private static final int MagickMimeOptions = (int)49L; + /** + * {@snippet lang=c : + * enum .MagickMimeOptions = 49 + * } + */ + public static int MagickMimeOptions() { + return MagickMimeOptions; + } + private static final int MagickModeOptions = (int)50L; + /** + * {@snippet lang=c : + * enum .MagickModeOptions = 50 + * } + */ + public static int MagickModeOptions() { + return MagickModeOptions; + } + private static final int MagickModuleOptions = (int)51L; + /** + * {@snippet lang=c : + * enum .MagickModuleOptions = 51 + * } + */ + public static int MagickModuleOptions() { + return MagickModuleOptions; + } + private static final int MagickMorphologyOptions = (int)52L; + /** + * {@snippet lang=c : + * enum .MagickMorphologyOptions = 52 + * } + */ + public static int MagickMorphologyOptions() { + return MagickMorphologyOptions; + } + private static final int MagickNoiseOptions = (int)53L; + /** + * {@snippet lang=c : + * enum .MagickNoiseOptions = 53 + * } + */ + public static int MagickNoiseOptions() { + return MagickNoiseOptions; + } + private static final int MagickOrientationOptions = (int)54L; + /** + * {@snippet lang=c : + * enum .MagickOrientationOptions = 54 + * } + */ + public static int MagickOrientationOptions() { + return MagickOrientationOptions; + } + private static final int MagickPixelChannelOptions = (int)55L; + /** + * {@snippet lang=c : + * enum .MagickPixelChannelOptions = 55 + * } + */ + public static int MagickPixelChannelOptions() { + return MagickPixelChannelOptions; + } + private static final int MagickPixelIntensityOptions = (int)56L; + /** + * {@snippet lang=c : + * enum .MagickPixelIntensityOptions = 56 + * } + */ + public static int MagickPixelIntensityOptions() { + return MagickPixelIntensityOptions; + } + private static final int MagickPixelMaskOptions = (int)57L; + /** + * {@snippet lang=c : + * enum .MagickPixelMaskOptions = 57 + * } + */ + public static int MagickPixelMaskOptions() { + return MagickPixelMaskOptions; + } + private static final int MagickPixelTraitOptions = (int)58L; + /** + * {@snippet lang=c : + * enum .MagickPixelTraitOptions = 58 + * } + */ + public static int MagickPixelTraitOptions() { + return MagickPixelTraitOptions; + } + private static final int MagickPolicyOptions = (int)59L; + /** + * {@snippet lang=c : + * enum .MagickPolicyOptions = 59 + * } + */ + public static int MagickPolicyOptions() { + return MagickPolicyOptions; + } + private static final int MagickPolicyDomainOptions = (int)60L; + /** + * {@snippet lang=c : + * enum .MagickPolicyDomainOptions = 60 + * } + */ + public static int MagickPolicyDomainOptions() { + return MagickPolicyDomainOptions; + } + private static final int MagickPolicyRightsOptions = (int)61L; + /** + * {@snippet lang=c : + * enum .MagickPolicyRightsOptions = 61 + * } + */ + public static int MagickPolicyRightsOptions() { + return MagickPolicyRightsOptions; + } + private static final int MagickPreviewOptions = (int)62L; + /** + * {@snippet lang=c : + * enum .MagickPreviewOptions = 62 + * } + */ + public static int MagickPreviewOptions() { + return MagickPreviewOptions; + } + private static final int MagickPrimitiveOptions = (int)63L; + /** + * {@snippet lang=c : + * enum .MagickPrimitiveOptions = 63 + * } + */ + public static int MagickPrimitiveOptions() { + return MagickPrimitiveOptions; + } + private static final int MagickQuantumFormatOptions = (int)64L; + /** + * {@snippet lang=c : + * enum .MagickQuantumFormatOptions = 64 + * } + */ + public static int MagickQuantumFormatOptions() { + return MagickQuantumFormatOptions; + } + private static final int MagickResolutionOptions = (int)65L; + /** + * {@snippet lang=c : + * enum .MagickResolutionOptions = 65 + * } + */ + public static int MagickResolutionOptions() { + return MagickResolutionOptions; + } + private static final int MagickResourceOptions = (int)66L; + /** + * {@snippet lang=c : + * enum .MagickResourceOptions = 66 + * } + */ + public static int MagickResourceOptions() { + return MagickResourceOptions; + } + private static final int MagickSparseColorOptions = (int)67L; + /** + * {@snippet lang=c : + * enum .MagickSparseColorOptions = 67 + * } + */ + public static int MagickSparseColorOptions() { + return MagickSparseColorOptions; + } + private static final int MagickStatisticOptions = (int)68L; + /** + * {@snippet lang=c : + * enum .MagickStatisticOptions = 68 + * } + */ + public static int MagickStatisticOptions() { + return MagickStatisticOptions; + } + private static final int MagickStorageOptions = (int)69L; + /** + * {@snippet lang=c : + * enum .MagickStorageOptions = 69 + * } + */ + public static int MagickStorageOptions() { + return MagickStorageOptions; + } + private static final int MagickStretchOptions = (int)70L; + /** + * {@snippet lang=c : + * enum .MagickStretchOptions = 70 + * } + */ + public static int MagickStretchOptions() { + return MagickStretchOptions; + } + private static final int MagickStyleOptions = (int)71L; + /** + * {@snippet lang=c : + * enum .MagickStyleOptions = 71 + * } + */ + public static int MagickStyleOptions() { + return MagickStyleOptions; + } + private static final int MagickThresholdOptions = (int)72L; + /** + * {@snippet lang=c : + * enum .MagickThresholdOptions = 72 + * } + */ + public static int MagickThresholdOptions() { + return MagickThresholdOptions; + } + private static final int MagickTypeOptions = (int)73L; + /** + * {@snippet lang=c : + * enum .MagickTypeOptions = 73 + * } + */ + public static int MagickTypeOptions() { + return MagickTypeOptions; + } + private static final int MagickValidateOptions = (int)74L; + /** + * {@snippet lang=c : + * enum .MagickValidateOptions = 74 + * } + */ + public static int MagickValidateOptions() { + return MagickValidateOptions; + } + private static final int MagickVirtualPixelOptions = (int)75L; + /** + * {@snippet lang=c : + * enum .MagickVirtualPixelOptions = 75 + * } + */ + public static int MagickVirtualPixelOptions() { + return MagickVirtualPixelOptions; + } + private static final int MagickWeightOptions = (int)76L; + /** + * {@snippet lang=c : + * enum .MagickWeightOptions = 76 + * } + */ + public static int MagickWeightOptions() { + return MagickWeightOptions; + } + private static final int MagickAutoThresholdOptions = (int)77L; + /** + * {@snippet lang=c : + * enum .MagickAutoThresholdOptions = 77 + * } + */ + public static int MagickAutoThresholdOptions() { + return MagickAutoThresholdOptions; + } + private static final int MagickToolOptions = (int)78L; + /** + * {@snippet lang=c : + * enum .MagickToolOptions = 78 + * } + */ + public static int MagickToolOptions() { + return MagickToolOptions; + } + private static final int MagickCLIOptions = (int)79L; + /** + * {@snippet lang=c : + * enum .MagickCLIOptions = 79 + * } + */ + public static int MagickCLIOptions() { + return MagickCLIOptions; + } + private static final int MagickIlluminantOptions = (int)80L; + /** + * {@snippet lang=c : + * enum .MagickIlluminantOptions = 80 + * } + */ + public static int MagickIlluminantOptions() { + return MagickIlluminantOptions; + } + private static final int MagickWordBreakOptions = (int)81L; + /** + * {@snippet lang=c : + * enum .MagickWordBreakOptions = 81 + * } + */ + public static int MagickWordBreakOptions() { + return MagickWordBreakOptions; + } + private static final int MagickPagesizeOptions = (int)82L; + /** + * {@snippet lang=c : + * enum .MagickPagesizeOptions = 82 + * } + */ + public static int MagickPagesizeOptions() { + return MagickPagesizeOptions; + } + private static final int MontageValidate = (int)512L; + /** + * {@snippet lang=c : + * enum .MontageValidate = 512 + * } + */ + public static int MontageValidate() { + return MontageValidate; + } + private static final int MagickValidate = (int)2048L; + /** + * {@snippet lang=c : + * enum .MagickValidate = 2048 + * } + */ + public static int MagickValidate() { + return MagickValidate; + } + private static final int NonMagickOptionFlag = (int)4096L; + /** + * {@snippet lang=c : + * enum .NonMagickOptionFlag = 4096 + * } + */ + public static int NonMagickOptionFlag() { + return NonMagickOptionFlag; + } + + private static class GetCommandOptions { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetCommandOptions"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char **GetCommandOptions(const CommandOption) + * } + */ + public static FunctionDescriptor GetCommandOptions$descriptor() { + return GetCommandOptions.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char **GetCommandOptions(const CommandOption) + * } + */ + public static MethodHandle GetCommandOptions$handle() { + return GetCommandOptions.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char **GetCommandOptions(const CommandOption) + * } + */ + public static MemorySegment GetCommandOptions$address() { + return GetCommandOptions.ADDR; + } + + /** + * {@snippet lang=c : + * extern char **GetCommandOptions(const CommandOption) + * } + */ + public static MemorySegment GetCommandOptions(int x0) { + var mh$ = GetCommandOptions.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetCommandOptions", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class IsCommandOption { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("IsCommandOption"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType IsCommandOption(const char *) + * } + */ + public static FunctionDescriptor IsCommandOption$descriptor() { + return IsCommandOption.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType IsCommandOption(const char *) + * } + */ + public static MethodHandle IsCommandOption$handle() { + return IsCommandOption.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType IsCommandOption(const char *) + * } + */ + public static MemorySegment IsCommandOption$address() { + return IsCommandOption.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType IsCommandOption(const char *) + * } + */ + public static int IsCommandOption(MemorySegment x0) { + var mh$ = IsCommandOption.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("IsCommandOption", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ListCommandOptions { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ListCommandOptions"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType ListCommandOptions(FILE *, const CommandOption, ExceptionInfo *) + * } + */ + public static FunctionDescriptor ListCommandOptions$descriptor() { + return ListCommandOptions.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType ListCommandOptions(FILE *, const CommandOption, ExceptionInfo *) + * } + */ + public static MethodHandle ListCommandOptions$handle() { + return ListCommandOptions.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType ListCommandOptions(FILE *, const CommandOption, ExceptionInfo *) + * } + */ + public static MemorySegment ListCommandOptions$address() { + return ListCommandOptions.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType ListCommandOptions(FILE *, const CommandOption, ExceptionInfo *) + * } + */ + public static int ListCommandOptions(MemorySegment x0, int x1, MemorySegment x2) { + var mh$ = ListCommandOptions.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ListCommandOptions", x0, x1, x2); + } + return (int)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetCommandOptionFlags { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetCommandOptionFlags"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern ssize_t GetCommandOptionFlags(const CommandOption, const MagickBooleanType, const char *) + * } + */ + public static FunctionDescriptor GetCommandOptionFlags$descriptor() { + return GetCommandOptionFlags.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern ssize_t GetCommandOptionFlags(const CommandOption, const MagickBooleanType, const char *) + * } + */ + public static MethodHandle GetCommandOptionFlags$handle() { + return GetCommandOptionFlags.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern ssize_t GetCommandOptionFlags(const CommandOption, const MagickBooleanType, const char *) + * } + */ + public static MemorySegment GetCommandOptionFlags$address() { + return GetCommandOptionFlags.ADDR; + } + + /** + * {@snippet lang=c : + * extern ssize_t GetCommandOptionFlags(const CommandOption, const MagickBooleanType, const char *) + * } + */ + public static long GetCommandOptionFlags(int x0, int x1, MemorySegment x2) { + var mh$ = GetCommandOptionFlags.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetCommandOptionFlags", x0, x1, x2); + } + return (long)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ParseCommandOption { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ParseCommandOption"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern ssize_t ParseCommandOption(const CommandOption, const MagickBooleanType, const char *) + * } + */ + public static FunctionDescriptor ParseCommandOption$descriptor() { + return ParseCommandOption.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern ssize_t ParseCommandOption(const CommandOption, const MagickBooleanType, const char *) + * } + */ + public static MethodHandle ParseCommandOption$handle() { + return ParseCommandOption.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern ssize_t ParseCommandOption(const CommandOption, const MagickBooleanType, const char *) + * } + */ + public static MemorySegment ParseCommandOption$address() { + return ParseCommandOption.ADDR; + } + + /** + * {@snippet lang=c : + * extern ssize_t ParseCommandOption(const CommandOption, const MagickBooleanType, const char *) + * } + */ + public static long ParseCommandOption(int x0, int x1, MemorySegment x2) { + var mh$ = ParseCommandOption.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ParseCommandOption", x0, x1, x2); + } + return (long)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ResetImageOptionIterator { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ResetImageOptionIterator"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void ResetImageOptionIterator(const ImageInfo *) + * } + */ + public static FunctionDescriptor ResetImageOptionIterator$descriptor() { + return ResetImageOptionIterator.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void ResetImageOptionIterator(const ImageInfo *) + * } + */ + public static MethodHandle ResetImageOptionIterator$handle() { + return ResetImageOptionIterator.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void ResetImageOptionIterator(const ImageInfo *) + * } + */ + public static MemorySegment ResetImageOptionIterator$address() { + return ResetImageOptionIterator.ADDR; + } + + /** + * {@snippet lang=c : + * extern void ResetImageOptionIterator(const ImageInfo *) + * } + */ + public static void ResetImageOptionIterator(MemorySegment x0) { + var mh$ = ResetImageOptionIterator.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ResetImageOptionIterator", x0); + } + mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetCommandOptionInfo { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetCommandOptionInfo"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const OptionInfo *GetCommandOptionInfo(const char *value) + * } + */ + public static FunctionDescriptor GetCommandOptionInfo$descriptor() { + return GetCommandOptionInfo.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const OptionInfo *GetCommandOptionInfo(const char *value) + * } + */ + public static MethodHandle GetCommandOptionInfo$handle() { + return GetCommandOptionInfo.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const OptionInfo *GetCommandOptionInfo(const char *value) + * } + */ + public static MemorySegment GetCommandOptionInfo$address() { + return GetCommandOptionInfo.ADDR; + } + + /** + * {@snippet lang=c : + * extern const OptionInfo *GetCommandOptionInfo(const char *value) + * } + */ + public static MemorySegment GetCommandOptionInfo(MemorySegment value) { + var mh$ = GetCommandOptionInfo.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetCommandOptionInfo", value); + } + return (MemorySegment)mh$.invokeExact(value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + private static final int FilterPolicyDomain = (int)3L; + /** + * {@snippet lang=c : + * enum .FilterPolicyDomain = 3 + * } + */ + public static int FilterPolicyDomain() { + return FilterPolicyDomain; + } + + private static class SetMagickSecurityPolicy { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("SetMagickSecurityPolicy"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType SetMagickSecurityPolicy(const char *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor SetMagickSecurityPolicy$descriptor() { + return SetMagickSecurityPolicy.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType SetMagickSecurityPolicy(const char *, ExceptionInfo *) + * } + */ + public static MethodHandle SetMagickSecurityPolicy$handle() { + return SetMagickSecurityPolicy.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType SetMagickSecurityPolicy(const char *, ExceptionInfo *) + * } + */ + public static MemorySegment SetMagickSecurityPolicy$address() { + return SetMagickSecurityPolicy.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType SetMagickSecurityPolicy(const char *, ExceptionInfo *) + * } + */ + public static int SetMagickSecurityPolicy(MemorySegment x0, MemorySegment x1) { + var mh$ = SetMagickSecurityPolicy.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("SetMagickSecurityPolicy", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class SetMagickSecurityPolicyValue { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("SetMagickSecurityPolicyValue"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType SetMagickSecurityPolicyValue(const PolicyDomain, const char *, const char *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor SetMagickSecurityPolicyValue$descriptor() { + return SetMagickSecurityPolicyValue.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType SetMagickSecurityPolicyValue(const PolicyDomain, const char *, const char *, ExceptionInfo *) + * } + */ + public static MethodHandle SetMagickSecurityPolicyValue$handle() { + return SetMagickSecurityPolicyValue.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType SetMagickSecurityPolicyValue(const PolicyDomain, const char *, const char *, ExceptionInfo *) + * } + */ + public static MemorySegment SetMagickSecurityPolicyValue$address() { + return SetMagickSecurityPolicyValue.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType SetMagickSecurityPolicyValue(const PolicyDomain, const char *, const char *, ExceptionInfo *) + * } + */ + public static int SetMagickSecurityPolicyValue(int x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { + var mh$ = SetMagickSecurityPolicyValue.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("SetMagickSecurityPolicyValue", x0, x1, x2, x3); + } + return (int)mh$.invokeExact(x0, x1, x2, x3); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickProperty { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickProperty"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *GetMagickProperty(ImageInfo *, Image *, const char *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor GetMagickProperty$descriptor() { + return GetMagickProperty.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *GetMagickProperty(ImageInfo *, Image *, const char *, ExceptionInfo *) + * } + */ + public static MethodHandle GetMagickProperty$handle() { + return GetMagickProperty.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *GetMagickProperty(ImageInfo *, Image *, const char *, ExceptionInfo *) + * } + */ + public static MemorySegment GetMagickProperty$address() { + return GetMagickProperty.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *GetMagickProperty(ImageInfo *, Image *, const char *, ExceptionInfo *) + * } + */ + public static MemorySegment GetMagickProperty(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { + var mh$ = GetMagickProperty.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickProperty", x0, x1, x2, x3); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2, x3); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ResetImagePropertyIterator { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ResetImagePropertyIterator"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void ResetImagePropertyIterator(const Image *) + * } + */ + public static FunctionDescriptor ResetImagePropertyIterator$descriptor() { + return ResetImagePropertyIterator.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void ResetImagePropertyIterator(const Image *) + * } + */ + public static MethodHandle ResetImagePropertyIterator$handle() { + return ResetImagePropertyIterator.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void ResetImagePropertyIterator(const Image *) + * } + */ + public static MemorySegment ResetImagePropertyIterator$address() { + return ResetImagePropertyIterator.ADDR; + } + + /** + * {@snippet lang=c : + * extern void ResetImagePropertyIterator(const Image *) + * } + */ + public static void ResetImagePropertyIterator(MemorySegment x0) { + var mh$ = ResetImagePropertyIterator.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ResetImagePropertyIterator", x0); + } + mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ResetImageRegistryIterator { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ResetImageRegistryIterator"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void ResetImageRegistryIterator() + * } + */ + public static FunctionDescriptor ResetImageRegistryIterator$descriptor() { + return ResetImageRegistryIterator.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void ResetImageRegistryIterator() + * } + */ + public static MethodHandle ResetImageRegistryIterator$handle() { + return ResetImageRegistryIterator.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void ResetImageRegistryIterator() + * } + */ + public static MemorySegment ResetImageRegistryIterator$address() { + return ResetImageRegistryIterator.ADDR; + } + + /** + * {@snippet lang=c : + * extern void ResetImageRegistryIterator() + * } + */ + public static void ResetImageRegistryIterator() { + var mh$ = ResetImageRegistryIterator.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ResetImageRegistryIterator"); + } + mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class AcquireMagickResource { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_INT, + MagickWand_h.C_LONG_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("AcquireMagickResource"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType AcquireMagickResource(const ResourceType, const MagickSizeType) + * } + */ + public static FunctionDescriptor AcquireMagickResource$descriptor() { + return AcquireMagickResource.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType AcquireMagickResource(const ResourceType, const MagickSizeType) + * } + */ + public static MethodHandle AcquireMagickResource$handle() { + return AcquireMagickResource.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType AcquireMagickResource(const ResourceType, const MagickSizeType) + * } + */ + public static MemorySegment AcquireMagickResource$address() { + return AcquireMagickResource.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType AcquireMagickResource(const ResourceType, const MagickSizeType) + * } + */ + public static int AcquireMagickResource(int x0, long x1) { + var mh$ = AcquireMagickResource.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("AcquireMagickResource", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ListMagickResourceInfo { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ListMagickResourceInfo"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType ListMagickResourceInfo(FILE *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor ListMagickResourceInfo$descriptor() { + return ListMagickResourceInfo.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType ListMagickResourceInfo(FILE *, ExceptionInfo *) + * } + */ + public static MethodHandle ListMagickResourceInfo$handle() { + return ListMagickResourceInfo.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType ListMagickResourceInfo(FILE *, ExceptionInfo *) + * } + */ + public static MemorySegment ListMagickResourceInfo$address() { + return ListMagickResourceInfo.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType ListMagickResourceInfo(FILE *, ExceptionInfo *) + * } + */ + public static int ListMagickResourceInfo(MemorySegment x0, MemorySegment x1) { + var mh$ = ListMagickResourceInfo.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ListMagickResourceInfo", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class SetMagickResourceLimit { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_INT, + MagickWand_h.C_LONG_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("SetMagickResourceLimit"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType SetMagickResourceLimit(const ResourceType, const MagickSizeType) + * } + */ + public static FunctionDescriptor SetMagickResourceLimit$descriptor() { + return SetMagickResourceLimit.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType SetMagickResourceLimit(const ResourceType, const MagickSizeType) + * } + */ + public static MethodHandle SetMagickResourceLimit$handle() { + return SetMagickResourceLimit.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType SetMagickResourceLimit(const ResourceType, const MagickSizeType) + * } + */ + public static MemorySegment SetMagickResourceLimit$address() { + return SetMagickResourceLimit.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType SetMagickResourceLimit(const ResourceType, const MagickSizeType) + * } + */ + public static int SetMagickResourceLimit(int x0, long x1) { + var mh$ = SetMagickResourceLimit.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("SetMagickResourceLimit", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickResource { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_LONG_LONG, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickResource"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickSizeType GetMagickResource(const ResourceType) + * } + */ + public static FunctionDescriptor GetMagickResource$descriptor() { + return GetMagickResource.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickSizeType GetMagickResource(const ResourceType) + * } + */ + public static MethodHandle GetMagickResource$handle() { + return GetMagickResource.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickSizeType GetMagickResource(const ResourceType) + * } + */ + public static MemorySegment GetMagickResource$address() { + return GetMagickResource.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickSizeType GetMagickResource(const ResourceType) + * } + */ + public static long GetMagickResource(int x0) { + var mh$ = GetMagickResource.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickResource", x0); + } + return (long)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class GetMagickResourceLimit { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_LONG_LONG, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetMagickResourceLimit"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickSizeType GetMagickResourceLimit(const ResourceType) + * } + */ + public static FunctionDescriptor GetMagickResourceLimit$descriptor() { + return GetMagickResourceLimit.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickSizeType GetMagickResourceLimit(const ResourceType) + * } + */ + public static MethodHandle GetMagickResourceLimit$handle() { + return GetMagickResourceLimit.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickSizeType GetMagickResourceLimit(const ResourceType) + * } + */ + public static MemorySegment GetMagickResourceLimit$address() { + return GetMagickResourceLimit.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickSizeType GetMagickResourceLimit(const ResourceType) + * } + */ + public static long GetMagickResourceLimit(int x0) { + var mh$ = GetMagickResourceLimit.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("GetMagickResourceLimit", x0); + } + return (long)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class RelinquishMagickResource { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_INT, + MagickWand_h.C_LONG_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("RelinquishMagickResource"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void RelinquishMagickResource(const ResourceType, const MagickSizeType) + * } + */ + public static FunctionDescriptor RelinquishMagickResource$descriptor() { + return RelinquishMagickResource.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void RelinquishMagickResource(const ResourceType, const MagickSizeType) + * } + */ + public static MethodHandle RelinquishMagickResource$handle() { + return RelinquishMagickResource.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void RelinquishMagickResource(const ResourceType, const MagickSizeType) + * } + */ + public static MemorySegment RelinquishMagickResource$address() { + return RelinquishMagickResource.ADDR; + } + + /** + * {@snippet lang=c : + * extern void RelinquishMagickResource(const ResourceType, const MagickSizeType) + * } + */ + public static void RelinquishMagickResource(int x0, long x1) { + var mh$ = RelinquishMagickResource.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("RelinquishMagickResource", x0, x1); + } + mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ResetSplayTreeIterator { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ResetSplayTreeIterator"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void ResetSplayTreeIterator(SplayTreeInfo *) + * } + */ + public static FunctionDescriptor ResetSplayTreeIterator$descriptor() { + return ResetSplayTreeIterator.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void ResetSplayTreeIterator(SplayTreeInfo *) + * } + */ + public static MethodHandle ResetSplayTreeIterator$handle() { + return ResetSplayTreeIterator.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void ResetSplayTreeIterator(SplayTreeInfo *) + * } + */ + public static MemorySegment ResetSplayTreeIterator$address() { + return ResetSplayTreeIterator.ADDR; + } + + /** + * {@snippet lang=c : + * extern void ResetSplayTreeIterator(SplayTreeInfo *) + * } + */ + public static void ResetSplayTreeIterator(MemorySegment x0) { + var mh$ = ResetSplayTreeIterator.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ResetSplayTreeIterator", x0); + } + mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class InvokeStaticImageFilter { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("InvokeStaticImageFilter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType InvokeStaticImageFilter(const char *, Image **, const int, const char **, ExceptionInfo *) + * } + */ + public static FunctionDescriptor InvokeStaticImageFilter$descriptor() { + return InvokeStaticImageFilter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType InvokeStaticImageFilter(const char *, Image **, const int, const char **, ExceptionInfo *) + * } + */ + public static MethodHandle InvokeStaticImageFilter$handle() { + return InvokeStaticImageFilter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType InvokeStaticImageFilter(const char *, Image **, const int, const char **, ExceptionInfo *) + * } + */ + public static MemorySegment InvokeStaticImageFilter$address() { + return InvokeStaticImageFilter.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType InvokeStaticImageFilter(const char *, Image **, const int, const char **, ExceptionInfo *) + * } + */ + public static int InvokeStaticImageFilter(MemorySegment x0, MemorySegment x1, int x2, MemorySegment x3, MemorySegment x4) { + var mh$ = InvokeStaticImageFilter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("InvokeStaticImageFilter", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + private static final int MagickPath = (int)1L; + /** + * {@snippet lang=c : + * enum .MagickPath = 1 + * } + */ + public static int MagickPath() { + return MagickPath; + } + + private static class MagickDelay { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_LONG_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDelay"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void MagickDelay(const MagickSizeType) + * } + */ + public static FunctionDescriptor MagickDelay$descriptor() { + return MagickDelay.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void MagickDelay(const MagickSizeType) + * } + */ + public static MethodHandle MagickDelay$handle() { + return MagickDelay.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void MagickDelay(const MagickSizeType) + * } + */ + public static MemorySegment MagickDelay$address() { + return MagickDelay.ADDR; + } + + /** + * {@snippet lang=c : + * extern void MagickDelay(const MagickSizeType) + * } + */ + public static void MagickDelay(long x0) { + var mh$ = MagickDelay.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickDelay", x0); + } + mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class AnimateImageCommand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("AnimateImageCommand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType AnimateImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static FunctionDescriptor AnimateImageCommand$descriptor() { + return AnimateImageCommand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType AnimateImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MethodHandle AnimateImageCommand$handle() { + return AnimateImageCommand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType AnimateImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MemorySegment AnimateImageCommand$address() { + return AnimateImageCommand.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType AnimateImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static int AnimateImageCommand(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = AnimateImageCommand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("AnimateImageCommand", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class CompareImagesCommand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("CompareImagesCommand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType CompareImagesCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static FunctionDescriptor CompareImagesCommand$descriptor() { + return CompareImagesCommand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType CompareImagesCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MethodHandle CompareImagesCommand$handle() { + return CompareImagesCommand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType CompareImagesCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MemorySegment CompareImagesCommand$address() { + return CompareImagesCommand.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType CompareImagesCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static int CompareImagesCommand(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = CompareImagesCommand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("CompareImagesCommand", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class CompositeImageCommand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("CompositeImageCommand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType CompositeImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static FunctionDescriptor CompositeImageCommand$descriptor() { + return CompositeImageCommand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType CompositeImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MethodHandle CompositeImageCommand$handle() { + return CompositeImageCommand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType CompositeImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MemorySegment CompositeImageCommand$address() { + return CompositeImageCommand.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType CompositeImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static int CompositeImageCommand(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = CompositeImageCommand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("CompositeImageCommand", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ConjureImageCommand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ConjureImageCommand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType ConjureImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static FunctionDescriptor ConjureImageCommand$descriptor() { + return ConjureImageCommand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType ConjureImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MethodHandle ConjureImageCommand$handle() { + return ConjureImageCommand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType ConjureImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MemorySegment ConjureImageCommand$address() { + return ConjureImageCommand.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType ConjureImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static int ConjureImageCommand(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = ConjureImageCommand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ConjureImageCommand", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class PixelGetException { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelGetException"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char *PixelGetException(const PixelWand *, ExceptionType *) + * } + */ + public static FunctionDescriptor PixelGetException$descriptor() { + return PixelGetException.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char *PixelGetException(const PixelWand *, ExceptionType *) + * } + */ + public static MethodHandle PixelGetException$handle() { + return PixelGetException.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char *PixelGetException(const PixelWand *, ExceptionType *) + * } + */ + public static MemorySegment PixelGetException$address() { + return PixelGetException.ADDR; + } + + /** + * {@snippet lang=c : + * extern char *PixelGetException(const PixelWand *, ExceptionType *) + * } + */ + public static MemorySegment PixelGetException(MemorySegment x0, MemorySegment x1) { + var mh$ = PixelGetException.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("PixelGetException", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class PixelGetExceptionType { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelGetExceptionType"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern ExceptionType PixelGetExceptionType(const PixelWand *) + * } + */ + public static FunctionDescriptor PixelGetExceptionType$descriptor() { + return PixelGetExceptionType.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern ExceptionType PixelGetExceptionType(const PixelWand *) + * } + */ + public static MethodHandle PixelGetExceptionType$handle() { + return PixelGetExceptionType.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern ExceptionType PixelGetExceptionType(const PixelWand *) + * } + */ + public static MemorySegment PixelGetExceptionType$address() { + return PixelGetExceptionType.ADDR; + } + + /** + * {@snippet lang=c : + * extern ExceptionType PixelGetExceptionType(const PixelWand *) + * } + */ + public static int PixelGetExceptionType(MemorySegment x0) { + var mh$ = PixelGetExceptionType.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("PixelGetExceptionType", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class IsPixelWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("IsPixelWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType IsPixelWand(const PixelWand *) + * } + */ + public static FunctionDescriptor IsPixelWand$descriptor() { + return IsPixelWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType IsPixelWand(const PixelWand *) + * } + */ + public static MethodHandle IsPixelWand$handle() { + return IsPixelWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType IsPixelWand(const PixelWand *) + * } + */ + public static MemorySegment IsPixelWand$address() { + return IsPixelWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType IsPixelWand(const PixelWand *) + * } + */ + public static int IsPixelWand(MemorySegment x0) { + var mh$ = IsPixelWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("IsPixelWand", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class IsPixelWandSimilar { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("IsPixelWandSimilar"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType IsPixelWandSimilar(PixelWand *, PixelWand *, const double) + * } + */ + public static FunctionDescriptor IsPixelWandSimilar$descriptor() { + return IsPixelWandSimilar.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType IsPixelWandSimilar(PixelWand *, PixelWand *, const double) + * } + */ + public static MethodHandle IsPixelWandSimilar$handle() { + return IsPixelWandSimilar.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType IsPixelWandSimilar(PixelWand *, PixelWand *, const double) + * } + */ + public static MemorySegment IsPixelWandSimilar$address() { + return IsPixelWandSimilar.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType IsPixelWandSimilar(PixelWand *, PixelWand *, const double) + * } + */ + public static int IsPixelWandSimilar(MemorySegment x0, MemorySegment x1, double x2) { + var mh$ = IsPixelWandSimilar.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("IsPixelWandSimilar", x0, x1, x2); + } + return (int)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class PixelClearException { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelClearException"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType PixelClearException(PixelWand *) + * } + */ + public static FunctionDescriptor PixelClearException$descriptor() { + return PixelClearException.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType PixelClearException(PixelWand *) + * } + */ + public static MethodHandle PixelClearException$handle() { + return PixelClearException.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType PixelClearException(PixelWand *) + * } + */ + public static MemorySegment PixelClearException$address() { + return PixelClearException.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType PixelClearException(PixelWand *) + * } + */ + public static int PixelClearException(MemorySegment x0) { + var mh$ = PixelClearException.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("PixelClearException", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ClonePixelWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ClonePixelWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern PixelWand *ClonePixelWand(const PixelWand *) + * } + */ + public static FunctionDescriptor ClonePixelWand$descriptor() { + return ClonePixelWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern PixelWand *ClonePixelWand(const PixelWand *) + * } + */ + public static MethodHandle ClonePixelWand$handle() { + return ClonePixelWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern PixelWand *ClonePixelWand(const PixelWand *) + * } + */ + public static MemorySegment ClonePixelWand$address() { + return ClonePixelWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern PixelWand *ClonePixelWand(const PixelWand *) + * } + */ + public static MemorySegment ClonePixelWand(MemorySegment x0) { + var mh$ = ClonePixelWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ClonePixelWand", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ClonePixelWands { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ClonePixelWands"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern PixelWand **ClonePixelWands(const PixelWand **, const size_t) + * } + */ + public static FunctionDescriptor ClonePixelWands$descriptor() { + return ClonePixelWands.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern PixelWand **ClonePixelWands(const PixelWand **, const size_t) + * } + */ + public static MethodHandle ClonePixelWands$handle() { + return ClonePixelWands.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern PixelWand **ClonePixelWands(const PixelWand **, const size_t) + * } + */ + public static MemorySegment ClonePixelWands$address() { + return ClonePixelWands.ADDR; + } + + /** + * {@snippet lang=c : + * extern PixelWand **ClonePixelWands(const PixelWand **, const size_t) + * } + */ + public static MemorySegment ClonePixelWands(MemorySegment x0, long x1) { + var mh$ = ClonePixelWands.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ClonePixelWands", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class DestroyPixelWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DestroyPixelWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern PixelWand *DestroyPixelWand(PixelWand *) + * } + */ + public static FunctionDescriptor DestroyPixelWand$descriptor() { + return DestroyPixelWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern PixelWand *DestroyPixelWand(PixelWand *) + * } + */ + public static MethodHandle DestroyPixelWand$handle() { + return DestroyPixelWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern PixelWand *DestroyPixelWand(PixelWand *) + * } + */ + public static MemorySegment DestroyPixelWand$address() { + return DestroyPixelWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern PixelWand *DestroyPixelWand(PixelWand *) + * } + */ + public static MemorySegment DestroyPixelWand(MemorySegment x0) { + var mh$ = DestroyPixelWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("DestroyPixelWand", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class DestroyPixelWands { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DestroyPixelWands"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern PixelWand **DestroyPixelWands(PixelWand **, const size_t) + * } + */ + public static FunctionDescriptor DestroyPixelWands$descriptor() { + return DestroyPixelWands.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern PixelWand **DestroyPixelWands(PixelWand **, const size_t) + * } + */ + public static MethodHandle DestroyPixelWands$handle() { + return DestroyPixelWands.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern PixelWand **DestroyPixelWands(PixelWand **, const size_t) + * } + */ + public static MemorySegment DestroyPixelWands$address() { + return DestroyPixelWands.ADDR; + } + + /** + * {@snippet lang=c : + * extern PixelWand **DestroyPixelWands(PixelWand **, const size_t) + * } + */ + public static MemorySegment DestroyPixelWands(MemorySegment x0, long x1) { + var mh$ = DestroyPixelWands.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("DestroyPixelWands", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class NewPixelWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("NewPixelWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern PixelWand *NewPixelWand() + * } + */ + public static FunctionDescriptor NewPixelWand$descriptor() { + return NewPixelWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern PixelWand *NewPixelWand() + * } + */ + public static MethodHandle NewPixelWand$handle() { + return NewPixelWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern PixelWand *NewPixelWand() + * } + */ + public static MemorySegment NewPixelWand$address() { + return NewPixelWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern PixelWand *NewPixelWand() + * } + */ + public static MemorySegment NewPixelWand() { + var mh$ = NewPixelWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("NewPixelWand"); + } + return (MemorySegment)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class NewPixelWands { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("NewPixelWands"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern PixelWand **NewPixelWands(const size_t) + * } + */ + public static FunctionDescriptor NewPixelWands$descriptor() { + return NewPixelWands.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern PixelWand **NewPixelWands(const size_t) + * } + */ + public static MethodHandle NewPixelWands$handle() { + return NewPixelWands.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern PixelWand **NewPixelWands(const size_t) + * } + */ + public static MemorySegment NewPixelWands$address() { + return NewPixelWands.ADDR; + } + + /** + * {@snippet lang=c : + * extern PixelWand **NewPixelWands(const size_t) + * } + */ + public static MemorySegment NewPixelWands(long x0) { + var mh$ = NewPixelWands.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("NewPixelWands", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ClearPixelWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ClearPixelWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void ClearPixelWand(PixelWand *) + * } + */ + public static FunctionDescriptor ClearPixelWand$descriptor() { + return ClearPixelWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void ClearPixelWand(PixelWand *) + * } + */ + public static MethodHandle ClearPixelWand$handle() { + return ClearPixelWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void ClearPixelWand(PixelWand *) + * } + */ + public static MemorySegment ClearPixelWand$address() { + return ClearPixelWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern void ClearPixelWand(PixelWand *) + * } + */ + public static void ClearPixelWand(MemorySegment x0) { + var mh$ = ClearPixelWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ClearPixelWand", x0); + } + mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class PixelGetMagickColor { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelGetMagickColor"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void PixelGetMagickColor(const PixelWand *, PixelInfo *) + * } + */ + public static FunctionDescriptor PixelGetMagickColor$descriptor() { + return PixelGetMagickColor.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void PixelGetMagickColor(const PixelWand *, PixelInfo *) + * } + */ + public static MethodHandle PixelGetMagickColor$handle() { + return PixelGetMagickColor.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void PixelGetMagickColor(const PixelWand *, PixelInfo *) + * } + */ + public static MemorySegment PixelGetMagickColor$address() { + return PixelGetMagickColor.ADDR; + } + + /** + * {@snippet lang=c : + * extern void PixelGetMagickColor(const PixelWand *, PixelInfo *) + * } + */ + public static void PixelGetMagickColor(MemorySegment x0, MemorySegment x1) { + var mh$ = PixelGetMagickColor.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("PixelGetMagickColor", x0, x1); + } + mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class PixelSetColorFromWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelSetColorFromWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void PixelSetColorFromWand(PixelWand *, const PixelWand *) + * } + */ + public static FunctionDescriptor PixelSetColorFromWand$descriptor() { + return PixelSetColorFromWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void PixelSetColorFromWand(PixelWand *, const PixelWand *) + * } + */ + public static MethodHandle PixelSetColorFromWand$handle() { + return PixelSetColorFromWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void PixelSetColorFromWand(PixelWand *, const PixelWand *) + * } + */ + public static MemorySegment PixelSetColorFromWand$address() { + return PixelSetColorFromWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern void PixelSetColorFromWand(PixelWand *, const PixelWand *) + * } + */ + public static void PixelSetColorFromWand(MemorySegment x0, MemorySegment x1) { + var mh$ = PixelSetColorFromWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("PixelSetColorFromWand", x0, x1); + } + mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ConvertImageCommand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ConvertImageCommand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType ConvertImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static FunctionDescriptor ConvertImageCommand$descriptor() { + return ConvertImageCommand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType ConvertImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MethodHandle ConvertImageCommand$handle() { + return ConvertImageCommand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType ConvertImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MemorySegment ConvertImageCommand$address() { + return ConvertImageCommand.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType ConvertImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static int ConvertImageCommand(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = ConvertImageCommand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ConvertImageCommand", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetImageAlphaColor { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageAlphaColor"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetImageAlphaColor(MagickWand *, PixelWand *) + * } + */ + public static FunctionDescriptor MagickGetImageAlphaColor$descriptor() { + return MagickGetImageAlphaColor.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetImageAlphaColor(MagickWand *, PixelWand *) + * } + */ + public static MethodHandle MagickGetImageAlphaColor$handle() { + return MagickGetImageAlphaColor.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetImageAlphaColor(MagickWand *, PixelWand *) + * } + */ + public static MemorySegment MagickGetImageAlphaColor$address() { + return MagickGetImageAlphaColor.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickGetImageAlphaColor(MagickWand *, PixelWand *) + * } + */ + public static int MagickGetImageAlphaColor(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickGetImageAlphaColor.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetImageAlphaColor", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetImageAlphaColor { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageAlphaColor"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageAlphaColor(MagickWand *, const PixelWand *) + * } + */ + public static FunctionDescriptor MagickSetImageAlphaColor$descriptor() { + return MagickSetImageAlphaColor.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageAlphaColor(MagickWand *, const PixelWand *) + * } + */ + public static MethodHandle MagickSetImageAlphaColor$handle() { + return MagickSetImageAlphaColor.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageAlphaColor(MagickWand *, const PixelWand *) + * } + */ + public static MemorySegment MagickSetImageAlphaColor$address() { + return MagickSetImageAlphaColor.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageAlphaColor(MagickWand *, const PixelWand *) + * } + */ + public static int MagickSetImageAlphaColor(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetImageAlphaColor.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetImageAlphaColor", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class DisplayImageCommand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DisplayImageCommand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType DisplayImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static FunctionDescriptor DisplayImageCommand$descriptor() { + return DisplayImageCommand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType DisplayImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MethodHandle DisplayImageCommand$handle() { + return DisplayImageCommand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType DisplayImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MemorySegment DisplayImageCommand$address() { + return DisplayImageCommand.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType DisplayImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static int DisplayImageCommand(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = DisplayImageCommand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("DisplayImageCommand", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class DrawGetException { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DrawGetException"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char *DrawGetException(const DrawingWand *, ExceptionType *) + * } + */ + public static FunctionDescriptor DrawGetException$descriptor() { + return DrawGetException.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char *DrawGetException(const DrawingWand *, ExceptionType *) + * } + */ + public static MethodHandle DrawGetException$handle() { + return DrawGetException.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char *DrawGetException(const DrawingWand *, ExceptionType *) + * } + */ + public static MemorySegment DrawGetException$address() { + return DrawGetException.ADDR; + } + + /** + * {@snippet lang=c : + * extern char *DrawGetException(const DrawingWand *, ExceptionType *) + * } + */ + public static MemorySegment DrawGetException(MemorySegment x0, MemorySegment x1) { + var mh$ = DrawGetException.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("DrawGetException", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class PeekDrawingWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PeekDrawingWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern DrawInfo *PeekDrawingWand(const DrawingWand *) + * } + */ + public static FunctionDescriptor PeekDrawingWand$descriptor() { + return PeekDrawingWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern DrawInfo *PeekDrawingWand(const DrawingWand *) + * } + */ + public static MethodHandle PeekDrawingWand$handle() { + return PeekDrawingWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern DrawInfo *PeekDrawingWand(const DrawingWand *) + * } + */ + public static MemorySegment PeekDrawingWand$address() { + return PeekDrawingWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern DrawInfo *PeekDrawingWand(const DrawingWand *) + * } + */ + public static MemorySegment PeekDrawingWand(MemorySegment x0) { + var mh$ = PeekDrawingWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("PeekDrawingWand", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class AcquireDrawingWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("AcquireDrawingWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern DrawingWand *AcquireDrawingWand(const DrawInfo *, Image *) + * } + */ + public static FunctionDescriptor AcquireDrawingWand$descriptor() { + return AcquireDrawingWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern DrawingWand *AcquireDrawingWand(const DrawInfo *, Image *) + * } + */ + public static MethodHandle AcquireDrawingWand$handle() { + return AcquireDrawingWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern DrawingWand *AcquireDrawingWand(const DrawInfo *, Image *) + * } + */ + public static MemorySegment AcquireDrawingWand$address() { + return AcquireDrawingWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern DrawingWand *AcquireDrawingWand(const DrawInfo *, Image *) + * } + */ + public static MemorySegment AcquireDrawingWand(MemorySegment x0, MemorySegment x1) { + var mh$ = AcquireDrawingWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("AcquireDrawingWand", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class CloneDrawingWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("CloneDrawingWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern DrawingWand *CloneDrawingWand(const DrawingWand *) + * } + */ + public static FunctionDescriptor CloneDrawingWand$descriptor() { + return CloneDrawingWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern DrawingWand *CloneDrawingWand(const DrawingWand *) + * } + */ + public static MethodHandle CloneDrawingWand$handle() { + return CloneDrawingWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern DrawingWand *CloneDrawingWand(const DrawingWand *) + * } + */ + public static MemorySegment CloneDrawingWand$address() { + return CloneDrawingWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern DrawingWand *CloneDrawingWand(const DrawingWand *) + * } + */ + public static MemorySegment CloneDrawingWand(MemorySegment x0) { + var mh$ = CloneDrawingWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("CloneDrawingWand", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class DestroyDrawingWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DestroyDrawingWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern DrawingWand *DestroyDrawingWand(DrawingWand *) + * } + */ + public static FunctionDescriptor DestroyDrawingWand$descriptor() { + return DestroyDrawingWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern DrawingWand *DestroyDrawingWand(DrawingWand *) + * } + */ + public static MethodHandle DestroyDrawingWand$handle() { + return DestroyDrawingWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern DrawingWand *DestroyDrawingWand(DrawingWand *) + * } + */ + public static MemorySegment DestroyDrawingWand$address() { + return DestroyDrawingWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern DrawingWand *DestroyDrawingWand(DrawingWand *) + * } + */ + public static MemorySegment DestroyDrawingWand(MemorySegment x0) { + var mh$ = DestroyDrawingWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("DestroyDrawingWand", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class NewDrawingWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("NewDrawingWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern DrawingWand *NewDrawingWand() + * } + */ + public static FunctionDescriptor NewDrawingWand$descriptor() { + return NewDrawingWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern DrawingWand *NewDrawingWand() + * } + */ + public static MethodHandle NewDrawingWand$handle() { + return NewDrawingWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern DrawingWand *NewDrawingWand() + * } + */ + public static MemorySegment NewDrawingWand$address() { + return NewDrawingWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern DrawingWand *NewDrawingWand() + * } + */ + public static MemorySegment NewDrawingWand() { + var mh$ = NewDrawingWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("NewDrawingWand"); + } + return (MemorySegment)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class DrawCloneExceptionInfo { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DrawCloneExceptionInfo"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern ExceptionInfo *DrawCloneExceptionInfo(const DrawingWand *wand) + * } + */ + public static FunctionDescriptor DrawCloneExceptionInfo$descriptor() { + return DrawCloneExceptionInfo.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern ExceptionInfo *DrawCloneExceptionInfo(const DrawingWand *wand) + * } + */ + public static MethodHandle DrawCloneExceptionInfo$handle() { + return DrawCloneExceptionInfo.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern ExceptionInfo *DrawCloneExceptionInfo(const DrawingWand *wand) + * } + */ + public static MemorySegment DrawCloneExceptionInfo$address() { + return DrawCloneExceptionInfo.ADDR; + } + + /** + * {@snippet lang=c : + * extern ExceptionInfo *DrawCloneExceptionInfo(const DrawingWand *wand) + * } + */ + public static MemorySegment DrawCloneExceptionInfo(MemorySegment wand) { + var mh$ = DrawCloneExceptionInfo.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("DrawCloneExceptionInfo", wand); + } + return (MemorySegment)mh$.invokeExact(wand); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class DrawGetExceptionType { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DrawGetExceptionType"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern ExceptionType DrawGetExceptionType(const DrawingWand *) + * } + */ + public static FunctionDescriptor DrawGetExceptionType$descriptor() { + return DrawGetExceptionType.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern ExceptionType DrawGetExceptionType(const DrawingWand *) + * } + */ + public static MethodHandle DrawGetExceptionType$handle() { + return DrawGetExceptionType.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern ExceptionType DrawGetExceptionType(const DrawingWand *) + * } + */ + public static MemorySegment DrawGetExceptionType$address() { + return DrawGetExceptionType.ADDR; + } + + /** + * {@snippet lang=c : + * extern ExceptionType DrawGetExceptionType(const DrawingWand *) + * } + */ + public static int DrawGetExceptionType(MemorySegment x0) { + var mh$ = DrawGetExceptionType.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("DrawGetExceptionType", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class DrawClearException { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DrawClearException"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType DrawClearException(DrawingWand *) + * } + */ + public static FunctionDescriptor DrawClearException$descriptor() { + return DrawClearException.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType DrawClearException(DrawingWand *) + * } + */ + public static MethodHandle DrawClearException$handle() { + return DrawClearException.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType DrawClearException(DrawingWand *) + * } + */ + public static MemorySegment DrawClearException$address() { + return DrawClearException.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType DrawClearException(DrawingWand *) + * } + */ + public static int DrawClearException(MemorySegment x0) { + var mh$ = DrawClearException.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("DrawClearException", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class IsDrawingWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("IsDrawingWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType IsDrawingWand(const DrawingWand *) + * } + */ + public static FunctionDescriptor IsDrawingWand$descriptor() { + return IsDrawingWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType IsDrawingWand(const DrawingWand *) + * } + */ + public static MethodHandle IsDrawingWand$handle() { + return IsDrawingWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType IsDrawingWand(const DrawingWand *) + * } + */ + public static MemorySegment IsDrawingWand$address() { + return IsDrawingWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType IsDrawingWand(const DrawingWand *) + * } + */ + public static int IsDrawingWand(MemorySegment x0) { + var mh$ = IsDrawingWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("IsDrawingWand", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class PopDrawingWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PopDrawingWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType PopDrawingWand(DrawingWand *) + * } + */ + public static FunctionDescriptor PopDrawingWand$descriptor() { + return PopDrawingWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType PopDrawingWand(DrawingWand *) + * } + */ + public static MethodHandle PopDrawingWand$handle() { + return PopDrawingWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType PopDrawingWand(DrawingWand *) + * } + */ + public static MemorySegment PopDrawingWand$address() { + return PopDrawingWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType PopDrawingWand(DrawingWand *) + * } + */ + public static int PopDrawingWand(MemorySegment x0) { + var mh$ = PopDrawingWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("PopDrawingWand", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class PushDrawingWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PushDrawingWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType PushDrawingWand(DrawingWand *) + * } + */ + public static FunctionDescriptor PushDrawingWand$descriptor() { + return PushDrawingWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType PushDrawingWand(DrawingWand *) + * } + */ + public static MethodHandle PushDrawingWand$handle() { + return PushDrawingWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType PushDrawingWand(DrawingWand *) + * } + */ + public static MemorySegment PushDrawingWand$address() { + return PushDrawingWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType PushDrawingWand(DrawingWand *) + * } + */ + public static int PushDrawingWand(MemorySegment x0) { + var mh$ = PushDrawingWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("PushDrawingWand", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ClearDrawingWand { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ClearDrawingWand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void ClearDrawingWand(DrawingWand *) + * } + */ + public static FunctionDescriptor ClearDrawingWand$descriptor() { + return ClearDrawingWand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void ClearDrawingWand(DrawingWand *) + * } + */ + public static MethodHandle ClearDrawingWand$handle() { + return ClearDrawingWand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void ClearDrawingWand(DrawingWand *) + * } + */ + public static MemorySegment ClearDrawingWand$address() { + return ClearDrawingWand.ADDR; + } + + /** + * {@snippet lang=c : + * extern void ClearDrawingWand(DrawingWand *) + * } + */ + public static void ClearDrawingWand(MemorySegment x0) { + var mh$ = ClearDrawingWand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ClearDrawingWand", x0); + } + mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class IdentifyImageCommand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("IdentifyImageCommand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType IdentifyImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static FunctionDescriptor IdentifyImageCommand$descriptor() { + return IdentifyImageCommand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType IdentifyImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MethodHandle IdentifyImageCommand$handle() { + return IdentifyImageCommand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType IdentifyImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MemorySegment IdentifyImageCommand$address() { + return IdentifyImageCommand.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType IdentifyImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static int IdentifyImageCommand(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = IdentifyImageCommand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("IdentifyImageCommand", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ImportImageCommand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ImportImageCommand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType ImportImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static FunctionDescriptor ImportImageCommand$descriptor() { + return ImportImageCommand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType ImportImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MethodHandle ImportImageCommand$handle() { + return ImportImageCommand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType ImportImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MemorySegment ImportImageCommand$address() { + return ImportImageCommand.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType ImportImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static int ImportImageCommand(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = ImportImageCommand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ImportImageCommand", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class AcquireMagickCLI { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("AcquireMagickCLI"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickCLI *AcquireMagickCLI(ImageInfo *, ExceptionInfo *) + * } + */ + public static FunctionDescriptor AcquireMagickCLI$descriptor() { + return AcquireMagickCLI.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickCLI *AcquireMagickCLI(ImageInfo *, ExceptionInfo *) + * } + */ + public static MethodHandle AcquireMagickCLI$handle() { + return AcquireMagickCLI.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickCLI *AcquireMagickCLI(ImageInfo *, ExceptionInfo *) + * } + */ + public static MemorySegment AcquireMagickCLI$address() { + return AcquireMagickCLI.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickCLI *AcquireMagickCLI(ImageInfo *, ExceptionInfo *) + * } + */ + public static MemorySegment AcquireMagickCLI(MemorySegment x0, MemorySegment x1) { + var mh$ = AcquireMagickCLI.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("AcquireMagickCLI", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class DestroyMagickCLI { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DestroyMagickCLI"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickCLI *DestroyMagickCLI(MagickCLI *) + * } + */ + public static FunctionDescriptor DestroyMagickCLI$descriptor() { + return DestroyMagickCLI.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickCLI *DestroyMagickCLI(MagickCLI *) + * } + */ + public static MethodHandle DestroyMagickCLI$handle() { + return DestroyMagickCLI.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickCLI *DestroyMagickCLI(MagickCLI *) + * } + */ + public static MemorySegment DestroyMagickCLI$address() { + return DestroyMagickCLI.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickCLI *DestroyMagickCLI(MagickCLI *) + * } + */ + public static MemorySegment DestroyMagickCLI(MemorySegment x0) { + var mh$ = DestroyMagickCLI.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("DestroyMagickCLI", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class CLICatchException { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("CLICatchException"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType CLICatchException(MagickCLI *, const MagickBooleanType) + * } + */ + public static FunctionDescriptor CLICatchException$descriptor() { + return CLICatchException.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType CLICatchException(MagickCLI *, const MagickBooleanType) + * } + */ + public static MethodHandle CLICatchException$handle() { + return CLICatchException.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType CLICatchException(MagickCLI *, const MagickBooleanType) + * } + */ + public static MemorySegment CLICatchException$address() { + return CLICatchException.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType CLICatchException(MagickCLI *, const MagickBooleanType) + * } + */ + public static int CLICatchException(MemorySegment x0, int x1) { + var mh$ = CLICatchException.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("CLICatchException", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + /** + * Variadic invoker class for: + * {@snippet lang=c : + * extern MagickBooleanType CLIThrowException(MagickCLI *, const char *, const char *, const size_t, const ExceptionType, const char *, const char *, ...) + * } + */ + public static class CLIThrowException { + private static final FunctionDescriptor BASE_DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + private static final MemorySegment ADDR = MagickWand_h.findOrThrow("CLIThrowException"); + + private final MethodHandle handle; + private final FunctionDescriptor descriptor; + private final MethodHandle spreader; + + private CLIThrowException(MethodHandle handle, FunctionDescriptor descriptor, MethodHandle spreader) { + this.handle = handle; + this.descriptor = descriptor; + this.spreader = spreader; + } + + /** + * Variadic invoker factory for: + * {@snippet lang=c : + * extern MagickBooleanType CLIThrowException(MagickCLI *, const char *, const char *, const size_t, const ExceptionType, const char *, const char *, ...) + * } + */ + public static CLIThrowException makeInvoker(MemoryLayout... layouts) { + FunctionDescriptor desc$ = BASE_DESC.appendArgumentLayouts(layouts); + Linker.Option fva$ = Linker.Option.firstVariadicArg(BASE_DESC.argumentLayouts().size()); + var mh$ = Linker.nativeLinker().downcallHandle(ADDR, desc$, fva$); + var spreader$ = mh$.asSpreader(Object[].class, layouts.length); + return new CLIThrowException(mh$, desc$, spreader$); + } + + /** + * {@return the address} + */ + public static MemorySegment address() { + return ADDR; + } + + /** + * {@return the specialized method handle} + */ + public MethodHandle handle() { + return handle; + } + + /** + * {@return the specialized descriptor} + */ + public FunctionDescriptor descriptor() { + return descriptor; + } + + public int apply(MemorySegment x0, MemorySegment x1, MemorySegment x2, long x3, int x4, MemorySegment x5, MemorySegment x6, Object... x7) { + try { + if (TRACE_DOWNCALLS) { + traceDowncall("CLIThrowException", x0, x1, x2, x3, x4, x5, x6, x7); + } + return (int)spreader.invokeExact(x0, x1, x2, x3, x4, x5, x6, x7); + } catch(IllegalArgumentException | ClassCastException ex$) { + throw ex$; // rethrow IAE from passing wrong number/type of args + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static class ProcessCommandOptions { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ProcessCommandOptions"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int ProcessCommandOptions(MagickCLI *, int, char **, int) + * } + */ + public static FunctionDescriptor ProcessCommandOptions$descriptor() { + return ProcessCommandOptions.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int ProcessCommandOptions(MagickCLI *, int, char **, int) + * } + */ + public static MethodHandle ProcessCommandOptions$handle() { + return ProcessCommandOptions.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int ProcessCommandOptions(MagickCLI *, int, char **, int) + * } + */ + public static MemorySegment ProcessCommandOptions$address() { + return ProcessCommandOptions.ADDR; + } + + /** + * {@snippet lang=c : + * extern int ProcessCommandOptions(MagickCLI *, int, char **, int) + * } + */ + public static int ProcessCommandOptions(MemorySegment x0, int x1, MemorySegment x2, int x3) { + var mh$ = ProcessCommandOptions.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ProcessCommandOptions", x0, x1, x2, x3); + } + return (int)mh$.invokeExact(x0, x1, x2, x3); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickCommandGenesis { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCommandGenesis"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickCommandGenesis(ImageInfo *, MagickCommand, int, char **, char **, ExceptionInfo *) + * } + */ + public static FunctionDescriptor MagickCommandGenesis$descriptor() { + return MagickCommandGenesis.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickCommandGenesis(ImageInfo *, MagickCommand, int, char **, char **, ExceptionInfo *) + * } + */ + public static MethodHandle MagickCommandGenesis$handle() { + return MagickCommandGenesis.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickCommandGenesis(ImageInfo *, MagickCommand, int, char **, char **, ExceptionInfo *) + * } + */ + public static MemorySegment MagickCommandGenesis$address() { + return MagickCommandGenesis.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickCommandGenesis(ImageInfo *, MagickCommand, int, char **, char **, ExceptionInfo *) + * } + */ + public static int MagickCommandGenesis(MemorySegment x0, MemorySegment x1, int x2, MemorySegment x3, MemorySegment x4, MemorySegment x5) { + var mh$ = MagickCommandGenesis.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickCommandGenesis", x0, x1, x2, x3, x4, x5); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickImageCommand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickImageCommand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static FunctionDescriptor MagickImageCommand$descriptor() { + return MagickImageCommand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MethodHandle MagickImageCommand$handle() { + return MagickImageCommand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static MemorySegment MagickImageCommand$address() { + return MagickImageCommand.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) + * } + */ + public static int MagickImageCommand(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = MagickImageCommand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickImageCommand", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetFilename { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetFilename"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char *MagickGetFilename(const MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetFilename$descriptor() { + return MagickGetFilename.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char *MagickGetFilename(const MagickWand *) + * } + */ + public static MethodHandle MagickGetFilename$handle() { + return MagickGetFilename.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char *MagickGetFilename(const MagickWand *) + * } + */ + public static MemorySegment MagickGetFilename$address() { + return MagickGetFilename.ADDR; + } + + /** + * {@snippet lang=c : + * extern char *MagickGetFilename(const MagickWand *) + * } + */ + public static MemorySegment MagickGetFilename(MemorySegment x0) { + var mh$ = MagickGetFilename.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetFilename", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetFormat { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetFormat"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char *MagickGetFormat(MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetFormat$descriptor() { + return MagickGetFormat.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char *MagickGetFormat(MagickWand *) + * } + */ + public static MethodHandle MagickGetFormat$handle() { + return MagickGetFormat.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char *MagickGetFormat(MagickWand *) + * } + */ + public static MemorySegment MagickGetFormat$address() { + return MagickGetFormat.ADDR; + } + + /** + * {@snippet lang=c : + * extern char *MagickGetFormat(MagickWand *) + * } + */ + public static MemorySegment MagickGetFormat(MemorySegment x0) { + var mh$ = MagickGetFormat.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetFormat", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetFont { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetFont"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char *MagickGetFont(MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetFont$descriptor() { + return MagickGetFont.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char *MagickGetFont(MagickWand *) + * } + */ + public static MethodHandle MagickGetFont$handle() { + return MagickGetFont.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char *MagickGetFont(MagickWand *) + * } + */ + public static MemorySegment MagickGetFont$address() { + return MagickGetFont.ADDR; + } + + /** + * {@snippet lang=c : + * extern char *MagickGetFont(MagickWand *) + * } + */ + public static MemorySegment MagickGetFont(MemorySegment x0) { + var mh$ = MagickGetFont.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetFont", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetHomeURL { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetHomeURL"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char *MagickGetHomeURL() + * } + */ + public static FunctionDescriptor MagickGetHomeURL$descriptor() { + return MagickGetHomeURL.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char *MagickGetHomeURL() + * } + */ + public static MethodHandle MagickGetHomeURL$handle() { + return MagickGetHomeURL.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char *MagickGetHomeURL() + * } + */ + public static MemorySegment MagickGetHomeURL$address() { + return MagickGetHomeURL.ADDR; + } + + /** + * {@snippet lang=c : + * extern char *MagickGetHomeURL() + * } + */ + public static MemorySegment MagickGetHomeURL() { + var mh$ = MagickGetHomeURL.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetHomeURL"); + } + return (MemorySegment)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetImageArtifact { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageArtifact"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char *MagickGetImageArtifact(MagickWand *, const char *) + * } + */ + public static FunctionDescriptor MagickGetImageArtifact$descriptor() { + return MagickGetImageArtifact.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char *MagickGetImageArtifact(MagickWand *, const char *) + * } + */ + public static MethodHandle MagickGetImageArtifact$handle() { + return MagickGetImageArtifact.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char *MagickGetImageArtifact(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickGetImageArtifact$address() { + return MagickGetImageArtifact.ADDR; + } + + /** + * {@snippet lang=c : + * extern char *MagickGetImageArtifact(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickGetImageArtifact(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickGetImageArtifact.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetImageArtifact", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetImageArtifacts { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageArtifacts"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char **MagickGetImageArtifacts(MagickWand *, const char *, size_t *) + * } + */ + public static FunctionDescriptor MagickGetImageArtifacts$descriptor() { + return MagickGetImageArtifacts.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char **MagickGetImageArtifacts(MagickWand *, const char *, size_t *) + * } + */ + public static MethodHandle MagickGetImageArtifacts$handle() { + return MagickGetImageArtifacts.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char **MagickGetImageArtifacts(MagickWand *, const char *, size_t *) + * } + */ + public static MemorySegment MagickGetImageArtifacts$address() { + return MagickGetImageArtifacts.ADDR; + } + + /** + * {@snippet lang=c : + * extern char **MagickGetImageArtifacts(MagickWand *, const char *, size_t *) + * } + */ + public static MemorySegment MagickGetImageArtifacts(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickGetImageArtifacts.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetImageArtifacts", x0, x1, x2); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetImageProfiles { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageProfiles"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char **MagickGetImageProfiles(MagickWand *, const char *, size_t *) + * } + */ + public static FunctionDescriptor MagickGetImageProfiles$descriptor() { + return MagickGetImageProfiles.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char **MagickGetImageProfiles(MagickWand *, const char *, size_t *) + * } + */ + public static MethodHandle MagickGetImageProfiles$handle() { + return MagickGetImageProfiles.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char **MagickGetImageProfiles(MagickWand *, const char *, size_t *) + * } + */ + public static MemorySegment MagickGetImageProfiles$address() { + return MagickGetImageProfiles.ADDR; + } + + /** + * {@snippet lang=c : + * extern char **MagickGetImageProfiles(MagickWand *, const char *, size_t *) + * } + */ + public static MemorySegment MagickGetImageProfiles(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickGetImageProfiles.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetImageProfiles", x0, x1, x2); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetImageProperty { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageProperty"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char *MagickGetImageProperty(MagickWand *, const char *) + * } + */ + public static FunctionDescriptor MagickGetImageProperty$descriptor() { + return MagickGetImageProperty.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char *MagickGetImageProperty(MagickWand *, const char *) + * } + */ + public static MethodHandle MagickGetImageProperty$handle() { + return MagickGetImageProperty.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char *MagickGetImageProperty(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickGetImageProperty$address() { + return MagickGetImageProperty.ADDR; + } + + /** + * {@snippet lang=c : + * extern char *MagickGetImageProperty(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickGetImageProperty(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickGetImageProperty.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetImageProperty", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetImageProperties { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageProperties"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char **MagickGetImageProperties(MagickWand *, const char *, size_t *) + * } + */ + public static FunctionDescriptor MagickGetImageProperties$descriptor() { + return MagickGetImageProperties.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char **MagickGetImageProperties(MagickWand *, const char *, size_t *) + * } + */ + public static MethodHandle MagickGetImageProperties$handle() { + return MagickGetImageProperties.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char **MagickGetImageProperties(MagickWand *, const char *, size_t *) + * } + */ + public static MemorySegment MagickGetImageProperties$address() { + return MagickGetImageProperties.ADDR; + } + + /** + * {@snippet lang=c : + * extern char **MagickGetImageProperties(MagickWand *, const char *, size_t *) + * } + */ + public static MemorySegment MagickGetImageProperties(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickGetImageProperties.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetImageProperties", x0, x1, x2); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetOption { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetOption"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char *MagickGetOption(MagickWand *, const char *) + * } + */ + public static FunctionDescriptor MagickGetOption$descriptor() { + return MagickGetOption.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char *MagickGetOption(MagickWand *, const char *) + * } + */ + public static MethodHandle MagickGetOption$handle() { + return MagickGetOption.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char *MagickGetOption(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickGetOption$address() { + return MagickGetOption.ADDR; + } + + /** + * {@snippet lang=c : + * extern char *MagickGetOption(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickGetOption(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickGetOption.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetOption", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetOptions { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetOptions"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char **MagickGetOptions(MagickWand *, const char *, size_t *) + * } + */ + public static FunctionDescriptor MagickGetOptions$descriptor() { + return MagickGetOptions.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char **MagickGetOptions(MagickWand *, const char *, size_t *) + * } + */ + public static MethodHandle MagickGetOptions$handle() { + return MagickGetOptions.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char **MagickGetOptions(MagickWand *, const char *, size_t *) + * } + */ + public static MemorySegment MagickGetOptions$address() { + return MagickGetOptions.ADDR; + } + + /** + * {@snippet lang=c : + * extern char **MagickGetOptions(MagickWand *, const char *, size_t *) + * } + */ + public static MemorySegment MagickGetOptions(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickGetOptions.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetOptions", x0, x1, x2); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickQueryConfigureOption { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQueryConfigureOption"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char *MagickQueryConfigureOption(const char *) + * } + */ + public static FunctionDescriptor MagickQueryConfigureOption$descriptor() { + return MagickQueryConfigureOption.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char *MagickQueryConfigureOption(const char *) + * } + */ + public static MethodHandle MagickQueryConfigureOption$handle() { + return MagickQueryConfigureOption.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char *MagickQueryConfigureOption(const char *) + * } + */ + public static MemorySegment MagickQueryConfigureOption$address() { + return MagickQueryConfigureOption.ADDR; + } + + /** + * {@snippet lang=c : + * extern char *MagickQueryConfigureOption(const char *) + * } + */ + public static MemorySegment MagickQueryConfigureOption(MemorySegment x0) { + var mh$ = MagickQueryConfigureOption.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickQueryConfigureOption", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickQueryConfigureOptions { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQueryConfigureOptions"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char **MagickQueryConfigureOptions(const char *, size_t *) + * } + */ + public static FunctionDescriptor MagickQueryConfigureOptions$descriptor() { + return MagickQueryConfigureOptions.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char **MagickQueryConfigureOptions(const char *, size_t *) + * } + */ + public static MethodHandle MagickQueryConfigureOptions$handle() { + return MagickQueryConfigureOptions.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char **MagickQueryConfigureOptions(const char *, size_t *) + * } + */ + public static MemorySegment MagickQueryConfigureOptions$address() { + return MagickQueryConfigureOptions.ADDR; + } + + /** + * {@snippet lang=c : + * extern char **MagickQueryConfigureOptions(const char *, size_t *) + * } + */ + public static MemorySegment MagickQueryConfigureOptions(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickQueryConfigureOptions.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickQueryConfigureOptions", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickQueryFonts { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQueryFonts"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char **MagickQueryFonts(const char *, size_t *) + * } + */ + public static FunctionDescriptor MagickQueryFonts$descriptor() { + return MagickQueryFonts.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char **MagickQueryFonts(const char *, size_t *) + * } + */ + public static MethodHandle MagickQueryFonts$handle() { + return MagickQueryFonts.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char **MagickQueryFonts(const char *, size_t *) + * } + */ + public static MemorySegment MagickQueryFonts$address() { + return MagickQueryFonts.ADDR; + } + + /** + * {@snippet lang=c : + * extern char **MagickQueryFonts(const char *, size_t *) + * } + */ + public static MemorySegment MagickQueryFonts(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickQueryFonts.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickQueryFonts", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickQueryFormats { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQueryFormats"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern char **MagickQueryFormats(const char *, size_t *) + * } + */ + public static FunctionDescriptor MagickQueryFormats$descriptor() { + return MagickQueryFormats.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern char **MagickQueryFormats(const char *, size_t *) + * } + */ + public static MethodHandle MagickQueryFormats$handle() { + return MagickQueryFormats.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern char **MagickQueryFormats(const char *, size_t *) + * } + */ + public static MemorySegment MagickQueryFormats$address() { + return MagickQueryFormats.ADDR; + } + + /** + * {@snippet lang=c : + * extern char **MagickQueryFormats(const char *, size_t *) + * } + */ + public static MemorySegment MagickQueryFormats(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickQueryFormats.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickQueryFormats", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetColorspace { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetColorspace"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern ColorspaceType MagickGetColorspace(MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetColorspace$descriptor() { + return MagickGetColorspace.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern ColorspaceType MagickGetColorspace(MagickWand *) + * } + */ + public static MethodHandle MagickGetColorspace$handle() { + return MagickGetColorspace.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern ColorspaceType MagickGetColorspace(MagickWand *) + * } + */ + public static MemorySegment MagickGetColorspace$address() { + return MagickGetColorspace.ADDR; + } + + /** + * {@snippet lang=c : + * extern ColorspaceType MagickGetColorspace(MagickWand *) + * } + */ + public static int MagickGetColorspace(MemorySegment x0) { + var mh$ = MagickGetColorspace.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetColorspace", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetCompression { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetCompression"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern CompressionType MagickGetCompression(MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetCompression$descriptor() { + return MagickGetCompression.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern CompressionType MagickGetCompression(MagickWand *) + * } + */ + public static MethodHandle MagickGetCompression$handle() { + return MagickGetCompression.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern CompressionType MagickGetCompression(MagickWand *) + * } + */ + public static MemorySegment MagickGetCompression$address() { + return MagickGetCompression.ADDR; + } + + /** + * {@snippet lang=c : + * extern CompressionType MagickGetCompression(MagickWand *) + * } + */ + public static int MagickGetCompression(MemorySegment x0) { + var mh$ = MagickGetCompression.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetCompression", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetCopyright { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetCopyright"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *MagickGetCopyright() + * } + */ + public static FunctionDescriptor MagickGetCopyright$descriptor() { + return MagickGetCopyright.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *MagickGetCopyright() + * } + */ + public static MethodHandle MagickGetCopyright$handle() { + return MagickGetCopyright.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *MagickGetCopyright() + * } + */ + public static MemorySegment MagickGetCopyright$address() { + return MagickGetCopyright.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *MagickGetCopyright() + * } + */ + public static MemorySegment MagickGetCopyright() { + var mh$ = MagickGetCopyright.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetCopyright"); + } + return (MemorySegment)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetPackageName { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetPackageName"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *MagickGetPackageName() + * } + */ + public static FunctionDescriptor MagickGetPackageName$descriptor() { + return MagickGetPackageName.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *MagickGetPackageName() + * } + */ + public static MethodHandle MagickGetPackageName$handle() { + return MagickGetPackageName.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *MagickGetPackageName() + * } + */ + public static MemorySegment MagickGetPackageName$address() { + return MagickGetPackageName.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *MagickGetPackageName() + * } + */ + public static MemorySegment MagickGetPackageName() { + var mh$ = MagickGetPackageName.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetPackageName"); + } + return (MemorySegment)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetQuantumDepth { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetQuantumDepth"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *MagickGetQuantumDepth(size_t *) + * } + */ + public static FunctionDescriptor MagickGetQuantumDepth$descriptor() { + return MagickGetQuantumDepth.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *MagickGetQuantumDepth(size_t *) + * } + */ + public static MethodHandle MagickGetQuantumDepth$handle() { + return MagickGetQuantumDepth.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *MagickGetQuantumDepth(size_t *) + * } + */ + public static MemorySegment MagickGetQuantumDepth$address() { + return MagickGetQuantumDepth.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *MagickGetQuantumDepth(size_t *) + * } + */ + public static MemorySegment MagickGetQuantumDepth(MemorySegment x0) { + var mh$ = MagickGetQuantumDepth.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetQuantumDepth", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetQuantumRange { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetQuantumRange"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *MagickGetQuantumRange(size_t *) + * } + */ + public static FunctionDescriptor MagickGetQuantumRange$descriptor() { + return MagickGetQuantumRange.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *MagickGetQuantumRange(size_t *) + * } + */ + public static MethodHandle MagickGetQuantumRange$handle() { + return MagickGetQuantumRange.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *MagickGetQuantumRange(size_t *) + * } + */ + public static MemorySegment MagickGetQuantumRange$address() { + return MagickGetQuantumRange.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *MagickGetQuantumRange(size_t *) + * } + */ + public static MemorySegment MagickGetQuantumRange(MemorySegment x0) { + var mh$ = MagickGetQuantumRange.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetQuantumRange", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetReleaseDate { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetReleaseDate"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *MagickGetReleaseDate() + * } + */ + public static FunctionDescriptor MagickGetReleaseDate$descriptor() { + return MagickGetReleaseDate.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *MagickGetReleaseDate() + * } + */ + public static MethodHandle MagickGetReleaseDate$handle() { + return MagickGetReleaseDate.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *MagickGetReleaseDate() + * } + */ + public static MemorySegment MagickGetReleaseDate$address() { + return MagickGetReleaseDate.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *MagickGetReleaseDate() + * } + */ + public static MemorySegment MagickGetReleaseDate() { + var mh$ = MagickGetReleaseDate.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetReleaseDate"); + } + return (MemorySegment)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetVersion { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetVersion"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern const char *MagickGetVersion(size_t *) + * } + */ + public static FunctionDescriptor MagickGetVersion$descriptor() { + return MagickGetVersion.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern const char *MagickGetVersion(size_t *) + * } + */ + public static MethodHandle MagickGetVersion$handle() { + return MagickGetVersion.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern const char *MagickGetVersion(size_t *) + * } + */ + public static MemorySegment MagickGetVersion$address() { + return MagickGetVersion.ADDR; + } + + /** + * {@snippet lang=c : + * extern const char *MagickGetVersion(size_t *) + * } + */ + public static MemorySegment MagickGetVersion(MemorySegment x0) { + var mh$ = MagickGetVersion.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetVersion", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetPointsize { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_DOUBLE, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetPointsize"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double MagickGetPointsize(MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetPointsize$descriptor() { + return MagickGetPointsize.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double MagickGetPointsize(MagickWand *) + * } + */ + public static MethodHandle MagickGetPointsize$handle() { + return MagickGetPointsize.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double MagickGetPointsize(MagickWand *) + * } + */ + public static MemorySegment MagickGetPointsize$address() { + return MagickGetPointsize.ADDR; + } + + /** + * {@snippet lang=c : + * extern double MagickGetPointsize(MagickWand *) + * } + */ + public static double MagickGetPointsize(MemorySegment x0) { + var mh$ = MagickGetPointsize.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetPointsize", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetSamplingFactors { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetSamplingFactors"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double *MagickGetSamplingFactors(MagickWand *, size_t *) + * } + */ + public static FunctionDescriptor MagickGetSamplingFactors$descriptor() { + return MagickGetSamplingFactors.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double *MagickGetSamplingFactors(MagickWand *, size_t *) + * } + */ + public static MethodHandle MagickGetSamplingFactors$handle() { + return MagickGetSamplingFactors.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double *MagickGetSamplingFactors(MagickWand *, size_t *) + * } + */ + public static MemorySegment MagickGetSamplingFactors$address() { + return MagickGetSamplingFactors.ADDR; + } + + /** + * {@snippet lang=c : + * extern double *MagickGetSamplingFactors(MagickWand *, size_t *) + * } + */ + public static MemorySegment MagickGetSamplingFactors(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickGetSamplingFactors.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetSamplingFactors", x0, x1); + } + return (MemorySegment)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickQueryFontMetrics { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQueryFontMetrics"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double *MagickQueryFontMetrics(MagickWand *, const DrawingWand *, const char *) + * } + */ + public static FunctionDescriptor MagickQueryFontMetrics$descriptor() { + return MagickQueryFontMetrics.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double *MagickQueryFontMetrics(MagickWand *, const DrawingWand *, const char *) + * } + */ + public static MethodHandle MagickQueryFontMetrics$handle() { + return MagickQueryFontMetrics.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double *MagickQueryFontMetrics(MagickWand *, const DrawingWand *, const char *) + * } + */ + public static MemorySegment MagickQueryFontMetrics$address() { + return MagickQueryFontMetrics.ADDR; + } + + /** + * {@snippet lang=c : + * extern double *MagickQueryFontMetrics(MagickWand *, const DrawingWand *, const char *) + * } + */ + public static MemorySegment MagickQueryFontMetrics(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickQueryFontMetrics.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickQueryFontMetrics", x0, x1, x2); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickQueryMultilineFontMetrics { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQueryMultilineFontMetrics"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double *MagickQueryMultilineFontMetrics(MagickWand *, const DrawingWand *, const char *) + * } + */ + public static FunctionDescriptor MagickQueryMultilineFontMetrics$descriptor() { + return MagickQueryMultilineFontMetrics.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double *MagickQueryMultilineFontMetrics(MagickWand *, const DrawingWand *, const char *) + * } + */ + public static MethodHandle MagickQueryMultilineFontMetrics$handle() { + return MagickQueryMultilineFontMetrics.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double *MagickQueryMultilineFontMetrics(MagickWand *, const DrawingWand *, const char *) + * } + */ + public static MemorySegment MagickQueryMultilineFontMetrics$address() { + return MagickQueryMultilineFontMetrics.ADDR; + } + + /** + * {@snippet lang=c : + * extern double *MagickQueryMultilineFontMetrics(MagickWand *, const DrawingWand *, const char *) + * } + */ + public static MemorySegment MagickQueryMultilineFontMetrics(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickQueryMultilineFontMetrics.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickQueryMultilineFontMetrics", x0, x1, x2); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetFilter { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetFilter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern FilterType MagickGetFilter(MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetFilter$descriptor() { + return MagickGetFilter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern FilterType MagickGetFilter(MagickWand *) + * } + */ + public static MethodHandle MagickGetFilter$handle() { + return MagickGetFilter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern FilterType MagickGetFilter(MagickWand *) + * } + */ + public static MemorySegment MagickGetFilter$address() { + return MagickGetFilter.ADDR; + } + + /** + * {@snippet lang=c : + * extern FilterType MagickGetFilter(MagickWand *) + * } + */ + public static int MagickGetFilter(MemorySegment x0) { + var mh$ = MagickGetFilter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetFilter", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetGravity { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetGravity"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern GravityType MagickGetGravity(MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetGravity$descriptor() { + return MagickGetGravity.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern GravityType MagickGetGravity(MagickWand *) + * } + */ + public static MethodHandle MagickGetGravity$handle() { + return MagickGetGravity.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern GravityType MagickGetGravity(MagickWand *) + * } + */ + public static MemorySegment MagickGetGravity$address() { + return MagickGetGravity.ADDR; + } + + /** + * {@snippet lang=c : + * extern GravityType MagickGetGravity(MagickWand *) + * } + */ + public static int MagickGetGravity(MemorySegment x0) { + var mh$ = MagickGetGravity.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetGravity", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetType { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetType"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern ImageType MagickGetType(MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetType$descriptor() { + return MagickGetType.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern ImageType MagickGetType(MagickWand *) + * } + */ + public static MethodHandle MagickGetType$handle() { + return MagickGetType.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern ImageType MagickGetType(MagickWand *) + * } + */ + public static MemorySegment MagickGetType$address() { + return MagickGetType.ADDR; + } + /** - * Function descriptor for: * {@snippet lang=c : * extern ImageType MagickGetType(MagickWand *) * } */ - public static FunctionDescriptor MagickGetType$descriptor() { - return MagickGetType.DESC; + public static int MagickGetType(MemorySegment x0) { + var mh$ = MagickGetType.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetType", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetInterlaceScheme { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetInterlaceScheme"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern InterlaceType MagickGetInterlaceScheme(MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetInterlaceScheme$descriptor() { + return MagickGetInterlaceScheme.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern InterlaceType MagickGetInterlaceScheme(MagickWand *) + * } + */ + public static MethodHandle MagickGetInterlaceScheme$handle() { + return MagickGetInterlaceScheme.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern InterlaceType MagickGetInterlaceScheme(MagickWand *) + * } + */ + public static MemorySegment MagickGetInterlaceScheme$address() { + return MagickGetInterlaceScheme.ADDR; + } + + /** + * {@snippet lang=c : + * extern InterlaceType MagickGetInterlaceScheme(MagickWand *) + * } + */ + public static int MagickGetInterlaceScheme(MemorySegment x0) { + var mh$ = MagickGetInterlaceScheme.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetInterlaceScheme", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetInterpolateMethod { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetInterpolateMethod"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern PixelInterpolateMethod MagickGetInterpolateMethod(MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetInterpolateMethod$descriptor() { + return MagickGetInterpolateMethod.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern PixelInterpolateMethod MagickGetInterpolateMethod(MagickWand *) + * } + */ + public static MethodHandle MagickGetInterpolateMethod$handle() { + return MagickGetInterpolateMethod.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern PixelInterpolateMethod MagickGetInterpolateMethod(MagickWand *) + * } + */ + public static MemorySegment MagickGetInterpolateMethod$address() { + return MagickGetInterpolateMethod.ADDR; + } + + /** + * {@snippet lang=c : + * extern PixelInterpolateMethod MagickGetInterpolateMethod(MagickWand *) + * } + */ + public static int MagickGetInterpolateMethod(MemorySegment x0) { + var mh$ = MagickGetInterpolateMethod.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetInterpolateMethod", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetOrientation { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetOrientation"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern OrientationType MagickGetOrientation(MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetOrientation$descriptor() { + return MagickGetOrientation.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern OrientationType MagickGetOrientation(MagickWand *) + * } + */ + public static MethodHandle MagickGetOrientation$handle() { + return MagickGetOrientation.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern OrientationType MagickGetOrientation(MagickWand *) + * } + */ + public static MemorySegment MagickGetOrientation$address() { + return MagickGetOrientation.ADDR; + } + + /** + * {@snippet lang=c : + * extern OrientationType MagickGetOrientation(MagickWand *) + * } + */ + public static int MagickGetOrientation(MemorySegment x0) { + var mh$ = MagickGetOrientation.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetOrientation", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickDeleteImageArtifact { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDeleteImageArtifact"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickDeleteImageArtifact(MagickWand *, const char *) + * } + */ + public static FunctionDescriptor MagickDeleteImageArtifact$descriptor() { + return MagickDeleteImageArtifact.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickDeleteImageArtifact(MagickWand *, const char *) + * } + */ + public static MethodHandle MagickDeleteImageArtifact$handle() { + return MagickDeleteImageArtifact.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickDeleteImageArtifact(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickDeleteImageArtifact$address() { + return MagickDeleteImageArtifact.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickDeleteImageArtifact(MagickWand *, const char *) + * } + */ + public static int MagickDeleteImageArtifact(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickDeleteImageArtifact.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickDeleteImageArtifact", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickDeleteImageProperty { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDeleteImageProperty"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickDeleteImageProperty(MagickWand *, const char *) + * } + */ + public static FunctionDescriptor MagickDeleteImageProperty$descriptor() { + return MagickDeleteImageProperty.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickDeleteImageProperty(MagickWand *, const char *) + * } + */ + public static MethodHandle MagickDeleteImageProperty$handle() { + return MagickDeleteImageProperty.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickDeleteImageProperty(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickDeleteImageProperty$address() { + return MagickDeleteImageProperty.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickDeleteImageProperty(MagickWand *, const char *) + * } + */ + public static int MagickDeleteImageProperty(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickDeleteImageProperty.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickDeleteImageProperty", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickDeleteOption { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDeleteOption"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickDeleteOption(MagickWand *, const char *) + * } + */ + public static FunctionDescriptor MagickDeleteOption$descriptor() { + return MagickDeleteOption.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickDeleteOption(MagickWand *, const char *) + * } + */ + public static MethodHandle MagickDeleteOption$handle() { + return MagickDeleteOption.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickDeleteOption(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickDeleteOption$address() { + return MagickDeleteOption.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickDeleteOption(MagickWand *, const char *) + * } + */ + public static int MagickDeleteOption(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickDeleteOption.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickDeleteOption", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetAntialias { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetAntialias"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetAntialias(const MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetAntialias$descriptor() { + return MagickGetAntialias.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetAntialias(const MagickWand *) + * } + */ + public static MethodHandle MagickGetAntialias$handle() { + return MagickGetAntialias.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetAntialias(const MagickWand *) + * } + */ + public static MemorySegment MagickGetAntialias$address() { + return MagickGetAntialias.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickGetAntialias(const MagickWand *) + * } + */ + public static int MagickGetAntialias(MemorySegment x0) { + var mh$ = MagickGetAntialias.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetAntialias", x0); + } + return (int)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetPage { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetPage"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetPage(const MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) + * } + */ + public static FunctionDescriptor MagickGetPage$descriptor() { + return MagickGetPage.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetPage(const MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) + * } + */ + public static MethodHandle MagickGetPage$handle() { + return MagickGetPage.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetPage(const MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) + * } + */ + public static MemorySegment MagickGetPage$address() { + return MagickGetPage.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickGetPage(const MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) + * } + */ + public static int MagickGetPage(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = MagickGetPage.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetPage", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetResolution { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetResolution"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetResolution(const MagickWand *, double *, double *) + * } + */ + public static FunctionDescriptor MagickGetResolution$descriptor() { + return MagickGetResolution.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetResolution(const MagickWand *, double *, double *) + * } + */ + public static MethodHandle MagickGetResolution$handle() { + return MagickGetResolution.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetResolution(const MagickWand *, double *, double *) + * } + */ + public static MemorySegment MagickGetResolution$address() { + return MagickGetResolution.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickGetResolution(const MagickWand *, double *, double *) + * } + */ + public static int MagickGetResolution(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickGetResolution.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetResolution", x0, x1, x2); + } + return (int)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetSize { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetSize"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetSize(const MagickWand *, size_t *, size_t *) + * } + */ + public static FunctionDescriptor MagickGetSize$descriptor() { + return MagickGetSize.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetSize(const MagickWand *, size_t *, size_t *) + * } + */ + public static MethodHandle MagickGetSize$handle() { + return MagickGetSize.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetSize(const MagickWand *, size_t *, size_t *) + * } + */ + public static MemorySegment MagickGetSize$address() { + return MagickGetSize.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickGetSize(const MagickWand *, size_t *, size_t *) + * } + */ + public static int MagickGetSize(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickGetSize.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetSize", x0, x1, x2); + } + return (int)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetSizeOffset { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetSizeOffset"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetSizeOffset(const MagickWand *, ssize_t *) + * } + */ + public static FunctionDescriptor MagickGetSizeOffset$descriptor() { + return MagickGetSizeOffset.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetSizeOffset(const MagickWand *, ssize_t *) + * } + */ + public static MethodHandle MagickGetSizeOffset$handle() { + return MagickGetSizeOffset.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickGetSizeOffset(const MagickWand *, ssize_t *) + * } + */ + public static MemorySegment MagickGetSizeOffset$address() { + return MagickGetSizeOffset.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickGetSizeOffset(const MagickWand *, ssize_t *) + * } + */ + public static int MagickGetSizeOffset(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickGetSizeOffset.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetSizeOffset", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickProfileImage { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickProfileImage"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickProfileImage(MagickWand *, const char *, const void *, const size_t) + * } + */ + public static FunctionDescriptor MagickProfileImage$descriptor() { + return MagickProfileImage.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickProfileImage(MagickWand *, const char *, const void *, const size_t) + * } + */ + public static MethodHandle MagickProfileImage$handle() { + return MagickProfileImage.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickProfileImage(MagickWand *, const char *, const void *, const size_t) + * } + */ + public static MemorySegment MagickProfileImage$address() { + return MagickProfileImage.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickProfileImage(MagickWand *, const char *, const void *, const size_t) + * } + */ + public static int MagickProfileImage(MemorySegment x0, MemorySegment x1, MemorySegment x2, long x3) { + var mh$ = MagickProfileImage.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickProfileImage", x0, x1, x2, x3); + } + return (int)mh$.invokeExact(x0, x1, x2, x3); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetAntialias { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetAntialias"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetAntialias(MagickWand *, const MagickBooleanType) + * } + */ + public static FunctionDescriptor MagickSetAntialias$descriptor() { + return MagickSetAntialias.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetAntialias(MagickWand *, const MagickBooleanType) + * } + */ + public static MethodHandle MagickSetAntialias$handle() { + return MagickSetAntialias.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetAntialias(MagickWand *, const MagickBooleanType) + * } + */ + public static MemorySegment MagickSetAntialias$address() { + return MagickSetAntialias.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetAntialias(MagickWand *, const MagickBooleanType) + * } + */ + public static int MagickSetAntialias(MemorySegment x0, int x1) { + var mh$ = MagickSetAntialias.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetAntialias", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetBackgroundColor { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetBackgroundColor"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetBackgroundColor(MagickWand *, const PixelWand *) + * } + */ + public static FunctionDescriptor MagickSetBackgroundColor$descriptor() { + return MagickSetBackgroundColor.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetBackgroundColor(MagickWand *, const PixelWand *) + * } + */ + public static MethodHandle MagickSetBackgroundColor$handle() { + return MagickSetBackgroundColor.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetBackgroundColor(MagickWand *, const PixelWand *) + * } + */ + public static MemorySegment MagickSetBackgroundColor$address() { + return MagickSetBackgroundColor.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetBackgroundColor(MagickWand *, const PixelWand *) + * } + */ + public static int MagickSetBackgroundColor(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetBackgroundColor.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetBackgroundColor", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetColorspace { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetColorspace"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetColorspace(MagickWand *, const ColorspaceType) + * } + */ + public static FunctionDescriptor MagickSetColorspace$descriptor() { + return MagickSetColorspace.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetColorspace(MagickWand *, const ColorspaceType) + * } + */ + public static MethodHandle MagickSetColorspace$handle() { + return MagickSetColorspace.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetColorspace(MagickWand *, const ColorspaceType) + * } + */ + public static MemorySegment MagickSetColorspace$address() { + return MagickSetColorspace.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetColorspace(MagickWand *, const ColorspaceType) + * } + */ + public static int MagickSetColorspace(MemorySegment x0, int x1) { + var mh$ = MagickSetColorspace.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetColorspace", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetCompression { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetCompression"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetCompression(MagickWand *, const CompressionType) + * } + */ + public static FunctionDescriptor MagickSetCompression$descriptor() { + return MagickSetCompression.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetCompression(MagickWand *, const CompressionType) + * } + */ + public static MethodHandle MagickSetCompression$handle() { + return MagickSetCompression.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetCompression(MagickWand *, const CompressionType) + * } + */ + public static MemorySegment MagickSetCompression$address() { + return MagickSetCompression.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetCompression(MagickWand *, const CompressionType) + * } + */ + public static int MagickSetCompression(MemorySegment x0, int x1) { + var mh$ = MagickSetCompression.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetCompression", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetCompressionQuality { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetCompressionQuality"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetCompressionQuality(MagickWand *, const size_t) + * } + */ + public static FunctionDescriptor MagickSetCompressionQuality$descriptor() { + return MagickSetCompressionQuality.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetCompressionQuality(MagickWand *, const size_t) + * } + */ + public static MethodHandle MagickSetCompressionQuality$handle() { + return MagickSetCompressionQuality.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetCompressionQuality(MagickWand *, const size_t) + * } + */ + public static MemorySegment MagickSetCompressionQuality$address() { + return MagickSetCompressionQuality.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetCompressionQuality(MagickWand *, const size_t) + * } + */ + public static int MagickSetCompressionQuality(MemorySegment x0, long x1) { + var mh$ = MagickSetCompressionQuality.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetCompressionQuality", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetDepth { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetDepth"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetDepth(MagickWand *, const size_t) + * } + */ + public static FunctionDescriptor MagickSetDepth$descriptor() { + return MagickSetDepth.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetDepth(MagickWand *, const size_t) + * } + */ + public static MethodHandle MagickSetDepth$handle() { + return MagickSetDepth.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetDepth(MagickWand *, const size_t) + * } + */ + public static MemorySegment MagickSetDepth$address() { + return MagickSetDepth.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetDepth(MagickWand *, const size_t) + * } + */ + public static int MagickSetDepth(MemorySegment x0, long x1) { + var mh$ = MagickSetDepth.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetDepth", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetExtract { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetExtract"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetExtract(MagickWand *, const char *) + * } + */ + public static FunctionDescriptor MagickSetExtract$descriptor() { + return MagickSetExtract.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetExtract(MagickWand *, const char *) + * } + */ + public static MethodHandle MagickSetExtract$handle() { + return MagickSetExtract.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetExtract(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickSetExtract$address() { + return MagickSetExtract.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetExtract(MagickWand *, const char *) + * } + */ + public static int MagickSetExtract(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetExtract.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetExtract", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetFilename { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetFilename"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFilename(MagickWand *, const char *) + * } + */ + public static FunctionDescriptor MagickSetFilename$descriptor() { + return MagickSetFilename.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFilename(MagickWand *, const char *) + * } + */ + public static MethodHandle MagickSetFilename$handle() { + return MagickSetFilename.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFilename(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickSetFilename$address() { + return MagickSetFilename.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFilename(MagickWand *, const char *) + * } + */ + public static int MagickSetFilename(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetFilename.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetFilename", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetFilter { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetFilter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFilter(MagickWand *, const FilterType) + * } + */ + public static FunctionDescriptor MagickSetFilter$descriptor() { + return MagickSetFilter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFilter(MagickWand *, const FilterType) + * } + */ + public static MethodHandle MagickSetFilter$handle() { + return MagickSetFilter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFilter(MagickWand *, const FilterType) + * } + */ + public static MemorySegment MagickSetFilter$address() { + return MagickSetFilter.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFilter(MagickWand *, const FilterType) + * } + */ + public static int MagickSetFilter(MemorySegment x0, int x1) { + var mh$ = MagickSetFilter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetFilter", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetFormat { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetFormat"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFormat(MagickWand *, const char *) + * } + */ + public static FunctionDescriptor MagickSetFormat$descriptor() { + return MagickSetFormat.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFormat(MagickWand *, const char *) + * } + */ + public static MethodHandle MagickSetFormat$handle() { + return MagickSetFormat.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFormat(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickSetFormat$address() { + return MagickSetFormat.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFormat(MagickWand *, const char *) + * } + */ + public static int MagickSetFormat(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetFormat.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetFormat", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetFont { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetFont"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFont(MagickWand *, const char *) + * } + */ + public static FunctionDescriptor MagickSetFont$descriptor() { + return MagickSetFont.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFont(MagickWand *, const char *) + * } + */ + public static MethodHandle MagickSetFont$handle() { + return MagickSetFont.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFont(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickSetFont$address() { + return MagickSetFont.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetFont(MagickWand *, const char *) + * } + */ + public static int MagickSetFont(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetFont.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetFont", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetGravity { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetGravity"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetGravity(MagickWand *, const GravityType) + * } + */ + public static FunctionDescriptor MagickSetGravity$descriptor() { + return MagickSetGravity.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetGravity(MagickWand *, const GravityType) + * } + */ + public static MethodHandle MagickSetGravity$handle() { + return MagickSetGravity.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetGravity(MagickWand *, const GravityType) + * } + */ + public static MemorySegment MagickSetGravity$address() { + return MagickSetGravity.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetGravity(MagickWand *, const GravityType) + * } + */ + public static int MagickSetGravity(MemorySegment x0, int x1) { + var mh$ = MagickSetGravity.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetGravity", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetImageArtifact { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageArtifact"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageArtifact(MagickWand *, const char *, const char *) + * } + */ + public static FunctionDescriptor MagickSetImageArtifact$descriptor() { + return MagickSetImageArtifact.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageArtifact(MagickWand *, const char *, const char *) + * } + */ + public static MethodHandle MagickSetImageArtifact$handle() { + return MagickSetImageArtifact.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageArtifact(MagickWand *, const char *, const char *) + * } + */ + public static MemorySegment MagickSetImageArtifact$address() { + return MagickSetImageArtifact.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageArtifact(MagickWand *, const char *, const char *) + * } + */ + public static int MagickSetImageArtifact(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickSetImageArtifact.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetImageArtifact", x0, x1, x2); + } + return (int)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetImageProfile { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageProfile"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageProfile(MagickWand *, const char *, const void *, const size_t) + * } + */ + public static FunctionDescriptor MagickSetImageProfile$descriptor() { + return MagickSetImageProfile.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageProfile(MagickWand *, const char *, const void *, const size_t) + * } + */ + public static MethodHandle MagickSetImageProfile$handle() { + return MagickSetImageProfile.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageProfile(MagickWand *, const char *, const void *, const size_t) + * } + */ + public static MemorySegment MagickSetImageProfile$address() { + return MagickSetImageProfile.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageProfile(MagickWand *, const char *, const void *, const size_t) + * } + */ + public static int MagickSetImageProfile(MemorySegment x0, MemorySegment x1, MemorySegment x2, long x3) { + var mh$ = MagickSetImageProfile.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetImageProfile", x0, x1, x2, x3); + } + return (int)mh$.invokeExact(x0, x1, x2, x3); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetImageProperty { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageProperty"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageProperty(MagickWand *, const char *, const char *) + * } + */ + public static FunctionDescriptor MagickSetImageProperty$descriptor() { + return MagickSetImageProperty.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageProperty(MagickWand *, const char *, const char *) + * } + */ + public static MethodHandle MagickSetImageProperty$handle() { + return MagickSetImageProperty.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageProperty(MagickWand *, const char *, const char *) + * } + */ + public static MemorySegment MagickSetImageProperty$address() { + return MagickSetImageProperty.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetImageProperty(MagickWand *, const char *, const char *) + * } + */ + public static int MagickSetImageProperty(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickSetImageProperty.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetImageProperty", x0, x1, x2); + } + return (int)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetInterlaceScheme { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetInterlaceScheme"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetInterlaceScheme(MagickWand *, const InterlaceType) + * } + */ + public static FunctionDescriptor MagickSetInterlaceScheme$descriptor() { + return MagickSetInterlaceScheme.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetInterlaceScheme(MagickWand *, const InterlaceType) + * } + */ + public static MethodHandle MagickSetInterlaceScheme$handle() { + return MagickSetInterlaceScheme.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetInterlaceScheme(MagickWand *, const InterlaceType) + * } + */ + public static MemorySegment MagickSetInterlaceScheme$address() { + return MagickSetInterlaceScheme.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetInterlaceScheme(MagickWand *, const InterlaceType) + * } + */ + public static int MagickSetInterlaceScheme(MemorySegment x0, int x1) { + var mh$ = MagickSetInterlaceScheme.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetInterlaceScheme", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetInterpolateMethod { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetInterpolateMethod"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetInterpolateMethod(MagickWand *, const PixelInterpolateMethod) + * } + */ + public static FunctionDescriptor MagickSetInterpolateMethod$descriptor() { + return MagickSetInterpolateMethod.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetInterpolateMethod(MagickWand *, const PixelInterpolateMethod) + * } + */ + public static MethodHandle MagickSetInterpolateMethod$handle() { + return MagickSetInterpolateMethod.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetInterpolateMethod(MagickWand *, const PixelInterpolateMethod) + * } + */ + public static MemorySegment MagickSetInterpolateMethod$address() { + return MagickSetInterpolateMethod.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetInterpolateMethod(MagickWand *, const PixelInterpolateMethod) + * } + */ + public static int MagickSetInterpolateMethod(MemorySegment x0, int x1) { + var mh$ = MagickSetInterpolateMethod.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetInterpolateMethod", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetOption { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetOption"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetOption(MagickWand *, const char *, const char *) + * } + */ + public static FunctionDescriptor MagickSetOption$descriptor() { + return MagickSetOption.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetOption(MagickWand *, const char *, const char *) + * } + */ + public static MethodHandle MagickSetOption$handle() { + return MagickSetOption.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetOption(MagickWand *, const char *, const char *) + * } + */ + public static MemorySegment MagickSetOption$address() { + return MagickSetOption.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetOption(MagickWand *, const char *, const char *) + * } + */ + public static int MagickSetOption(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickSetOption.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetOption", x0, x1, x2); + } + return (int)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetOrientation { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetOrientation"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetOrientation(MagickWand *, const OrientationType) + * } + */ + public static FunctionDescriptor MagickSetOrientation$descriptor() { + return MagickSetOrientation.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetOrientation(MagickWand *, const OrientationType) + * } + */ + public static MethodHandle MagickSetOrientation$handle() { + return MagickSetOrientation.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetOrientation(MagickWand *, const OrientationType) + * } + */ + public static MemorySegment MagickSetOrientation$address() { + return MagickSetOrientation.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetOrientation(MagickWand *, const OrientationType) + * } + */ + public static int MagickSetOrientation(MemorySegment x0, int x1) { + var mh$ = MagickSetOrientation.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetOrientation", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetPage { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetPage"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetPage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * } + */ + public static FunctionDescriptor MagickSetPage$descriptor() { + return MagickSetPage.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetPage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * } + */ + public static MethodHandle MagickSetPage$handle() { + return MagickSetPage.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetPage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * } + */ + public static MemorySegment MagickSetPage$address() { + return MagickSetPage.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetPage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * } + */ + public static int MagickSetPage(MemorySegment x0, long x1, long x2, long x3, long x4) { + var mh$ = MagickSetPage.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetPage", x0, x1, x2, x3, x4); + } + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetPassphrase { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetPassphrase"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetPassphrase(MagickWand *, const char *) + * } + */ + public static FunctionDescriptor MagickSetPassphrase$descriptor() { + return MagickSetPassphrase.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetPassphrase(MagickWand *, const char *) + * } + */ + public static MethodHandle MagickSetPassphrase$handle() { + return MagickSetPassphrase.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetPassphrase(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickSetPassphrase$address() { + return MagickSetPassphrase.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetPassphrase(MagickWand *, const char *) + * } + */ + public static int MagickSetPassphrase(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetPassphrase.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetPassphrase", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetPointsize { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetPointsize"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetPointsize(MagickWand *, const double) + * } + */ + public static FunctionDescriptor MagickSetPointsize$descriptor() { + return MagickSetPointsize.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetPointsize(MagickWand *, const double) + * } + */ + public static MethodHandle MagickSetPointsize$handle() { + return MagickSetPointsize.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetPointsize(MagickWand *, const double) + * } + */ + public static MemorySegment MagickSetPointsize$address() { + return MagickSetPointsize.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetPointsize(MagickWand *, const double) + * } + */ + public static int MagickSetPointsize(MemorySegment x0, double x1) { + var mh$ = MagickSetPointsize.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetPointsize", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetResolution { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetResolution"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetResolution(MagickWand *, const double, const double) + * } + */ + public static FunctionDescriptor MagickSetResolution$descriptor() { + return MagickSetResolution.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetResolution(MagickWand *, const double, const double) + * } + */ + public static MethodHandle MagickSetResolution$handle() { + return MagickSetResolution.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetResolution(MagickWand *, const double, const double) + * } + */ + public static MemorySegment MagickSetResolution$address() { + return MagickSetResolution.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetResolution(MagickWand *, const double, const double) + * } + */ + public static int MagickSetResolution(MemorySegment x0, double x1, double x2) { + var mh$ = MagickSetResolution.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetResolution", x0, x1, x2); + } + return (int)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetResourceLimit { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_INT, + MagickWand_h.C_LONG_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetResourceLimit"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetResourceLimit(const ResourceType type, const MagickSizeType limit) + * } + */ + public static FunctionDescriptor MagickSetResourceLimit$descriptor() { + return MagickSetResourceLimit.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetResourceLimit(const ResourceType type, const MagickSizeType limit) + * } + */ + public static MethodHandle MagickSetResourceLimit$handle() { + return MagickSetResourceLimit.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetResourceLimit(const ResourceType type, const MagickSizeType limit) + * } + */ + public static MemorySegment MagickSetResourceLimit$address() { + return MagickSetResourceLimit.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetResourceLimit(const ResourceType type, const MagickSizeType limit) + * } + */ + public static int MagickSetResourceLimit(int type, long limit) { + var mh$ = MagickSetResourceLimit.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetResourceLimit", type, limit); + } + return (int)mh$.invokeExact(type, limit); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetSamplingFactors { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetSamplingFactors"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSamplingFactors(MagickWand *, const size_t, const double *) + * } + */ + public static FunctionDescriptor MagickSetSamplingFactors$descriptor() { + return MagickSetSamplingFactors.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSamplingFactors(MagickWand *, const size_t, const double *) + * } + */ + public static MethodHandle MagickSetSamplingFactors$handle() { + return MagickSetSamplingFactors.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSamplingFactors(MagickWand *, const size_t, const double *) + * } + */ + public static MemorySegment MagickSetSamplingFactors$address() { + return MagickSetSamplingFactors.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSamplingFactors(MagickWand *, const size_t, const double *) + * } + */ + public static int MagickSetSamplingFactors(MemorySegment x0, long x1, MemorySegment x2) { + var mh$ = MagickSetSamplingFactors.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetSamplingFactors", x0, x1, x2); + } + return (int)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetSecurityPolicy { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetSecurityPolicy"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSecurityPolicy(MagickWand *, const char *) + * } + */ + public static FunctionDescriptor MagickSetSecurityPolicy$descriptor() { + return MagickSetSecurityPolicy.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSecurityPolicy(MagickWand *, const char *) + * } + */ + public static MethodHandle MagickSetSecurityPolicy$handle() { + return MagickSetSecurityPolicy.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSecurityPolicy(MagickWand *, const char *) + * } + */ + public static MemorySegment MagickSetSecurityPolicy$address() { + return MagickSetSecurityPolicy.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSecurityPolicy(MagickWand *, const char *) + * } + */ + public static int MagickSetSecurityPolicy(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetSecurityPolicy.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetSecurityPolicy", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetSize { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetSize"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSize(MagickWand *, const size_t, const size_t) + * } + */ + public static FunctionDescriptor MagickSetSize$descriptor() { + return MagickSetSize.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSize(MagickWand *, const size_t, const size_t) + * } + */ + public static MethodHandle MagickSetSize$handle() { + return MagickSetSize.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSize(MagickWand *, const size_t, const size_t) + * } + */ + public static MemorySegment MagickSetSize$address() { + return MagickSetSize.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSize(MagickWand *, const size_t, const size_t) + * } + */ + public static int MagickSetSize(MemorySegment x0, long x1, long x2) { + var mh$ = MagickSetSize.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetSize", x0, x1, x2); + } + return (int)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetSizeOffset { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetSizeOffset"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSizeOffset(MagickWand *, const size_t, const size_t, const ssize_t) + * } + */ + public static FunctionDescriptor MagickSetSizeOffset$descriptor() { + return MagickSetSizeOffset.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSizeOffset(MagickWand *, const size_t, const size_t, const ssize_t) + * } + */ + public static MethodHandle MagickSetSizeOffset$handle() { + return MagickSetSizeOffset.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSizeOffset(MagickWand *, const size_t, const size_t, const ssize_t) + * } + */ + public static MemorySegment MagickSetSizeOffset$address() { + return MagickSetSizeOffset.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetSizeOffset(MagickWand *, const size_t, const size_t, const ssize_t) + * } + */ + public static int MagickSetSizeOffset(MemorySegment x0, long x1, long x2, long x3) { + var mh$ = MagickSetSizeOffset.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetSizeOffset", x0, x1, x2, x3); + } + return (int)mh$.invokeExact(x0, x1, x2, x3); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetType { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetType"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetType(MagickWand *, const ImageType) + * } + */ + public static FunctionDescriptor MagickSetType$descriptor() { + return MagickSetType.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetType(MagickWand *, const ImageType) + * } + */ + public static MethodHandle MagickSetType$handle() { + return MagickSetType.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType MagickSetType(MagickWand *, const ImageType) + * } + */ + public static MemorySegment MagickSetType$address() { + return MagickSetType.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType MagickSetType(MagickWand *, const ImageType) + * } + */ + public static int MagickSetType(MemorySegment x0, int x1) { + var mh$ = MagickSetType.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetType", x0, x1); + } + return (int)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetProgressMonitor { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetProgressMonitor"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickProgressMonitor MagickSetProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) + * } + */ + public static FunctionDescriptor MagickSetProgressMonitor$descriptor() { + return MagickSetProgressMonitor.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickProgressMonitor MagickSetProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) + * } + */ + public static MethodHandle MagickSetProgressMonitor$handle() { + return MagickSetProgressMonitor.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickProgressMonitor MagickSetProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) + * } + */ + public static MemorySegment MagickSetProgressMonitor$address() { + return MagickSetProgressMonitor.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickProgressMonitor MagickSetProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) + * } + */ + public static MemorySegment MagickSetProgressMonitor(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickSetProgressMonitor.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetProgressMonitor", x0, x1, x2); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetResource { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_LONG_LONG, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetResource"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickSizeType MagickGetResource(const ResourceType) + * } + */ + public static FunctionDescriptor MagickGetResource$descriptor() { + return MagickGetResource.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickSizeType MagickGetResource(const ResourceType) + * } + */ + public static MethodHandle MagickGetResource$handle() { + return MagickGetResource.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickSizeType MagickGetResource(const ResourceType) + * } + */ + public static MemorySegment MagickGetResource$address() { + return MagickGetResource.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickSizeType MagickGetResource(const ResourceType) + * } + */ + public static long MagickGetResource(int x0) { + var mh$ = MagickGetResource.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetResource", x0); + } + return (long)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetResourceLimit { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_LONG_LONG, + MagickWand_h.C_INT + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetResourceLimit"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickSizeType MagickGetResourceLimit(const ResourceType) + * } + */ + public static FunctionDescriptor MagickGetResourceLimit$descriptor() { + return MagickGetResourceLimit.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickSizeType MagickGetResourceLimit(const ResourceType) + * } + */ + public static MethodHandle MagickGetResourceLimit$handle() { + return MagickGetResourceLimit.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickSizeType MagickGetResourceLimit(const ResourceType) + * } + */ + public static MemorySegment MagickGetResourceLimit$address() { + return MagickGetResourceLimit.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickSizeType MagickGetResourceLimit(const ResourceType) + * } + */ + public static long MagickGetResourceLimit(int x0) { + var mh$ = MagickGetResourceLimit.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetResourceLimit", x0); + } + return (long)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetBackgroundColor { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetBackgroundColor"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern PixelWand *MagickGetBackgroundColor(MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetBackgroundColor$descriptor() { + return MagickGetBackgroundColor.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern PixelWand *MagickGetBackgroundColor(MagickWand *) + * } + */ + public static MethodHandle MagickGetBackgroundColor$handle() { + return MagickGetBackgroundColor.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern PixelWand *MagickGetBackgroundColor(MagickWand *) + * } + */ + public static MemorySegment MagickGetBackgroundColor$address() { + return MagickGetBackgroundColor.ADDR; + } + + /** + * {@snippet lang=c : + * extern PixelWand *MagickGetBackgroundColor(MagickWand *) + * } + */ + public static MemorySegment MagickGetBackgroundColor(MemorySegment x0) { + var mh$ = MagickGetBackgroundColor.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickGetBackgroundColor", x0); + } + return (MemorySegment)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetOrientationType { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetOrientationType"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern OrientationType MagickGetOrientationType(MagickWand *) + * } + */ + public static FunctionDescriptor MagickGetOrientationType$descriptor() { + return MagickGetOrientationType.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern ImageType MagickGetType(MagickWand *) + * extern OrientationType MagickGetOrientationType(MagickWand *) * } */ - public static MethodHandle MagickGetType$handle() { - return MagickGetType.HANDLE; + public static MethodHandle MagickGetOrientationType$handle() { + return MagickGetOrientationType.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern ImageType MagickGetType(MagickWand *) + * extern OrientationType MagickGetOrientationType(MagickWand *) * } */ - public static MemorySegment MagickGetType$address() { - return MagickGetType.ADDR; + public static MemorySegment MagickGetOrientationType$address() { + return MagickGetOrientationType.ADDR; } /** * {@snippet lang=c : - * extern ImageType MagickGetType(MagickWand *) + * extern OrientationType MagickGetOrientationType(MagickWand *) * } */ - public static int MagickGetType(MemorySegment x0) { - var mh$ = MagickGetType.HANDLE; + public static int MagickGetOrientationType(MemorySegment x0) { + var mh$ = MagickGetOrientationType.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetType", x0); + traceDowncall("MagickGetOrientationType", x0); } return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { @@ -1830,13 +16213,13 @@ public static int MagickGetType(MemorySegment x0) { } } - private static class MagickGetInterlaceScheme { + private static class MagickGetCompressionQuality { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_LONG, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetInterlaceScheme"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetCompressionQuality"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1844,57 +16227,59 @@ private static class MagickGetInterlaceScheme { /** * Function descriptor for: * {@snippet lang=c : - * extern InterlaceType MagickGetInterlaceScheme(MagickWand *) + * extern size_t MagickGetCompressionQuality(MagickWand *) * } */ - public static FunctionDescriptor MagickGetInterlaceScheme$descriptor() { - return MagickGetInterlaceScheme.DESC; + public static FunctionDescriptor MagickGetCompressionQuality$descriptor() { + return MagickGetCompressionQuality.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern InterlaceType MagickGetInterlaceScheme(MagickWand *) + * extern size_t MagickGetCompressionQuality(MagickWand *) * } */ - public static MethodHandle MagickGetInterlaceScheme$handle() { - return MagickGetInterlaceScheme.HANDLE; + public static MethodHandle MagickGetCompressionQuality$handle() { + return MagickGetCompressionQuality.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern InterlaceType MagickGetInterlaceScheme(MagickWand *) + * extern size_t MagickGetCompressionQuality(MagickWand *) * } */ - public static MemorySegment MagickGetInterlaceScheme$address() { - return MagickGetInterlaceScheme.ADDR; + public static MemorySegment MagickGetCompressionQuality$address() { + return MagickGetCompressionQuality.ADDR; } /** * {@snippet lang=c : - * extern InterlaceType MagickGetInterlaceScheme(MagickWand *) + * extern size_t MagickGetCompressionQuality(MagickWand *) * } */ - public static int MagickGetInterlaceScheme(MemorySegment x0) { - var mh$ = MagickGetInterlaceScheme.HANDLE; + public static long MagickGetCompressionQuality(MemorySegment x0) { + var mh$ = MagickGetCompressionQuality.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetInterlaceScheme", x0); + traceDowncall("MagickGetCompressionQuality", x0); } - return (int)mh$.invokeExact(x0); + return (long)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetInterpolateMethod { + private static class MagickGetImageProfile { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetInterpolateMethod"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageProfile"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1902,57 +16287,59 @@ private static class MagickGetInterpolateMethod { /** * Function descriptor for: * {@snippet lang=c : - * extern PixelInterpolateMethod MagickGetInterpolateMethod(MagickWand *) + * extern unsigned char *MagickGetImageProfile(MagickWand *, const char *, size_t *) * } */ - public static FunctionDescriptor MagickGetInterpolateMethod$descriptor() { - return MagickGetInterpolateMethod.DESC; + public static FunctionDescriptor MagickGetImageProfile$descriptor() { + return MagickGetImageProfile.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern PixelInterpolateMethod MagickGetInterpolateMethod(MagickWand *) + * extern unsigned char *MagickGetImageProfile(MagickWand *, const char *, size_t *) * } */ - public static MethodHandle MagickGetInterpolateMethod$handle() { - return MagickGetInterpolateMethod.HANDLE; + public static MethodHandle MagickGetImageProfile$handle() { + return MagickGetImageProfile.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern PixelInterpolateMethod MagickGetInterpolateMethod(MagickWand *) + * extern unsigned char *MagickGetImageProfile(MagickWand *, const char *, size_t *) * } */ - public static MemorySegment MagickGetInterpolateMethod$address() { - return MagickGetInterpolateMethod.ADDR; + public static MemorySegment MagickGetImageProfile$address() { + return MagickGetImageProfile.ADDR; } /** * {@snippet lang=c : - * extern PixelInterpolateMethod MagickGetInterpolateMethod(MagickWand *) + * extern unsigned char *MagickGetImageProfile(MagickWand *, const char *, size_t *) * } */ - public static int MagickGetInterpolateMethod(MemorySegment x0) { - var mh$ = MagickGetInterpolateMethod.HANDLE; + public static MemorySegment MagickGetImageProfile(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickGetImageProfile.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetInterpolateMethod", x0); + traceDowncall("MagickGetImageProfile", x0, x1, x2); } - return (int)mh$.invokeExact(x0); + return (MemorySegment)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetOrientation { + private static class MagickRemoveImageProfile { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetOrientation"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRemoveImageProfile"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -1960,58 +16347,174 @@ private static class MagickGetOrientation { /** * Function descriptor for: * {@snippet lang=c : - * extern OrientationType MagickGetOrientation(MagickWand *) + * extern unsigned char *MagickRemoveImageProfile(MagickWand *, const char *, size_t *) * } */ - public static FunctionDescriptor MagickGetOrientation$descriptor() { - return MagickGetOrientation.DESC; + public static FunctionDescriptor MagickRemoveImageProfile$descriptor() { + return MagickRemoveImageProfile.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern OrientationType MagickGetOrientation(MagickWand *) + * extern unsigned char *MagickRemoveImageProfile(MagickWand *, const char *, size_t *) * } */ - public static MethodHandle MagickGetOrientation$handle() { - return MagickGetOrientation.HANDLE; + public static MethodHandle MagickRemoveImageProfile$handle() { + return MagickRemoveImageProfile.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern unsigned char *MagickRemoveImageProfile(MagickWand *, const char *, size_t *) + * } + */ + public static MemorySegment MagickRemoveImageProfile$address() { + return MagickRemoveImageProfile.ADDR; + } + + /** + * {@snippet lang=c : + * extern unsigned char *MagickRemoveImageProfile(MagickWand *, const char *, size_t *) + * } + */ + public static MemorySegment MagickRemoveImageProfile(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickRemoveImageProfile.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickRemoveImageProfile", x0, x1, x2); + } + return (MemorySegment)mh$.invokeExact(x0, x1, x2); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickSetSeed { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetSeed"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern void MagickSetSeed(const unsigned long) + * } + */ + public static FunctionDescriptor MagickSetSeed$descriptor() { + return MagickSetSeed.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern void MagickSetSeed(const unsigned long) + * } + */ + public static MethodHandle MagickSetSeed$handle() { + return MagickSetSeed.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern void MagickSetSeed(const unsigned long) + * } + */ + public static MemorySegment MagickSetSeed$address() { + return MagickSetSeed.ADDR; + } + + /** + * {@snippet lang=c : + * extern void MagickSetSeed(const unsigned long) + * } + */ + public static void MagickSetSeed(long x0) { + var mh$ = MagickSetSeed.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("MagickSetSeed", x0); + } + mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class MagickGetImageFeatures { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG + ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageFeatures"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern ChannelFeatures *MagickGetImageFeatures(MagickWand *, const size_t) + * } + */ + public static FunctionDescriptor MagickGetImageFeatures$descriptor() { + return MagickGetImageFeatures.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern ChannelFeatures *MagickGetImageFeatures(MagickWand *, const size_t) + * } + */ + public static MethodHandle MagickGetImageFeatures$handle() { + return MagickGetImageFeatures.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern OrientationType MagickGetOrientation(MagickWand *) + * extern ChannelFeatures *MagickGetImageFeatures(MagickWand *, const size_t) * } */ - public static MemorySegment MagickGetOrientation$address() { - return MagickGetOrientation.ADDR; + public static MemorySegment MagickGetImageFeatures$address() { + return MagickGetImageFeatures.ADDR; } /** * {@snippet lang=c : - * extern OrientationType MagickGetOrientation(MagickWand *) + * extern ChannelFeatures *MagickGetImageFeatures(MagickWand *, const size_t) * } */ - public static int MagickGetOrientation(MemorySegment x0) { - var mh$ = MagickGetOrientation.HANDLE; + public static MemorySegment MagickGetImageFeatures(MemorySegment x0, long x1) { + var mh$ = MagickGetImageFeatures.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetOrientation", x0); + traceDowncall("MagickGetImageFeatures", x0, x1); } - return (int)mh$.invokeExact(x0); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickDeleteImageArtifact { + private static class MagickSetImageChannelMask { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDeleteImageArtifact"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageChannelMask"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2019,43 +16522,43 @@ private static class MagickDeleteImageArtifact { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickDeleteImageArtifact(MagickWand *, const char *) + * extern ChannelType MagickSetImageChannelMask(MagickWand *, const ChannelType) * } */ - public static FunctionDescriptor MagickDeleteImageArtifact$descriptor() { - return MagickDeleteImageArtifact.DESC; + public static FunctionDescriptor MagickSetImageChannelMask$descriptor() { + return MagickSetImageChannelMask.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickDeleteImageArtifact(MagickWand *, const char *) + * extern ChannelType MagickSetImageChannelMask(MagickWand *, const ChannelType) * } */ - public static MethodHandle MagickDeleteImageArtifact$handle() { - return MagickDeleteImageArtifact.HANDLE; + public static MethodHandle MagickSetImageChannelMask$handle() { + return MagickSetImageChannelMask.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickDeleteImageArtifact(MagickWand *, const char *) + * extern ChannelType MagickSetImageChannelMask(MagickWand *, const ChannelType) * } */ - public static MemorySegment MagickDeleteImageArtifact$address() { - return MagickDeleteImageArtifact.ADDR; + public static MemorySegment MagickSetImageChannelMask$address() { + return MagickSetImageChannelMask.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickDeleteImageArtifact(MagickWand *, const char *) + * extern ChannelType MagickSetImageChannelMask(MagickWand *, const ChannelType) * } */ - public static int MagickDeleteImageArtifact(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickDeleteImageArtifact.HANDLE; + public static int MagickSetImageChannelMask(MemorySegment x0, int x1) { + var mh$ = MagickSetImageChannelMask.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickDeleteImageArtifact", x0, x1); + traceDowncall("MagickSetImageChannelMask", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -2063,14 +16566,13 @@ public static int MagickDeleteImageArtifact(MemorySegment x0, MemorySegment x1) } } - private static class MagickDeleteImageProperty { + private static class MagickGetImageStatistics { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDeleteImageProperty"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageStatistics"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2078,58 +16580,57 @@ private static class MagickDeleteImageProperty { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickDeleteImageProperty(MagickWand *, const char *) + * extern ChannelStatistics *MagickGetImageStatistics(MagickWand *) * } */ - public static FunctionDescriptor MagickDeleteImageProperty$descriptor() { - return MagickDeleteImageProperty.DESC; + public static FunctionDescriptor MagickGetImageStatistics$descriptor() { + return MagickGetImageStatistics.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickDeleteImageProperty(MagickWand *, const char *) + * extern ChannelStatistics *MagickGetImageStatistics(MagickWand *) * } */ - public static MethodHandle MagickDeleteImageProperty$handle() { - return MagickDeleteImageProperty.HANDLE; + public static MethodHandle MagickGetImageStatistics$handle() { + return MagickGetImageStatistics.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickDeleteImageProperty(MagickWand *, const char *) + * extern ChannelStatistics *MagickGetImageStatistics(MagickWand *) * } */ - public static MemorySegment MagickDeleteImageProperty$address() { - return MagickDeleteImageProperty.ADDR; + public static MemorySegment MagickGetImageStatistics$address() { + return MagickGetImageStatistics.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickDeleteImageProperty(MagickWand *, const char *) + * extern ChannelStatistics *MagickGetImageStatistics(MagickWand *) * } */ - public static int MagickDeleteImageProperty(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickDeleteImageProperty.HANDLE; + public static MemorySegment MagickGetImageStatistics(MemorySegment x0) { + var mh$ = MagickGetImageStatistics.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickDeleteImageProperty", x0, x1); + traceDowncall("MagickGetImageStatistics", x0); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickDeleteOption { + private static class MagickGetImageFilename { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDeleteOption"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageFilename"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2137,57 +16638,57 @@ private static class MagickDeleteOption { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickDeleteOption(MagickWand *, const char *) + * extern char *MagickGetImageFilename(MagickWand *) * } */ - public static FunctionDescriptor MagickDeleteOption$descriptor() { - return MagickDeleteOption.DESC; + public static FunctionDescriptor MagickGetImageFilename$descriptor() { + return MagickGetImageFilename.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickDeleteOption(MagickWand *, const char *) + * extern char *MagickGetImageFilename(MagickWand *) * } */ - public static MethodHandle MagickDeleteOption$handle() { - return MagickDeleteOption.HANDLE; + public static MethodHandle MagickGetImageFilename$handle() { + return MagickGetImageFilename.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickDeleteOption(MagickWand *, const char *) + * extern char *MagickGetImageFilename(MagickWand *) * } */ - public static MemorySegment MagickDeleteOption$address() { - return MagickDeleteOption.ADDR; + public static MemorySegment MagickGetImageFilename$address() { + return MagickGetImageFilename.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickDeleteOption(MagickWand *, const char *) + * extern char *MagickGetImageFilename(MagickWand *) * } */ - public static int MagickDeleteOption(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickDeleteOption.HANDLE; + public static MemorySegment MagickGetImageFilename(MemorySegment x0) { + var mh$ = MagickGetImageFilename.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickDeleteOption", x0, x1); + traceDowncall("MagickGetImageFilename", x0); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetAntialias { + private static class MagickGetImageFormat { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetAntialias"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageFormat"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2195,61 +16696,57 @@ private static class MagickGetAntialias { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetAntialias(const MagickWand *) + * extern char *MagickGetImageFormat(MagickWand *) * } */ - public static FunctionDescriptor MagickGetAntialias$descriptor() { - return MagickGetAntialias.DESC; + public static FunctionDescriptor MagickGetImageFormat$descriptor() { + return MagickGetImageFormat.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetAntialias(const MagickWand *) + * extern char *MagickGetImageFormat(MagickWand *) * } */ - public static MethodHandle MagickGetAntialias$handle() { - return MagickGetAntialias.HANDLE; + public static MethodHandle MagickGetImageFormat$handle() { + return MagickGetImageFormat.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetAntialias(const MagickWand *) + * extern char *MagickGetImageFormat(MagickWand *) * } */ - public static MemorySegment MagickGetAntialias$address() { - return MagickGetAntialias.ADDR; + public static MemorySegment MagickGetImageFormat$address() { + return MagickGetImageFormat.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetAntialias(const MagickWand *) + * extern char *MagickGetImageFormat(MagickWand *) * } */ - public static int MagickGetAntialias(MemorySegment x0) { - var mh$ = MagickGetAntialias.HANDLE; + public static MemorySegment MagickGetImageFormat(MemorySegment x0) { + var mh$ = MagickGetImageFormat.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetAntialias", x0); + traceDowncall("MagickGetImageFormat", x0); } - return (int)mh$.invokeExact(x0); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetPage { + private static class MagickGetImageSignature { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetPage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageSignature"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2257,59 +16754,57 @@ private static class MagickGetPage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetPage(const MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) + * extern char *MagickGetImageSignature(MagickWand *) * } */ - public static FunctionDescriptor MagickGetPage$descriptor() { - return MagickGetPage.DESC; + public static FunctionDescriptor MagickGetImageSignature$descriptor() { + return MagickGetImageSignature.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetPage(const MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) + * extern char *MagickGetImageSignature(MagickWand *) * } */ - public static MethodHandle MagickGetPage$handle() { - return MagickGetPage.HANDLE; + public static MethodHandle MagickGetImageSignature$handle() { + return MagickGetImageSignature.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetPage(const MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) + * extern char *MagickGetImageSignature(MagickWand *) * } */ - public static MemorySegment MagickGetPage$address() { - return MagickGetPage.ADDR; + public static MemorySegment MagickGetImageSignature$address() { + return MagickGetImageSignature.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetPage(const MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) + * extern char *MagickGetImageSignature(MagickWand *) * } */ - public static int MagickGetPage(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { - var mh$ = MagickGetPage.HANDLE; + public static MemorySegment MagickGetImageSignature(MemorySegment x0) { + var mh$ = MagickGetImageSignature.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetPage", x0, x1, x2, x3, x4); + traceDowncall("MagickGetImageSignature", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetResolution { + private static class MagickIdentifyImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetResolution"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickIdentifyImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2317,59 +16812,57 @@ private static class MagickGetResolution { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetResolution(const MagickWand *, double *, double *) + * extern char *MagickIdentifyImage(MagickWand *) * } */ - public static FunctionDescriptor MagickGetResolution$descriptor() { - return MagickGetResolution.DESC; + public static FunctionDescriptor MagickIdentifyImage$descriptor() { + return MagickIdentifyImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetResolution(const MagickWand *, double *, double *) + * extern char *MagickIdentifyImage(MagickWand *) * } */ - public static MethodHandle MagickGetResolution$handle() { - return MagickGetResolution.HANDLE; + public static MethodHandle MagickIdentifyImage$handle() { + return MagickIdentifyImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetResolution(const MagickWand *, double *, double *) + * extern char *MagickIdentifyImage(MagickWand *) * } */ - public static MemorySegment MagickGetResolution$address() { - return MagickGetResolution.ADDR; + public static MemorySegment MagickIdentifyImage$address() { + return MagickIdentifyImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetResolution(const MagickWand *, double *, double *) + * extern char *MagickIdentifyImage(MagickWand *) * } */ - public static int MagickGetResolution(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickGetResolution.HANDLE; + public static MemorySegment MagickIdentifyImage(MemorySegment x0) { + var mh$ = MagickIdentifyImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetResolution", x0, x1, x2); + traceDowncall("MagickIdentifyImage", x0); } - return (int)mh$.invokeExact(x0, x1, x2); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetSize { + private static class MagickGetImageColorspace { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetSize"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageColorspace"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2377,58 +16870,57 @@ private static class MagickGetSize { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetSize(const MagickWand *, size_t *, size_t *) + * extern ColorspaceType MagickGetImageColorspace(MagickWand *) * } */ - public static FunctionDescriptor MagickGetSize$descriptor() { - return MagickGetSize.DESC; + public static FunctionDescriptor MagickGetImageColorspace$descriptor() { + return MagickGetImageColorspace.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetSize(const MagickWand *, size_t *, size_t *) + * extern ColorspaceType MagickGetImageColorspace(MagickWand *) * } */ - public static MethodHandle MagickGetSize$handle() { - return MagickGetSize.HANDLE; + public static MethodHandle MagickGetImageColorspace$handle() { + return MagickGetImageColorspace.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetSize(const MagickWand *, size_t *, size_t *) + * extern ColorspaceType MagickGetImageColorspace(MagickWand *) * } */ - public static MemorySegment MagickGetSize$address() { - return MagickGetSize.ADDR; + public static MemorySegment MagickGetImageColorspace$address() { + return MagickGetImageColorspace.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetSize(const MagickWand *, size_t *, size_t *) + * extern ColorspaceType MagickGetImageColorspace(MagickWand *) * } */ - public static int MagickGetSize(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickGetSize.HANDLE; + public static int MagickGetImageColorspace(MemorySegment x0) { + var mh$ = MagickGetImageColorspace.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetSize", x0, x1, x2); + traceDowncall("MagickGetImageColorspace", x0); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetSizeOffset { + private static class MagickGetImageCompose { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetSizeOffset"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageCompose"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2436,60 +16928,57 @@ private static class MagickGetSizeOffset { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetSizeOffset(const MagickWand *, ssize_t *) + * extern CompositeOperator MagickGetImageCompose(MagickWand *) * } */ - public static FunctionDescriptor MagickGetSizeOffset$descriptor() { - return MagickGetSizeOffset.DESC; + public static FunctionDescriptor MagickGetImageCompose$descriptor() { + return MagickGetImageCompose.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetSizeOffset(const MagickWand *, ssize_t *) + * extern CompositeOperator MagickGetImageCompose(MagickWand *) * } */ - public static MethodHandle MagickGetSizeOffset$handle() { - return MagickGetSizeOffset.HANDLE; + public static MethodHandle MagickGetImageCompose$handle() { + return MagickGetImageCompose.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetSizeOffset(const MagickWand *, ssize_t *) + * extern CompositeOperator MagickGetImageCompose(MagickWand *) * } */ - public static MemorySegment MagickGetSizeOffset$address() { - return MagickGetSizeOffset.ADDR; + public static MemorySegment MagickGetImageCompose$address() { + return MagickGetImageCompose.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetSizeOffset(const MagickWand *, ssize_t *) + * extern CompositeOperator MagickGetImageCompose(MagickWand *) * } */ - public static int MagickGetSizeOffset(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickGetSizeOffset.HANDLE; + public static int MagickGetImageCompose(MemorySegment x0) { + var mh$ = MagickGetImageCompose.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetSizeOffset", x0, x1); + traceDowncall("MagickGetImageCompose", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickProfileImage { + private static class MagickGetImageCompression { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickProfileImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageCompression"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2497,58 +16986,57 @@ private static class MagickProfileImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickProfileImage(MagickWand *, const char *, const void *, const size_t) + * extern CompressionType MagickGetImageCompression(MagickWand *) * } */ - public static FunctionDescriptor MagickProfileImage$descriptor() { - return MagickProfileImage.DESC; + public static FunctionDescriptor MagickGetImageCompression$descriptor() { + return MagickGetImageCompression.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickProfileImage(MagickWand *, const char *, const void *, const size_t) + * extern CompressionType MagickGetImageCompression(MagickWand *) * } */ - public static MethodHandle MagickProfileImage$handle() { - return MagickProfileImage.HANDLE; + public static MethodHandle MagickGetImageCompression$handle() { + return MagickGetImageCompression.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickProfileImage(MagickWand *, const char *, const void *, const size_t) + * extern CompressionType MagickGetImageCompression(MagickWand *) * } */ - public static MemorySegment MagickProfileImage$address() { - return MagickProfileImage.ADDR; + public static MemorySegment MagickGetImageCompression$address() { + return MagickGetImageCompression.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickProfileImage(MagickWand *, const char *, const void *, const size_t) + * extern CompressionType MagickGetImageCompression(MagickWand *) * } */ - public static int MagickProfileImage(MemorySegment x0, MemorySegment x1, MemorySegment x2, long x3) { - var mh$ = MagickProfileImage.HANDLE; + public static int MagickGetImageCompression(MemorySegment x0) { + var mh$ = MagickGetImageCompression.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickProfileImage", x0, x1, x2, x3); + traceDowncall("MagickGetImageCompression", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetAntialias { + private static class MagickGetImageDispose { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetAntialias"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageDispose"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2556,58 +17044,59 @@ private static class MagickSetAntialias { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetAntialias(MagickWand *, const MagickBooleanType) + * extern DisposeType MagickGetImageDispose(MagickWand *) * } */ - public static FunctionDescriptor MagickSetAntialias$descriptor() { - return MagickSetAntialias.DESC; + public static FunctionDescriptor MagickGetImageDispose$descriptor() { + return MagickGetImageDispose.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetAntialias(MagickWand *, const MagickBooleanType) + * extern DisposeType MagickGetImageDispose(MagickWand *) * } */ - public static MethodHandle MagickSetAntialias$handle() { - return MagickSetAntialias.HANDLE; + public static MethodHandle MagickGetImageDispose$handle() { + return MagickGetImageDispose.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetAntialias(MagickWand *, const MagickBooleanType) + * extern DisposeType MagickGetImageDispose(MagickWand *) * } */ - public static MemorySegment MagickSetAntialias$address() { - return MagickSetAntialias.ADDR; + public static MemorySegment MagickGetImageDispose$address() { + return MagickGetImageDispose.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetAntialias(MagickWand *, const MagickBooleanType) + * extern DisposeType MagickGetImageDispose(MagickWand *) * } */ - public static int MagickSetAntialias(MemorySegment x0, int x1) { - var mh$ = MagickSetAntialias.HANDLE; + public static int MagickGetImageDispose(MemorySegment x0) { + var mh$ = MagickGetImageDispose.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetAntialias", x0, x1); + traceDowncall("MagickGetImageDispose", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetBackgroundColor { + private static class MagickGetImageDistortions { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetBackgroundColor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageDistortions"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2615,58 +17104,57 @@ private static class MagickSetBackgroundColor { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetBackgroundColor(MagickWand *, const PixelWand *) + * extern double *MagickGetImageDistortions(MagickWand *, const MagickWand *, const MetricType) * } */ - public static FunctionDescriptor MagickSetBackgroundColor$descriptor() { - return MagickSetBackgroundColor.DESC; + public static FunctionDescriptor MagickGetImageDistortions$descriptor() { + return MagickGetImageDistortions.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetBackgroundColor(MagickWand *, const PixelWand *) + * extern double *MagickGetImageDistortions(MagickWand *, const MagickWand *, const MetricType) * } */ - public static MethodHandle MagickSetBackgroundColor$handle() { - return MagickSetBackgroundColor.HANDLE; + public static MethodHandle MagickGetImageDistortions$handle() { + return MagickGetImageDistortions.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetBackgroundColor(MagickWand *, const PixelWand *) + * extern double *MagickGetImageDistortions(MagickWand *, const MagickWand *, const MetricType) * } */ - public static MemorySegment MagickSetBackgroundColor$address() { - return MagickSetBackgroundColor.ADDR; + public static MemorySegment MagickGetImageDistortions$address() { + return MagickGetImageDistortions.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetBackgroundColor(MagickWand *, const PixelWand *) + * extern double *MagickGetImageDistortions(MagickWand *, const MagickWand *, const MetricType) * } */ - public static int MagickSetBackgroundColor(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickSetBackgroundColor.HANDLE; + public static MemorySegment MagickGetImageDistortions(MemorySegment x0, MemorySegment x1, int x2) { + var mh$ = MagickGetImageDistortions.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetBackgroundColor", x0, x1); + traceDowncall("MagickGetImageDistortions", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetColorspace { + private static class MagickGetImageFuzz { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_DOUBLE, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetColorspace"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageFuzz"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2674,58 +17162,57 @@ private static class MagickSetColorspace { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetColorspace(MagickWand *, const ColorspaceType) + * extern double MagickGetImageFuzz(MagickWand *) * } */ - public static FunctionDescriptor MagickSetColorspace$descriptor() { - return MagickSetColorspace.DESC; + public static FunctionDescriptor MagickGetImageFuzz$descriptor() { + return MagickGetImageFuzz.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetColorspace(MagickWand *, const ColorspaceType) + * extern double MagickGetImageFuzz(MagickWand *) * } */ - public static MethodHandle MagickSetColorspace$handle() { - return MagickSetColorspace.HANDLE; + public static MethodHandle MagickGetImageFuzz$handle() { + return MagickGetImageFuzz.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetColorspace(MagickWand *, const ColorspaceType) + * extern double MagickGetImageFuzz(MagickWand *) * } */ - public static MemorySegment MagickSetColorspace$address() { - return MagickSetColorspace.ADDR; + public static MemorySegment MagickGetImageFuzz$address() { + return MagickGetImageFuzz.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetColorspace(MagickWand *, const ColorspaceType) + * extern double MagickGetImageFuzz(MagickWand *) * } */ - public static int MagickSetColorspace(MemorySegment x0, int x1) { - var mh$ = MagickSetColorspace.HANDLE; + public static double MagickGetImageFuzz(MemorySegment x0) { + var mh$ = MagickGetImageFuzz.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetColorspace", x0, x1); + traceDowncall("MagickGetImageFuzz", x0); } - return (int)mh$.invokeExact(x0, x1); + return (double)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetCompression { + private static class MagickGetImageGamma { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_DOUBLE, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetCompression"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageGamma"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2733,58 +17220,57 @@ private static class MagickSetCompression { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetCompression(MagickWand *, const CompressionType) + * extern double MagickGetImageGamma(MagickWand *) * } */ - public static FunctionDescriptor MagickSetCompression$descriptor() { - return MagickSetCompression.DESC; + public static FunctionDescriptor MagickGetImageGamma$descriptor() { + return MagickGetImageGamma.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetCompression(MagickWand *, const CompressionType) + * extern double MagickGetImageGamma(MagickWand *) * } */ - public static MethodHandle MagickSetCompression$handle() { - return MagickSetCompression.HANDLE; + public static MethodHandle MagickGetImageGamma$handle() { + return MagickGetImageGamma.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetCompression(MagickWand *, const CompressionType) + * extern double MagickGetImageGamma(MagickWand *) * } */ - public static MemorySegment MagickSetCompression$address() { - return MagickSetCompression.ADDR; + public static MemorySegment MagickGetImageGamma$address() { + return MagickGetImageGamma.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetCompression(MagickWand *, const CompressionType) + * extern double MagickGetImageGamma(MagickWand *) * } */ - public static int MagickSetCompression(MemorySegment x0, int x1) { - var mh$ = MagickSetCompression.HANDLE; + public static double MagickGetImageGamma(MemorySegment x0) { + var mh$ = MagickGetImageGamma.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetCompression", x0, x1); + traceDowncall("MagickGetImageGamma", x0); } - return (int)mh$.invokeExact(x0, x1); + return (double)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetCompressionQuality { + private static class MagickGetImageTotalInkDensity { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_DOUBLE, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetCompressionQuality"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageTotalInkDensity"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2792,58 +17278,57 @@ private static class MagickSetCompressionQuality { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetCompressionQuality(MagickWand *, const size_t) + * extern double MagickGetImageTotalInkDensity(MagickWand *) * } */ - public static FunctionDescriptor MagickSetCompressionQuality$descriptor() { - return MagickSetCompressionQuality.DESC; + public static FunctionDescriptor MagickGetImageTotalInkDensity$descriptor() { + return MagickGetImageTotalInkDensity.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetCompressionQuality(MagickWand *, const size_t) + * extern double MagickGetImageTotalInkDensity(MagickWand *) * } */ - public static MethodHandle MagickSetCompressionQuality$handle() { - return MagickSetCompressionQuality.HANDLE; + public static MethodHandle MagickGetImageTotalInkDensity$handle() { + return MagickGetImageTotalInkDensity.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetCompressionQuality(MagickWand *, const size_t) + * extern double MagickGetImageTotalInkDensity(MagickWand *) * } */ - public static MemorySegment MagickSetCompressionQuality$address() { - return MagickSetCompressionQuality.ADDR; + public static MemorySegment MagickGetImageTotalInkDensity$address() { + return MagickGetImageTotalInkDensity.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetCompressionQuality(MagickWand *, const size_t) + * extern double MagickGetImageTotalInkDensity(MagickWand *) * } */ - public static int MagickSetCompressionQuality(MemorySegment x0, long x1) { - var mh$ = MagickSetCompressionQuality.HANDLE; + public static double MagickGetImageTotalInkDensity(MemorySegment x0) { + var mh$ = MagickGetImageTotalInkDensity.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetCompressionQuality", x0, x1); + traceDowncall("MagickGetImageTotalInkDensity", x0); } - return (int)mh$.invokeExact(x0, x1); + return (double)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetDepth { + private static class MagickGetImageEndian { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetDepth"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageEndian"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2851,58 +17336,57 @@ private static class MagickSetDepth { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetDepth(MagickWand *, const size_t) + * extern EndianType MagickGetImageEndian(MagickWand *) * } */ - public static FunctionDescriptor MagickSetDepth$descriptor() { - return MagickSetDepth.DESC; + public static FunctionDescriptor MagickGetImageEndian$descriptor() { + return MagickGetImageEndian.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetDepth(MagickWand *, const size_t) + * extern EndianType MagickGetImageEndian(MagickWand *) * } */ - public static MethodHandle MagickSetDepth$handle() { - return MagickSetDepth.HANDLE; + public static MethodHandle MagickGetImageEndian$handle() { + return MagickGetImageEndian.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetDepth(MagickWand *, const size_t) + * extern EndianType MagickGetImageEndian(MagickWand *) * } */ - public static MemorySegment MagickSetDepth$address() { - return MagickSetDepth.ADDR; + public static MemorySegment MagickGetImageEndian$address() { + return MagickGetImageEndian.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetDepth(MagickWand *, const size_t) + * extern EndianType MagickGetImageEndian(MagickWand *) * } */ - public static int MagickSetDepth(MemorySegment x0, long x1) { - var mh$ = MagickSetDepth.HANDLE; + public static int MagickGetImageEndian(MemorySegment x0) { + var mh$ = MagickGetImageEndian.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetDepth", x0, x1); + traceDowncall("MagickGetImageEndian", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetExtract { + private static class MagickGetImageFilter { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetExtract"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageFilter"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2910,58 +17394,57 @@ private static class MagickSetExtract { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetExtract(MagickWand *, const char *) + * extern FilterType MagickGetImageFilter(MagickWand *) * } */ - public static FunctionDescriptor MagickSetExtract$descriptor() { - return MagickSetExtract.DESC; + public static FunctionDescriptor MagickGetImageFilter$descriptor() { + return MagickGetImageFilter.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetExtract(MagickWand *, const char *) + * extern FilterType MagickGetImageFilter(MagickWand *) * } */ - public static MethodHandle MagickSetExtract$handle() { - return MagickSetExtract.HANDLE; + public static MethodHandle MagickGetImageFilter$handle() { + return MagickGetImageFilter.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetExtract(MagickWand *, const char *) + * extern FilterType MagickGetImageFilter(MagickWand *) * } */ - public static MemorySegment MagickSetExtract$address() { - return MagickSetExtract.ADDR; + public static MemorySegment MagickGetImageFilter$address() { + return MagickGetImageFilter.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetExtract(MagickWand *, const char *) + * extern FilterType MagickGetImageFilter(MagickWand *) * } */ - public static int MagickSetExtract(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickSetExtract.HANDLE; + public static int MagickGetImageFilter(MemorySegment x0) { + var mh$ = MagickGetImageFilter.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetExtract", x0, x1); + traceDowncall("MagickGetImageFilter", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetFilename { + private static class MagickGetImageGravity { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetFilename"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageGravity"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -2969,58 +17452,57 @@ private static class MagickSetFilename { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetFilename(MagickWand *, const char *) + * extern GravityType MagickGetImageGravity(MagickWand *) * } */ - public static FunctionDescriptor MagickSetFilename$descriptor() { - return MagickSetFilename.DESC; + public static FunctionDescriptor MagickGetImageGravity$descriptor() { + return MagickGetImageGravity.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetFilename(MagickWand *, const char *) + * extern GravityType MagickGetImageGravity(MagickWand *) * } */ - public static MethodHandle MagickSetFilename$handle() { - return MagickSetFilename.HANDLE; + public static MethodHandle MagickGetImageGravity$handle() { + return MagickGetImageGravity.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetFilename(MagickWand *, const char *) + * extern GravityType MagickGetImageGravity(MagickWand *) * } */ - public static MemorySegment MagickSetFilename$address() { - return MagickSetFilename.ADDR; + public static MemorySegment MagickGetImageGravity$address() { + return MagickGetImageGravity.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetFilename(MagickWand *, const char *) + * extern GravityType MagickGetImageGravity(MagickWand *) * } */ - public static int MagickSetFilename(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickSetFilename.HANDLE; + public static int MagickGetImageGravity(MemorySegment x0) { + var mh$ = MagickGetImageGravity.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetFilename", x0, x1); + traceDowncall("MagickGetImageGravity", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetFilter { + private static class MagickDestroyImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetFilter"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDestroyImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3028,58 +17510,57 @@ private static class MagickSetFilter { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetFilter(MagickWand *, const FilterType) + * extern Image *MagickDestroyImage(Image *) * } */ - public static FunctionDescriptor MagickSetFilter$descriptor() { - return MagickSetFilter.DESC; + public static FunctionDescriptor MagickDestroyImage$descriptor() { + return MagickDestroyImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetFilter(MagickWand *, const FilterType) + * extern Image *MagickDestroyImage(Image *) * } */ - public static MethodHandle MagickSetFilter$handle() { - return MagickSetFilter.HANDLE; + public static MethodHandle MagickDestroyImage$handle() { + return MagickDestroyImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetFilter(MagickWand *, const FilterType) + * extern Image *MagickDestroyImage(Image *) * } */ - public static MemorySegment MagickSetFilter$address() { - return MagickSetFilter.ADDR; + public static MemorySegment MagickDestroyImage$address() { + return MagickDestroyImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetFilter(MagickWand *, const FilterType) + * extern Image *MagickDestroyImage(Image *) * } */ - public static int MagickSetFilter(MemorySegment x0, int x1) { - var mh$ = MagickSetFilter.HANDLE; + public static MemorySegment MagickDestroyImage(MemorySegment x0) { + var mh$ = MagickDestroyImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetFilter", x0, x1); + traceDowncall("MagickDestroyImage", x0); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetFormat { + private static class GetImageFromMagickWand { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetFormat"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetImageFromMagickWand"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3087,58 +17568,57 @@ private static class MagickSetFormat { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetFormat(MagickWand *, const char *) + * extern Image *GetImageFromMagickWand(const MagickWand *) * } */ - public static FunctionDescriptor MagickSetFormat$descriptor() { - return MagickSetFormat.DESC; + public static FunctionDescriptor GetImageFromMagickWand$descriptor() { + return GetImageFromMagickWand.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetFormat(MagickWand *, const char *) + * extern Image *GetImageFromMagickWand(const MagickWand *) * } */ - public static MethodHandle MagickSetFormat$handle() { - return MagickSetFormat.HANDLE; + public static MethodHandle GetImageFromMagickWand$handle() { + return GetImageFromMagickWand.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetFormat(MagickWand *, const char *) + * extern Image *GetImageFromMagickWand(const MagickWand *) * } */ - public static MemorySegment MagickSetFormat$address() { - return MagickSetFormat.ADDR; + public static MemorySegment GetImageFromMagickWand$address() { + return GetImageFromMagickWand.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetFormat(MagickWand *, const char *) + * extern Image *GetImageFromMagickWand(const MagickWand *) * } */ - public static int MagickSetFormat(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickSetFormat.HANDLE; + public static MemorySegment GetImageFromMagickWand(MemorySegment x0) { + var mh$ = GetImageFromMagickWand.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetFormat", x0, x1); + traceDowncall("GetImageFromMagickWand", x0); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetFont { + private static class MagickGetImageType { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetFont"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageType"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3146,58 +17626,57 @@ private static class MagickSetFont { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetFont(MagickWand *, const char *) + * extern ImageType MagickGetImageType(MagickWand *) * } */ - public static FunctionDescriptor MagickSetFont$descriptor() { - return MagickSetFont.DESC; + public static FunctionDescriptor MagickGetImageType$descriptor() { + return MagickGetImageType.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetFont(MagickWand *, const char *) + * extern ImageType MagickGetImageType(MagickWand *) * } */ - public static MethodHandle MagickSetFont$handle() { - return MagickSetFont.HANDLE; + public static MethodHandle MagickGetImageType$handle() { + return MagickGetImageType.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetFont(MagickWand *, const char *) + * extern ImageType MagickGetImageType(MagickWand *) * } */ - public static MemorySegment MagickSetFont$address() { - return MagickSetFont.ADDR; + public static MemorySegment MagickGetImageType$address() { + return MagickGetImageType.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetFont(MagickWand *, const char *) + * extern ImageType MagickGetImageType(MagickWand *) * } */ - public static int MagickSetFont(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickSetFont.HANDLE; + public static int MagickGetImageType(MemorySegment x0) { + var mh$ = MagickGetImageType.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetFont", x0, x1); + traceDowncall("MagickGetImageType", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetGravity { + private static class MagickIdentifyImageType { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetGravity"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickIdentifyImageType"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3205,59 +17684,57 @@ private static class MagickSetGravity { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetGravity(MagickWand *, const GravityType) + * extern ImageType MagickIdentifyImageType(MagickWand *) * } */ - public static FunctionDescriptor MagickSetGravity$descriptor() { - return MagickSetGravity.DESC; + public static FunctionDescriptor MagickIdentifyImageType$descriptor() { + return MagickIdentifyImageType.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetGravity(MagickWand *, const GravityType) + * extern ImageType MagickIdentifyImageType(MagickWand *) * } */ - public static MethodHandle MagickSetGravity$handle() { - return MagickSetGravity.HANDLE; + public static MethodHandle MagickIdentifyImageType$handle() { + return MagickIdentifyImageType.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetGravity(MagickWand *, const GravityType) + * extern ImageType MagickIdentifyImageType(MagickWand *) * } */ - public static MemorySegment MagickSetGravity$address() { - return MagickSetGravity.ADDR; + public static MemorySegment MagickIdentifyImageType$address() { + return MagickIdentifyImageType.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetGravity(MagickWand *, const GravityType) + * extern ImageType MagickIdentifyImageType(MagickWand *) * } */ - public static int MagickSetGravity(MemorySegment x0, int x1) { - var mh$ = MagickSetGravity.HANDLE; + public static int MagickIdentifyImageType(MemorySegment x0) { + var mh$ = MagickIdentifyImageType.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetGravity", x0, x1); + traceDowncall("MagickIdentifyImageType", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageArtifact { + private static class MagickGetImageInterlaceScheme { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageArtifact"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageInterlaceScheme"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3265,60 +17742,57 @@ private static class MagickSetImageArtifact { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageArtifact(MagickWand *, const char *, const char *) + * extern InterlaceType MagickGetImageInterlaceScheme(MagickWand *) * } */ - public static FunctionDescriptor MagickSetImageArtifact$descriptor() { - return MagickSetImageArtifact.DESC; + public static FunctionDescriptor MagickGetImageInterlaceScheme$descriptor() { + return MagickGetImageInterlaceScheme.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageArtifact(MagickWand *, const char *, const char *) + * extern InterlaceType MagickGetImageInterlaceScheme(MagickWand *) * } */ - public static MethodHandle MagickSetImageArtifact$handle() { - return MagickSetImageArtifact.HANDLE; + public static MethodHandle MagickGetImageInterlaceScheme$handle() { + return MagickGetImageInterlaceScheme.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageArtifact(MagickWand *, const char *, const char *) + * extern InterlaceType MagickGetImageInterlaceScheme(MagickWand *) * } - */ - public static MemorySegment MagickSetImageArtifact$address() { - return MagickSetImageArtifact.ADDR; + */ + public static MemorySegment MagickGetImageInterlaceScheme$address() { + return MagickGetImageInterlaceScheme.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageArtifact(MagickWand *, const char *, const char *) + * extern InterlaceType MagickGetImageInterlaceScheme(MagickWand *) * } */ - public static int MagickSetImageArtifact(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickSetImageArtifact.HANDLE; + public static int MagickGetImageInterlaceScheme(MemorySegment x0) { + var mh$ = MagickGetImageInterlaceScheme.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageArtifact", x0, x1, x2); + traceDowncall("MagickGetImageInterlaceScheme", x0); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageProfile { + private static class MagickGetImageInterpolateMethod { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageProfile"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageInterpolateMethod"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3326,59 +17800,59 @@ private static class MagickSetImageProfile { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageProfile(MagickWand *, const char *, const void *, const size_t) + * extern PixelInterpolateMethod MagickGetImageInterpolateMethod(MagickWand *) * } */ - public static FunctionDescriptor MagickSetImageProfile$descriptor() { - return MagickSetImageProfile.DESC; + public static FunctionDescriptor MagickGetImageInterpolateMethod$descriptor() { + return MagickGetImageInterpolateMethod.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageProfile(MagickWand *, const char *, const void *, const size_t) + * extern PixelInterpolateMethod MagickGetImageInterpolateMethod(MagickWand *) * } */ - public static MethodHandle MagickSetImageProfile$handle() { - return MagickSetImageProfile.HANDLE; + public static MethodHandle MagickGetImageInterpolateMethod$handle() { + return MagickGetImageInterpolateMethod.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageProfile(MagickWand *, const char *, const void *, const size_t) + * extern PixelInterpolateMethod MagickGetImageInterpolateMethod(MagickWand *) * } */ - public static MemorySegment MagickSetImageProfile$address() { - return MagickSetImageProfile.ADDR; + public static MemorySegment MagickGetImageInterpolateMethod$address() { + return MagickGetImageInterpolateMethod.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageProfile(MagickWand *, const char *, const void *, const size_t) + * extern PixelInterpolateMethod MagickGetImageInterpolateMethod(MagickWand *) * } */ - public static int MagickSetImageProfile(MemorySegment x0, MemorySegment x1, MemorySegment x2, long x3) { - var mh$ = MagickSetImageProfile.HANDLE; + public static int MagickGetImageInterpolateMethod(MemorySegment x0) { + var mh$ = MagickGetImageInterpolateMethod.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageProfile", x0, x1, x2, x3); + traceDowncall("MagickGetImageInterpolateMethod", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageProperty { + private static class MagickAdaptiveBlurImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageProperty"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAdaptiveBlurImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3386,43 +17860,43 @@ private static class MagickSetImageProperty { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageProperty(MagickWand *, const char *, const char *) + * extern MagickBooleanType MagickAdaptiveBlurImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickSetImageProperty$descriptor() { - return MagickSetImageProperty.DESC; + public static FunctionDescriptor MagickAdaptiveBlurImage$descriptor() { + return MagickAdaptiveBlurImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageProperty(MagickWand *, const char *, const char *) + * extern MagickBooleanType MagickAdaptiveBlurImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickSetImageProperty$handle() { - return MagickSetImageProperty.HANDLE; + public static MethodHandle MagickAdaptiveBlurImage$handle() { + return MagickAdaptiveBlurImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageProperty(MagickWand *, const char *, const char *) + * extern MagickBooleanType MagickAdaptiveBlurImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickSetImageProperty$address() { - return MagickSetImageProperty.ADDR; + public static MemorySegment MagickAdaptiveBlurImage$address() { + return MagickAdaptiveBlurImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageProperty(MagickWand *, const char *, const char *) + * extern MagickBooleanType MagickAdaptiveBlurImage(MagickWand *, const double, const double) * } */ - public static int MagickSetImageProperty(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickSetImageProperty.HANDLE; + public static int MagickAdaptiveBlurImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickAdaptiveBlurImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageProperty", x0, x1, x2); + traceDowncall("MagickAdaptiveBlurImage", x0, x1, x2); } return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { @@ -3430,14 +17904,15 @@ public static int MagickSetImageProperty(MemorySegment x0, MemorySegment x1, Mem } } - private static class MagickSetInterlaceScheme { + private static class MagickAdaptiveResizeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetInterlaceScheme"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAdaptiveResizeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3445,58 +17920,59 @@ private static class MagickSetInterlaceScheme { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetInterlaceScheme(MagickWand *, const InterlaceType) + * extern MagickBooleanType MagickAdaptiveResizeImage(MagickWand *, const size_t, const size_t) * } */ - public static FunctionDescriptor MagickSetInterlaceScheme$descriptor() { - return MagickSetInterlaceScheme.DESC; + public static FunctionDescriptor MagickAdaptiveResizeImage$descriptor() { + return MagickAdaptiveResizeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetInterlaceScheme(MagickWand *, const InterlaceType) + * extern MagickBooleanType MagickAdaptiveResizeImage(MagickWand *, const size_t, const size_t) * } */ - public static MethodHandle MagickSetInterlaceScheme$handle() { - return MagickSetInterlaceScheme.HANDLE; + public static MethodHandle MagickAdaptiveResizeImage$handle() { + return MagickAdaptiveResizeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetInterlaceScheme(MagickWand *, const InterlaceType) + * extern MagickBooleanType MagickAdaptiveResizeImage(MagickWand *, const size_t, const size_t) * } */ - public static MemorySegment MagickSetInterlaceScheme$address() { - return MagickSetInterlaceScheme.ADDR; + public static MemorySegment MagickAdaptiveResizeImage$address() { + return MagickAdaptiveResizeImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetInterlaceScheme(MagickWand *, const InterlaceType) + * extern MagickBooleanType MagickAdaptiveResizeImage(MagickWand *, const size_t, const size_t) * } */ - public static int MagickSetInterlaceScheme(MemorySegment x0, int x1) { - var mh$ = MagickSetInterlaceScheme.HANDLE; + public static int MagickAdaptiveResizeImage(MemorySegment x0, long x1, long x2) { + var mh$ = MagickAdaptiveResizeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetInterlaceScheme", x0, x1); + traceDowncall("MagickAdaptiveResizeImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetInterpolateMethod { + private static class MagickAdaptiveSharpenImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetInterpolateMethod"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAdaptiveSharpenImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3504,59 +17980,60 @@ private static class MagickSetInterpolateMethod { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetInterpolateMethod(MagickWand *, const PixelInterpolateMethod) + * extern MagickBooleanType MagickAdaptiveSharpenImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickSetInterpolateMethod$descriptor() { - return MagickSetInterpolateMethod.DESC; + public static FunctionDescriptor MagickAdaptiveSharpenImage$descriptor() { + return MagickAdaptiveSharpenImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetInterpolateMethod(MagickWand *, const PixelInterpolateMethod) + * extern MagickBooleanType MagickAdaptiveSharpenImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickSetInterpolateMethod$handle() { - return MagickSetInterpolateMethod.HANDLE; + public static MethodHandle MagickAdaptiveSharpenImage$handle() { + return MagickAdaptiveSharpenImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetInterpolateMethod(MagickWand *, const PixelInterpolateMethod) + * extern MagickBooleanType MagickAdaptiveSharpenImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickSetInterpolateMethod$address() { - return MagickSetInterpolateMethod.ADDR; + public static MemorySegment MagickAdaptiveSharpenImage$address() { + return MagickAdaptiveSharpenImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetInterpolateMethod(MagickWand *, const PixelInterpolateMethod) + * extern MagickBooleanType MagickAdaptiveSharpenImage(MagickWand *, const double, const double) * } */ - public static int MagickSetInterpolateMethod(MemorySegment x0, int x1) { - var mh$ = MagickSetInterpolateMethod.HANDLE; + public static int MagickAdaptiveSharpenImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickAdaptiveSharpenImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetInterpolateMethod", x0, x1); + traceDowncall("MagickAdaptiveSharpenImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetOption { + private static class MagickAdaptiveThresholdImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetOption"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAdaptiveThresholdImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3564,58 +18041,58 @@ private static class MagickSetOption { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetOption(MagickWand *, const char *, const char *) + * extern MagickBooleanType MagickAdaptiveThresholdImage(MagickWand *, const size_t, const size_t, const double) * } */ - public static FunctionDescriptor MagickSetOption$descriptor() { - return MagickSetOption.DESC; + public static FunctionDescriptor MagickAdaptiveThresholdImage$descriptor() { + return MagickAdaptiveThresholdImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetOption(MagickWand *, const char *, const char *) + * extern MagickBooleanType MagickAdaptiveThresholdImage(MagickWand *, const size_t, const size_t, const double) * } */ - public static MethodHandle MagickSetOption$handle() { - return MagickSetOption.HANDLE; + public static MethodHandle MagickAdaptiveThresholdImage$handle() { + return MagickAdaptiveThresholdImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetOption(MagickWand *, const char *, const char *) + * extern MagickBooleanType MagickAdaptiveThresholdImage(MagickWand *, const size_t, const size_t, const double) * } */ - public static MemorySegment MagickSetOption$address() { - return MagickSetOption.ADDR; + public static MemorySegment MagickAdaptiveThresholdImage$address() { + return MagickAdaptiveThresholdImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetOption(MagickWand *, const char *, const char *) + * extern MagickBooleanType MagickAdaptiveThresholdImage(MagickWand *, const size_t, const size_t, const double) * } */ - public static int MagickSetOption(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickSetOption.HANDLE; + public static int MagickAdaptiveThresholdImage(MemorySegment x0, long x1, long x2, double x3) { + var mh$ = MagickAdaptiveThresholdImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetOption", x0, x1, x2); + traceDowncall("MagickAdaptiveThresholdImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetOrientation { + private static class MagickAddImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetOrientation"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAddImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3623,43 +18100,43 @@ private static class MagickSetOrientation { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetOrientation(MagickWand *, const OrientationType) + * extern MagickBooleanType MagickAddImage(MagickWand *, const MagickWand *) * } */ - public static FunctionDescriptor MagickSetOrientation$descriptor() { - return MagickSetOrientation.DESC; + public static FunctionDescriptor MagickAddImage$descriptor() { + return MagickAddImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetOrientation(MagickWand *, const OrientationType) + * extern MagickBooleanType MagickAddImage(MagickWand *, const MagickWand *) * } */ - public static MethodHandle MagickSetOrientation$handle() { - return MagickSetOrientation.HANDLE; + public static MethodHandle MagickAddImage$handle() { + return MagickAddImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetOrientation(MagickWand *, const OrientationType) + * extern MagickBooleanType MagickAddImage(MagickWand *, const MagickWand *) * } */ - public static MemorySegment MagickSetOrientation$address() { - return MagickSetOrientation.ADDR; + public static MemorySegment MagickAddImage$address() { + return MagickAddImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetOrientation(MagickWand *, const OrientationType) + * extern MagickBooleanType MagickAddImage(MagickWand *, const MagickWand *) * } */ - public static int MagickSetOrientation(MemorySegment x0, int x1) { - var mh$ = MagickSetOrientation.HANDLE; + public static int MagickAddImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickAddImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetOrientation", x0, x1); + traceDowncall("MagickAddImage", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -3667,17 +18144,15 @@ public static int MagickSetOrientation(MemorySegment x0, int x1) { } } - private static class MagickSetPage { + private static class MagickAddNoiseImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_INT, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetPage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAddNoiseImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3685,58 +18160,58 @@ private static class MagickSetPage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetPage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickAddNoiseImage(MagickWand *, const NoiseType, const double) * } */ - public static FunctionDescriptor MagickSetPage$descriptor() { - return MagickSetPage.DESC; + public static FunctionDescriptor MagickAddNoiseImage$descriptor() { + return MagickAddNoiseImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetPage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickAddNoiseImage(MagickWand *, const NoiseType, const double) * } */ - public static MethodHandle MagickSetPage$handle() { - return MagickSetPage.HANDLE; + public static MethodHandle MagickAddNoiseImage$handle() { + return MagickAddNoiseImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetPage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickAddNoiseImage(MagickWand *, const NoiseType, const double) * } */ - public static MemorySegment MagickSetPage$address() { - return MagickSetPage.ADDR; + public static MemorySegment MagickAddNoiseImage$address() { + return MagickAddNoiseImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetPage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickAddNoiseImage(MagickWand *, const NoiseType, const double) * } - */ - public static int MagickSetPage(MemorySegment x0, long x1, long x2, long x3, long x4) { - var mh$ = MagickSetPage.HANDLE; + */ + public static int MagickAddNoiseImage(MemorySegment x0, int x1, double x2) { + var mh$ = MagickAddNoiseImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetPage", x0, x1, x2, x3, x4); + traceDowncall("MagickAddNoiseImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetPassphrase { + private static class MagickAffineTransformImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetPassphrase"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAffineTransformImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3744,43 +18219,43 @@ private static class MagickSetPassphrase { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetPassphrase(MagickWand *, const char *) + * extern MagickBooleanType MagickAffineTransformImage(MagickWand *, const DrawingWand *) * } */ - public static FunctionDescriptor MagickSetPassphrase$descriptor() { - return MagickSetPassphrase.DESC; + public static FunctionDescriptor MagickAffineTransformImage$descriptor() { + return MagickAffineTransformImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetPassphrase(MagickWand *, const char *) + * extern MagickBooleanType MagickAffineTransformImage(MagickWand *, const DrawingWand *) * } */ - public static MethodHandle MagickSetPassphrase$handle() { - return MagickSetPassphrase.HANDLE; + public static MethodHandle MagickAffineTransformImage$handle() { + return MagickAffineTransformImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetPassphrase(MagickWand *, const char *) + * extern MagickBooleanType MagickAffineTransformImage(MagickWand *, const DrawingWand *) * } */ - public static MemorySegment MagickSetPassphrase$address() { - return MagickSetPassphrase.ADDR; + public static MemorySegment MagickAffineTransformImage$address() { + return MagickAffineTransformImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetPassphrase(MagickWand *, const char *) + * extern MagickBooleanType MagickAffineTransformImage(MagickWand *, const DrawingWand *) * } */ - public static int MagickSetPassphrase(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickSetPassphrase.HANDLE; + public static int MagickAffineTransformImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickAffineTransformImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetPassphrase", x0, x1); + traceDowncall("MagickAffineTransformImage", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -3788,14 +18263,18 @@ public static int MagickSetPassphrase(MemorySegment x0, MemorySegment x1) { } } - private static class MagickSetPointsize { + private static class MagickAnnotateImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetPointsize"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAnnotateImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3803,59 +18282,58 @@ private static class MagickSetPointsize { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetPointsize(MagickWand *, const double) + * extern MagickBooleanType MagickAnnotateImage(MagickWand *, const DrawingWand *, const double, const double, const double, const char *) * } */ - public static FunctionDescriptor MagickSetPointsize$descriptor() { - return MagickSetPointsize.DESC; + public static FunctionDescriptor MagickAnnotateImage$descriptor() { + return MagickAnnotateImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetPointsize(MagickWand *, const double) + * extern MagickBooleanType MagickAnnotateImage(MagickWand *, const DrawingWand *, const double, const double, const double, const char *) * } */ - public static MethodHandle MagickSetPointsize$handle() { - return MagickSetPointsize.HANDLE; + public static MethodHandle MagickAnnotateImage$handle() { + return MagickAnnotateImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetPointsize(MagickWand *, const double) + * extern MagickBooleanType MagickAnnotateImage(MagickWand *, const DrawingWand *, const double, const double, const double, const char *) * } */ - public static MemorySegment MagickSetPointsize$address() { - return MagickSetPointsize.ADDR; + public static MemorySegment MagickAnnotateImage$address() { + return MagickAnnotateImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetPointsize(MagickWand *, const double) + * extern MagickBooleanType MagickAnnotateImage(MagickWand *, const DrawingWand *, const double, const double, const double, const char *) * } */ - public static int MagickSetPointsize(MemorySegment x0, double x1) { - var mh$ = MagickSetPointsize.HANDLE; + public static int MagickAnnotateImage(MemorySegment x0, MemorySegment x1, double x2, double x3, double x4, MemorySegment x5) { + var mh$ = MagickAnnotateImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetPointsize", x0, x1); + traceDowncall("MagickAnnotateImage", x0, x1, x2, x3, x4, x5); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetResolution { + private static class MagickAnimateImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetResolution"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAnimateImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3863,58 +18341,57 @@ private static class MagickSetResolution { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetResolution(MagickWand *, const double, const double) + * extern MagickBooleanType MagickAnimateImages(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickSetResolution$descriptor() { - return MagickSetResolution.DESC; + public static FunctionDescriptor MagickAnimateImages$descriptor() { + return MagickAnimateImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetResolution(MagickWand *, const double, const double) + * extern MagickBooleanType MagickAnimateImages(MagickWand *, const char *) * } */ - public static MethodHandle MagickSetResolution$handle() { - return MagickSetResolution.HANDLE; + public static MethodHandle MagickAnimateImages$handle() { + return MagickAnimateImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetResolution(MagickWand *, const double, const double) + * extern MagickBooleanType MagickAnimateImages(MagickWand *, const char *) * } */ - public static MemorySegment MagickSetResolution$address() { - return MagickSetResolution.ADDR; + public static MemorySegment MagickAnimateImages$address() { + return MagickAnimateImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetResolution(MagickWand *, const double, const double) + * extern MagickBooleanType MagickAnimateImages(MagickWand *, const char *) * } */ - public static int MagickSetResolution(MemorySegment x0, double x1, double x2) { - var mh$ = MagickSetResolution.HANDLE; + public static int MagickAnimateImages(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickAnimateImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetResolution", x0, x1, x2); + traceDowncall("MagickAnimateImages", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetResourceLimit { + private static class MagickAutoGammaImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_INT, - MagickWand_h.C_LONG_LONG + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetResourceLimit"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAutoGammaImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3922,59 +18399,57 @@ private static class MagickSetResourceLimit { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetResourceLimit(const ResourceType type, const MagickSizeType limit) + * extern MagickBooleanType MagickAutoGammaImage(MagickWand *) * } */ - public static FunctionDescriptor MagickSetResourceLimit$descriptor() { - return MagickSetResourceLimit.DESC; + public static FunctionDescriptor MagickAutoGammaImage$descriptor() { + return MagickAutoGammaImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetResourceLimit(const ResourceType type, const MagickSizeType limit) + * extern MagickBooleanType MagickAutoGammaImage(MagickWand *) * } */ - public static MethodHandle MagickSetResourceLimit$handle() { - return MagickSetResourceLimit.HANDLE; + public static MethodHandle MagickAutoGammaImage$handle() { + return MagickAutoGammaImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetResourceLimit(const ResourceType type, const MagickSizeType limit) + * extern MagickBooleanType MagickAutoGammaImage(MagickWand *) * } */ - public static MemorySegment MagickSetResourceLimit$address() { - return MagickSetResourceLimit.ADDR; + public static MemorySegment MagickAutoGammaImage$address() { + return MagickAutoGammaImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetResourceLimit(const ResourceType type, const MagickSizeType limit) + * extern MagickBooleanType MagickAutoGammaImage(MagickWand *) * } */ - public static int MagickSetResourceLimit(int type, long limit) { - var mh$ = MagickSetResourceLimit.HANDLE; + public static int MagickAutoGammaImage(MemorySegment x0) { + var mh$ = MagickAutoGammaImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetResourceLimit", type, limit); + traceDowncall("MagickAutoGammaImage", x0); } - return (int)mh$.invokeExact(type, limit); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetSamplingFactors { + private static class MagickAutoLevelImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetSamplingFactors"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAutoLevelImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -3982,58 +18457,57 @@ private static class MagickSetSamplingFactors { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetSamplingFactors(MagickWand *, const size_t, const double *) + * extern MagickBooleanType MagickAutoLevelImage(MagickWand *) * } */ - public static FunctionDescriptor MagickSetSamplingFactors$descriptor() { - return MagickSetSamplingFactors.DESC; + public static FunctionDescriptor MagickAutoLevelImage$descriptor() { + return MagickAutoLevelImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetSamplingFactors(MagickWand *, const size_t, const double *) + * extern MagickBooleanType MagickAutoLevelImage(MagickWand *) * } */ - public static MethodHandle MagickSetSamplingFactors$handle() { - return MagickSetSamplingFactors.HANDLE; + public static MethodHandle MagickAutoLevelImage$handle() { + return MagickAutoLevelImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetSamplingFactors(MagickWand *, const size_t, const double *) + * extern MagickBooleanType MagickAutoLevelImage(MagickWand *) * } */ - public static MemorySegment MagickSetSamplingFactors$address() { - return MagickSetSamplingFactors.ADDR; + public static MemorySegment MagickAutoLevelImage$address() { + return MagickAutoLevelImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetSamplingFactors(MagickWand *, const size_t, const double *) + * extern MagickBooleanType MagickAutoLevelImage(MagickWand *) * } */ - public static int MagickSetSamplingFactors(MemorySegment x0, long x1, MemorySegment x2) { - var mh$ = MagickSetSamplingFactors.HANDLE; + public static int MagickAutoLevelImage(MemorySegment x0) { + var mh$ = MagickAutoLevelImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetSamplingFactors", x0, x1, x2); + traceDowncall("MagickAutoLevelImage", x0); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetSecurityPolicy { + private static class MagickAutoOrientImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetSecurityPolicy"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAutoOrientImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4041,59 +18515,58 @@ private static class MagickSetSecurityPolicy { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetSecurityPolicy(MagickWand *, const char *) + * extern MagickBooleanType MagickAutoOrientImage(MagickWand *) * } */ - public static FunctionDescriptor MagickSetSecurityPolicy$descriptor() { - return MagickSetSecurityPolicy.DESC; + public static FunctionDescriptor MagickAutoOrientImage$descriptor() { + return MagickAutoOrientImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetSecurityPolicy(MagickWand *, const char *) + * extern MagickBooleanType MagickAutoOrientImage(MagickWand *) * } */ - public static MethodHandle MagickSetSecurityPolicy$handle() { - return MagickSetSecurityPolicy.HANDLE; + public static MethodHandle MagickAutoOrientImage$handle() { + return MagickAutoOrientImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetSecurityPolicy(MagickWand *, const char *) + * extern MagickBooleanType MagickAutoOrientImage(MagickWand *) * } */ - public static MemorySegment MagickSetSecurityPolicy$address() { - return MagickSetSecurityPolicy.ADDR; + public static MemorySegment MagickAutoOrientImage$address() { + return MagickAutoOrientImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetSecurityPolicy(MagickWand *, const char *) + * extern MagickBooleanType MagickAutoOrientImage(MagickWand *) * } */ - public static int MagickSetSecurityPolicy(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickSetSecurityPolicy.HANDLE; + public static int MagickAutoOrientImage(MemorySegment x0) { + var mh$ = MagickAutoOrientImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetSecurityPolicy", x0, x1); + traceDowncall("MagickAutoOrientImage", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetSize { + private static class MagickAutoThresholdImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetSize"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAutoThresholdImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4101,60 +18574,61 @@ private static class MagickSetSize { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetSize(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickAutoThresholdImage(MagickWand *, const AutoThresholdMethod) * } */ - public static FunctionDescriptor MagickSetSize$descriptor() { - return MagickSetSize.DESC; + public static FunctionDescriptor MagickAutoThresholdImage$descriptor() { + return MagickAutoThresholdImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetSize(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickAutoThresholdImage(MagickWand *, const AutoThresholdMethod) * } */ - public static MethodHandle MagickSetSize$handle() { - return MagickSetSize.HANDLE; + public static MethodHandle MagickAutoThresholdImage$handle() { + return MagickAutoThresholdImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetSize(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickAutoThresholdImage(MagickWand *, const AutoThresholdMethod) * } */ - public static MemorySegment MagickSetSize$address() { - return MagickSetSize.ADDR; + public static MemorySegment MagickAutoThresholdImage$address() { + return MagickAutoThresholdImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetSize(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickAutoThresholdImage(MagickWand *, const AutoThresholdMethod) * } */ - public static int MagickSetSize(MemorySegment x0, long x1, long x2) { - var mh$ = MagickSetSize.HANDLE; + public static int MagickAutoThresholdImage(MemorySegment x0, int x1) { + var mh$ = MagickAutoThresholdImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetSize", x0, x1, x2); + traceDowncall("MagickAutoThresholdImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetSizeOffset { + private static class MagickBilateralBlurImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetSizeOffset"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickBilateralBlurImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4162,59 +18636,58 @@ private static class MagickSetSizeOffset { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetSizeOffset(MagickWand *, const size_t, const size_t, const ssize_t) + * extern MagickBooleanType MagickBilateralBlurImage(MagickWand *, const double, const double, const double, const double) * } */ - public static FunctionDescriptor MagickSetSizeOffset$descriptor() { - return MagickSetSizeOffset.DESC; + public static FunctionDescriptor MagickBilateralBlurImage$descriptor() { + return MagickBilateralBlurImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetSizeOffset(MagickWand *, const size_t, const size_t, const ssize_t) + * extern MagickBooleanType MagickBilateralBlurImage(MagickWand *, const double, const double, const double, const double) * } */ - public static MethodHandle MagickSetSizeOffset$handle() { - return MagickSetSizeOffset.HANDLE; + public static MethodHandle MagickBilateralBlurImage$handle() { + return MagickBilateralBlurImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetSizeOffset(MagickWand *, const size_t, const size_t, const ssize_t) + * extern MagickBooleanType MagickBilateralBlurImage(MagickWand *, const double, const double, const double, const double) * } */ - public static MemorySegment MagickSetSizeOffset$address() { - return MagickSetSizeOffset.ADDR; + public static MemorySegment MagickBilateralBlurImage$address() { + return MagickBilateralBlurImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetSizeOffset(MagickWand *, const size_t, const size_t, const ssize_t) + * extern MagickBooleanType MagickBilateralBlurImage(MagickWand *, const double, const double, const double, const double) * } */ - public static int MagickSetSizeOffset(MemorySegment x0, long x1, long x2, long x3) { - var mh$ = MagickSetSizeOffset.HANDLE; + public static int MagickBilateralBlurImage(MemorySegment x0, double x1, double x2, double x3, double x4) { + var mh$ = MagickBilateralBlurImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetSizeOffset", x0, x1, x2, x3); + traceDowncall("MagickBilateralBlurImage", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetProgressMonitor { + private static class MagickBlackThresholdImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetProgressMonitor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickBlackThresholdImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4222,57 +18695,58 @@ private static class MagickSetProgressMonitor { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickProgressMonitor MagickSetProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) + * extern MagickBooleanType MagickBlackThresholdImage(MagickWand *, const PixelWand *) * } */ - public static FunctionDescriptor MagickSetProgressMonitor$descriptor() { - return MagickSetProgressMonitor.DESC; + public static FunctionDescriptor MagickBlackThresholdImage$descriptor() { + return MagickBlackThresholdImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickProgressMonitor MagickSetProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) + * extern MagickBooleanType MagickBlackThresholdImage(MagickWand *, const PixelWand *) * } */ - public static MethodHandle MagickSetProgressMonitor$handle() { - return MagickSetProgressMonitor.HANDLE; + public static MethodHandle MagickBlackThresholdImage$handle() { + return MagickBlackThresholdImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickProgressMonitor MagickSetProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) + * extern MagickBooleanType MagickBlackThresholdImage(MagickWand *, const PixelWand *) * } */ - public static MemorySegment MagickSetProgressMonitor$address() { - return MagickSetProgressMonitor.ADDR; + public static MemorySegment MagickBlackThresholdImage$address() { + return MagickBlackThresholdImage.ADDR; } /** * {@snippet lang=c : - * extern MagickProgressMonitor MagickSetProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) + * extern MagickBooleanType MagickBlackThresholdImage(MagickWand *, const PixelWand *) * } */ - public static MemorySegment MagickSetProgressMonitor(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickSetProgressMonitor.HANDLE; + public static int MagickBlackThresholdImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickBlackThresholdImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetProgressMonitor", x0, x1, x2); + traceDowncall("MagickBlackThresholdImage", x0, x1); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetResource { + private static class MagickBlueShiftImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_LONG_LONG, - MagickWand_h.C_INT + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetResource"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickBlueShiftImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4280,57 +18754,59 @@ private static class MagickGetResource { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickSizeType MagickGetResource(const ResourceType) + * extern MagickBooleanType MagickBlueShiftImage(MagickWand *, const double) * } */ - public static FunctionDescriptor MagickGetResource$descriptor() { - return MagickGetResource.DESC; + public static FunctionDescriptor MagickBlueShiftImage$descriptor() { + return MagickBlueShiftImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickSizeType MagickGetResource(const ResourceType) + * extern MagickBooleanType MagickBlueShiftImage(MagickWand *, const double) * } */ - public static MethodHandle MagickGetResource$handle() { - return MagickGetResource.HANDLE; + public static MethodHandle MagickBlueShiftImage$handle() { + return MagickBlueShiftImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickSizeType MagickGetResource(const ResourceType) + * extern MagickBooleanType MagickBlueShiftImage(MagickWand *, const double) * } */ - public static MemorySegment MagickGetResource$address() { - return MagickGetResource.ADDR; + public static MemorySegment MagickBlueShiftImage$address() { + return MagickBlueShiftImage.ADDR; } /** * {@snippet lang=c : - * extern MagickSizeType MagickGetResource(const ResourceType) + * extern MagickBooleanType MagickBlueShiftImage(MagickWand *, const double) * } */ - public static long MagickGetResource(int x0) { - var mh$ = MagickGetResource.HANDLE; + public static int MagickBlueShiftImage(MemorySegment x0, double x1) { + var mh$ = MagickBlueShiftImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetResource", x0); + traceDowncall("MagickBlueShiftImage", x0, x1); } - return (long)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetResourceLimit { + private static class MagickBlurImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_LONG_LONG, - MagickWand_h.C_INT + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetResourceLimit"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickBlurImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4338,57 +18814,61 @@ private static class MagickGetResourceLimit { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickSizeType MagickGetResourceLimit(const ResourceType) + * extern MagickBooleanType MagickBlurImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickGetResourceLimit$descriptor() { - return MagickGetResourceLimit.DESC; + public static FunctionDescriptor MagickBlurImage$descriptor() { + return MagickBlurImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickSizeType MagickGetResourceLimit(const ResourceType) + * extern MagickBooleanType MagickBlurImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickGetResourceLimit$handle() { - return MagickGetResourceLimit.HANDLE; + public static MethodHandle MagickBlurImage$handle() { + return MagickBlurImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickSizeType MagickGetResourceLimit(const ResourceType) + * extern MagickBooleanType MagickBlurImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickGetResourceLimit$address() { - return MagickGetResourceLimit.ADDR; + public static MemorySegment MagickBlurImage$address() { + return MagickBlurImage.ADDR; } /** * {@snippet lang=c : - * extern MagickSizeType MagickGetResourceLimit(const ResourceType) + * extern MagickBooleanType MagickBlurImage(MagickWand *, const double, const double) * } */ - public static long MagickGetResourceLimit(int x0) { - var mh$ = MagickGetResourceLimit.HANDLE; + public static int MagickBlurImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickBlurImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetResourceLimit", x0); + traceDowncall("MagickBlurImage", x0, x1, x2); } - return (long)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetBackgroundColor { + private static class MagickBorderImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetBackgroundColor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickBorderImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4396,57 +18876,59 @@ private static class MagickGetBackgroundColor { /** * Function descriptor for: * {@snippet lang=c : - * extern PixelWand *MagickGetBackgroundColor(MagickWand *) + * extern MagickBooleanType MagickBorderImage(MagickWand *, const PixelWand *, const size_t, const size_t, const CompositeOperator compose) * } */ - public static FunctionDescriptor MagickGetBackgroundColor$descriptor() { - return MagickGetBackgroundColor.DESC; + public static FunctionDescriptor MagickBorderImage$descriptor() { + return MagickBorderImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern PixelWand *MagickGetBackgroundColor(MagickWand *) + * extern MagickBooleanType MagickBorderImage(MagickWand *, const PixelWand *, const size_t, const size_t, const CompositeOperator compose) * } */ - public static MethodHandle MagickGetBackgroundColor$handle() { - return MagickGetBackgroundColor.HANDLE; + public static MethodHandle MagickBorderImage$handle() { + return MagickBorderImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern PixelWand *MagickGetBackgroundColor(MagickWand *) + * extern MagickBooleanType MagickBorderImage(MagickWand *, const PixelWand *, const size_t, const size_t, const CompositeOperator compose) * } */ - public static MemorySegment MagickGetBackgroundColor$address() { - return MagickGetBackgroundColor.ADDR; + public static MemorySegment MagickBorderImage$address() { + return MagickBorderImage.ADDR; } /** * {@snippet lang=c : - * extern PixelWand *MagickGetBackgroundColor(MagickWand *) + * extern MagickBooleanType MagickBorderImage(MagickWand *, const PixelWand *, const size_t, const size_t, const CompositeOperator compose) * } */ - public static MemorySegment MagickGetBackgroundColor(MemorySegment x0) { - var mh$ = MagickGetBackgroundColor.HANDLE; + public static int MagickBorderImage(MemorySegment x0, MemorySegment x1, long x2, long x3, int compose) { + var mh$ = MagickBorderImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetBackgroundColor", x0); + traceDowncall("MagickBorderImage", x0, x1, x2, x3, compose); } - return (MemorySegment)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3, compose); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetCompressionQuality { + private static class MagickBrightnessContrastImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_LONG, - MagickWand_h.C_POINTER + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetCompressionQuality"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickBrightnessContrastImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4454,59 +18936,61 @@ private static class MagickGetCompressionQuality { /** * Function descriptor for: * {@snippet lang=c : - * extern size_t MagickGetCompressionQuality(MagickWand *) + * extern MagickBooleanType MagickBrightnessContrastImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickGetCompressionQuality$descriptor() { - return MagickGetCompressionQuality.DESC; + public static FunctionDescriptor MagickBrightnessContrastImage$descriptor() { + return MagickBrightnessContrastImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern size_t MagickGetCompressionQuality(MagickWand *) + * extern MagickBooleanType MagickBrightnessContrastImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickGetCompressionQuality$handle() { - return MagickGetCompressionQuality.HANDLE; + public static MethodHandle MagickBrightnessContrastImage$handle() { + return MagickBrightnessContrastImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern size_t MagickGetCompressionQuality(MagickWand *) + * extern MagickBooleanType MagickBrightnessContrastImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickGetCompressionQuality$address() { - return MagickGetCompressionQuality.ADDR; + public static MemorySegment MagickBrightnessContrastImage$address() { + return MagickBrightnessContrastImage.ADDR; } /** * {@snippet lang=c : - * extern size_t MagickGetCompressionQuality(MagickWand *) + * extern MagickBooleanType MagickBrightnessContrastImage(MagickWand *, const double, const double) * } */ - public static long MagickGetCompressionQuality(MemorySegment x0) { - var mh$ = MagickGetCompressionQuality.HANDLE; + public static int MagickBrightnessContrastImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickBrightnessContrastImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetCompressionQuality", x0); + traceDowncall("MagickBrightnessContrastImage", x0, x1, x2); } - return (long)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageProfile { + private static class MagickCannyEdgeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageProfile"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCannyEdgeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4514,59 +18998,59 @@ private static class MagickGetImageProfile { /** * Function descriptor for: * {@snippet lang=c : - * extern unsigned char *MagickGetImageProfile(MagickWand *, const char *, size_t *) + * extern MagickBooleanType MagickCannyEdgeImage(MagickWand *, const double, const double, const double, const double) * } */ - public static FunctionDescriptor MagickGetImageProfile$descriptor() { - return MagickGetImageProfile.DESC; + public static FunctionDescriptor MagickCannyEdgeImage$descriptor() { + return MagickCannyEdgeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern unsigned char *MagickGetImageProfile(MagickWand *, const char *, size_t *) + * extern MagickBooleanType MagickCannyEdgeImage(MagickWand *, const double, const double, const double, const double) * } */ - public static MethodHandle MagickGetImageProfile$handle() { - return MagickGetImageProfile.HANDLE; + public static MethodHandle MagickCannyEdgeImage$handle() { + return MagickCannyEdgeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern unsigned char *MagickGetImageProfile(MagickWand *, const char *, size_t *) + * extern MagickBooleanType MagickCannyEdgeImage(MagickWand *, const double, const double, const double, const double) * } */ - public static MemorySegment MagickGetImageProfile$address() { - return MagickGetImageProfile.ADDR; + public static MemorySegment MagickCannyEdgeImage$address() { + return MagickCannyEdgeImage.ADDR; } /** * {@snippet lang=c : - * extern unsigned char *MagickGetImageProfile(MagickWand *, const char *, size_t *) + * extern MagickBooleanType MagickCannyEdgeImage(MagickWand *, const double, const double, const double, const double) * } */ - public static MemorySegment MagickGetImageProfile(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickGetImageProfile.HANDLE; + public static int MagickCannyEdgeImage(MemorySegment x0, double x1, double x2, double x3, double x4) { + var mh$ = MagickCannyEdgeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageProfile", x0, x1, x2); + traceDowncall("MagickCannyEdgeImage", x0, x1, x2, x3, x4); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickRemoveImageProfile { + private static class MagickCharcoalImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRemoveImageProfile"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCharcoalImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4574,56 +19058,61 @@ private static class MagickRemoveImageProfile { /** * Function descriptor for: * {@snippet lang=c : - * extern unsigned char *MagickRemoveImageProfile(MagickWand *, const char *, size_t *) + * extern MagickBooleanType MagickCharcoalImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickRemoveImageProfile$descriptor() { - return MagickRemoveImageProfile.DESC; + public static FunctionDescriptor MagickCharcoalImage$descriptor() { + return MagickCharcoalImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern unsigned char *MagickRemoveImageProfile(MagickWand *, const char *, size_t *) + * extern MagickBooleanType MagickCharcoalImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickRemoveImageProfile$handle() { - return MagickRemoveImageProfile.HANDLE; + public static MethodHandle MagickCharcoalImage$handle() { + return MagickCharcoalImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern unsigned char *MagickRemoveImageProfile(MagickWand *, const char *, size_t *) + * extern MagickBooleanType MagickCharcoalImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickRemoveImageProfile$address() { - return MagickRemoveImageProfile.ADDR; + public static MemorySegment MagickCharcoalImage$address() { + return MagickCharcoalImage.ADDR; } /** * {@snippet lang=c : - * extern unsigned char *MagickRemoveImageProfile(MagickWand *, const char *, size_t *) + * extern MagickBooleanType MagickCharcoalImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickRemoveImageProfile(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickRemoveImageProfile.HANDLE; + public static int MagickCharcoalImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickCharcoalImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickRemoveImageProfile", x0, x1, x2); + traceDowncall("MagickCharcoalImage", x0, x1, x2); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetSeed { - public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + private static class MagickChopImage { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetSeed"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickChopImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4631,58 +19120,61 @@ private static class MagickSetSeed { /** * Function descriptor for: * {@snippet lang=c : - * extern void MagickSetSeed(const unsigned long) + * extern MagickBooleanType MagickChopImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static FunctionDescriptor MagickSetSeed$descriptor() { - return MagickSetSeed.DESC; + public static FunctionDescriptor MagickChopImage$descriptor() { + return MagickChopImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern void MagickSetSeed(const unsigned long) + * extern MagickBooleanType MagickChopImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static MethodHandle MagickSetSeed$handle() { - return MagickSetSeed.HANDLE; + public static MethodHandle MagickChopImage$handle() { + return MagickChopImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern void MagickSetSeed(const unsigned long) + * extern MagickBooleanType MagickChopImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static MemorySegment MagickSetSeed$address() { - return MagickSetSeed.ADDR; + public static MemorySegment MagickChopImage$address() { + return MagickChopImage.ADDR; } /** * {@snippet lang=c : - * extern void MagickSetSeed(const unsigned long) + * extern MagickBooleanType MagickChopImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static void MagickSetSeed(long x0) { - var mh$ = MagickSetSeed.HANDLE; + public static int MagickChopImage(MemorySegment x0, long x1, long x2, long x3, long x4) { + var mh$ = MagickChopImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetSeed", x0); + traceDowncall("MagickChopImage", x0, x1, x2, x3, x4); } - mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageFeatures { + private static class MagickCLAHEImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageFeatures"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCLAHEImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4690,58 +19182,57 @@ private static class MagickGetImageFeatures { /** * Function descriptor for: * {@snippet lang=c : - * extern ChannelFeatures *MagickGetImageFeatures(MagickWand *, const size_t) + * extern MagickBooleanType MagickCLAHEImage(MagickWand *, const size_t, const size_t, const double, const double) * } */ - public static FunctionDescriptor MagickGetImageFeatures$descriptor() { - return MagickGetImageFeatures.DESC; + public static FunctionDescriptor MagickCLAHEImage$descriptor() { + return MagickCLAHEImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern ChannelFeatures *MagickGetImageFeatures(MagickWand *, const size_t) + * extern MagickBooleanType MagickCLAHEImage(MagickWand *, const size_t, const size_t, const double, const double) * } */ - public static MethodHandle MagickGetImageFeatures$handle() { - return MagickGetImageFeatures.HANDLE; + public static MethodHandle MagickCLAHEImage$handle() { + return MagickCLAHEImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern ChannelFeatures *MagickGetImageFeatures(MagickWand *, const size_t) + * extern MagickBooleanType MagickCLAHEImage(MagickWand *, const size_t, const size_t, const double, const double) * } */ - public static MemorySegment MagickGetImageFeatures$address() { - return MagickGetImageFeatures.ADDR; + public static MemorySegment MagickCLAHEImage$address() { + return MagickCLAHEImage.ADDR; } /** * {@snippet lang=c : - * extern ChannelFeatures *MagickGetImageFeatures(MagickWand *, const size_t) + * extern MagickBooleanType MagickCLAHEImage(MagickWand *, const size_t, const size_t, const double, const double) * } */ - public static MemorySegment MagickGetImageFeatures(MemorySegment x0, long x1) { - var mh$ = MagickGetImageFeatures.HANDLE; + public static int MagickCLAHEImage(MemorySegment x0, long x1, long x2, double x3, double x4) { + var mh$ = MagickCLAHEImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageFeatures", x0, x1); + traceDowncall("MagickCLAHEImage", x0, x1, x2, x3, x4); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageChannelMask { + private static class MagickClampImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageChannelMask"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickClampImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4749,57 +19240,57 @@ private static class MagickSetImageChannelMask { /** * Function descriptor for: * {@snippet lang=c : - * extern ChannelType MagickSetImageChannelMask(MagickWand *, const ChannelType) + * extern MagickBooleanType MagickClampImage(MagickWand *) * } */ - public static FunctionDescriptor MagickSetImageChannelMask$descriptor() { - return MagickSetImageChannelMask.DESC; + public static FunctionDescriptor MagickClampImage$descriptor() { + return MagickClampImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern ChannelType MagickSetImageChannelMask(MagickWand *, const ChannelType) + * extern MagickBooleanType MagickClampImage(MagickWand *) * } */ - public static MethodHandle MagickSetImageChannelMask$handle() { - return MagickSetImageChannelMask.HANDLE; + public static MethodHandle MagickClampImage$handle() { + return MagickClampImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern ChannelType MagickSetImageChannelMask(MagickWand *, const ChannelType) + * extern MagickBooleanType MagickClampImage(MagickWand *) * } */ - public static MemorySegment MagickSetImageChannelMask$address() { - return MagickSetImageChannelMask.ADDR; + public static MemorySegment MagickClampImage$address() { + return MagickClampImage.ADDR; } /** * {@snippet lang=c : - * extern ChannelType MagickSetImageChannelMask(MagickWand *, const ChannelType) + * extern MagickBooleanType MagickClampImage(MagickWand *) * } */ - public static int MagickSetImageChannelMask(MemorySegment x0, int x1) { - var mh$ = MagickSetImageChannelMask.HANDLE; + public static int MagickClampImage(MemorySegment x0) { + var mh$ = MagickClampImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageChannelMask", x0, x1); + traceDowncall("MagickClampImage", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageStatistics { + private static class MagickClipImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageStatistics"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickClipImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4807,57 +19298,59 @@ private static class MagickGetImageStatistics { /** * Function descriptor for: * {@snippet lang=c : - * extern ChannelStatistics *MagickGetImageStatistics(MagickWand *) + * extern MagickBooleanType MagickClipImage(MagickWand *) * } */ - public static FunctionDescriptor MagickGetImageStatistics$descriptor() { - return MagickGetImageStatistics.DESC; + public static FunctionDescriptor MagickClipImage$descriptor() { + return MagickClipImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern ChannelStatistics *MagickGetImageStatistics(MagickWand *) + * extern MagickBooleanType MagickClipImage(MagickWand *) * } */ - public static MethodHandle MagickGetImageStatistics$handle() { - return MagickGetImageStatistics.HANDLE; + public static MethodHandle MagickClipImage$handle() { + return MagickClipImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern ChannelStatistics *MagickGetImageStatistics(MagickWand *) + * extern MagickBooleanType MagickClipImage(MagickWand *) * } */ - public static MemorySegment MagickGetImageStatistics$address() { - return MagickGetImageStatistics.ADDR; + public static MemorySegment MagickClipImage$address() { + return MagickClipImage.ADDR; } /** * {@snippet lang=c : - * extern ChannelStatistics *MagickGetImageStatistics(MagickWand *) + * extern MagickBooleanType MagickClipImage(MagickWand *) * } */ - public static MemorySegment MagickGetImageStatistics(MemorySegment x0) { - var mh$ = MagickGetImageStatistics.HANDLE; + public static int MagickClipImage(MemorySegment x0) { + var mh$ = MagickClipImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageStatistics", x0); + traceDowncall("MagickClipImage", x0); } - return (MemorySegment)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageFilename { + private static class MagickClipImagePath { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageFilename"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickClipImagePath"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4865,57 +19358,59 @@ private static class MagickGetImageFilename { /** * Function descriptor for: * {@snippet lang=c : - * extern char *MagickGetImageFilename(MagickWand *) + * extern MagickBooleanType MagickClipImagePath(MagickWand *, const char *, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickGetImageFilename$descriptor() { - return MagickGetImageFilename.DESC; + public static FunctionDescriptor MagickClipImagePath$descriptor() { + return MagickClipImagePath.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char *MagickGetImageFilename(MagickWand *) + * extern MagickBooleanType MagickClipImagePath(MagickWand *, const char *, const MagickBooleanType) * } */ - public static MethodHandle MagickGetImageFilename$handle() { - return MagickGetImageFilename.HANDLE; + public static MethodHandle MagickClipImagePath$handle() { + return MagickClipImagePath.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char *MagickGetImageFilename(MagickWand *) + * extern MagickBooleanType MagickClipImagePath(MagickWand *, const char *, const MagickBooleanType) * } */ - public static MemorySegment MagickGetImageFilename$address() { - return MagickGetImageFilename.ADDR; + public static MemorySegment MagickClipImagePath$address() { + return MagickClipImagePath.ADDR; } /** * {@snippet lang=c : - * extern char *MagickGetImageFilename(MagickWand *) + * extern MagickBooleanType MagickClipImagePath(MagickWand *, const char *, const MagickBooleanType) * } */ - public static MemorySegment MagickGetImageFilename(MemorySegment x0) { - var mh$ = MagickGetImageFilename.HANDLE; + public static int MagickClipImagePath(MemorySegment x0, MemorySegment x1, int x2) { + var mh$ = MagickClipImagePath.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageFilename", x0); + traceDowncall("MagickClipImagePath", x0, x1, x2); } - return (MemorySegment)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageFormat { + private static class MagickClutImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageFormat"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickClutImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4923,57 +19418,58 @@ private static class MagickGetImageFormat { /** * Function descriptor for: * {@snippet lang=c : - * extern char *MagickGetImageFormat(MagickWand *) + * extern MagickBooleanType MagickClutImage(MagickWand *, const MagickWand *, const PixelInterpolateMethod) * } */ - public static FunctionDescriptor MagickGetImageFormat$descriptor() { - return MagickGetImageFormat.DESC; + public static FunctionDescriptor MagickClutImage$descriptor() { + return MagickClutImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char *MagickGetImageFormat(MagickWand *) + * extern MagickBooleanType MagickClutImage(MagickWand *, const MagickWand *, const PixelInterpolateMethod) * } */ - public static MethodHandle MagickGetImageFormat$handle() { - return MagickGetImageFormat.HANDLE; + public static MethodHandle MagickClutImage$handle() { + return MagickClutImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char *MagickGetImageFormat(MagickWand *) + * extern MagickBooleanType MagickClutImage(MagickWand *, const MagickWand *, const PixelInterpolateMethod) * } */ - public static MemorySegment MagickGetImageFormat$address() { - return MagickGetImageFormat.ADDR; + public static MemorySegment MagickClutImage$address() { + return MagickClutImage.ADDR; } /** * {@snippet lang=c : - * extern char *MagickGetImageFormat(MagickWand *) + * extern MagickBooleanType MagickClutImage(MagickWand *, const MagickWand *, const PixelInterpolateMethod) * } */ - public static MemorySegment MagickGetImageFormat(MemorySegment x0) { - var mh$ = MagickGetImageFormat.HANDLE; + public static int MagickClutImage(MemorySegment x0, MemorySegment x1, int x2) { + var mh$ = MagickClutImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageFormat", x0); + traceDowncall("MagickClutImage", x0, x1, x2); } - return (MemorySegment)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageSignature { + private static class MagickColorDecisionListImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageSignature"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickColorDecisionListImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -4981,57 +19477,59 @@ private static class MagickGetImageSignature { /** * Function descriptor for: * {@snippet lang=c : - * extern char *MagickGetImageSignature(MagickWand *) + * extern MagickBooleanType MagickColorDecisionListImage(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickGetImageSignature$descriptor() { - return MagickGetImageSignature.DESC; + public static FunctionDescriptor MagickColorDecisionListImage$descriptor() { + return MagickColorDecisionListImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char *MagickGetImageSignature(MagickWand *) + * extern MagickBooleanType MagickColorDecisionListImage(MagickWand *, const char *) * } */ - public static MethodHandle MagickGetImageSignature$handle() { - return MagickGetImageSignature.HANDLE; + public static MethodHandle MagickColorDecisionListImage$handle() { + return MagickColorDecisionListImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char *MagickGetImageSignature(MagickWand *) + * extern MagickBooleanType MagickColorDecisionListImage(MagickWand *, const char *) * } */ - public static MemorySegment MagickGetImageSignature$address() { - return MagickGetImageSignature.ADDR; + public static MemorySegment MagickColorDecisionListImage$address() { + return MagickColorDecisionListImage.ADDR; } /** * {@snippet lang=c : - * extern char *MagickGetImageSignature(MagickWand *) + * extern MagickBooleanType MagickColorDecisionListImage(MagickWand *, const char *) * } */ - public static MemorySegment MagickGetImageSignature(MemorySegment x0) { - var mh$ = MagickGetImageSignature.HANDLE; + public static int MagickColorDecisionListImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickColorDecisionListImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageSignature", x0); + traceDowncall("MagickColorDecisionListImage", x0, x1); } - return (MemorySegment)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickIdentifyImage { + private static class MagickColorizeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickIdentifyImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickColorizeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5039,57 +19537,58 @@ private static class MagickIdentifyImage { /** * Function descriptor for: * {@snippet lang=c : - * extern char *MagickIdentifyImage(MagickWand *) + * extern MagickBooleanType MagickColorizeImage(MagickWand *, const PixelWand *, const PixelWand *) * } */ - public static FunctionDescriptor MagickIdentifyImage$descriptor() { - return MagickIdentifyImage.DESC; + public static FunctionDescriptor MagickColorizeImage$descriptor() { + return MagickColorizeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern char *MagickIdentifyImage(MagickWand *) + * extern MagickBooleanType MagickColorizeImage(MagickWand *, const PixelWand *, const PixelWand *) * } */ - public static MethodHandle MagickIdentifyImage$handle() { - return MagickIdentifyImage.HANDLE; + public static MethodHandle MagickColorizeImage$handle() { + return MagickColorizeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern char *MagickIdentifyImage(MagickWand *) + * extern MagickBooleanType MagickColorizeImage(MagickWand *, const PixelWand *, const PixelWand *) * } */ - public static MemorySegment MagickIdentifyImage$address() { - return MagickIdentifyImage.ADDR; + public static MemorySegment MagickColorizeImage$address() { + return MagickColorizeImage.ADDR; } /** * {@snippet lang=c : - * extern char *MagickIdentifyImage(MagickWand *) + * extern MagickBooleanType MagickColorizeImage(MagickWand *, const PixelWand *, const PixelWand *) * } */ - public static MemorySegment MagickIdentifyImage(MemorySegment x0) { - var mh$ = MagickIdentifyImage.HANDLE; + public static int MagickColorizeImage(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickColorizeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickIdentifyImage", x0); + traceDowncall("MagickColorizeImage", x0, x1, x2); } - return (MemorySegment)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageColorspace { + private static class MagickColorMatrixImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageColorspace"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickColorMatrixImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5097,57 +19596,59 @@ private static class MagickGetImageColorspace { /** * Function descriptor for: * {@snippet lang=c : - * extern ColorspaceType MagickGetImageColorspace(MagickWand *) + * extern MagickBooleanType MagickColorMatrixImage(MagickWand *, const KernelInfo *) * } */ - public static FunctionDescriptor MagickGetImageColorspace$descriptor() { - return MagickGetImageColorspace.DESC; + public static FunctionDescriptor MagickColorMatrixImage$descriptor() { + return MagickColorMatrixImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern ColorspaceType MagickGetImageColorspace(MagickWand *) + * extern MagickBooleanType MagickColorMatrixImage(MagickWand *, const KernelInfo *) * } */ - public static MethodHandle MagickGetImageColorspace$handle() { - return MagickGetImageColorspace.HANDLE; + public static MethodHandle MagickColorMatrixImage$handle() { + return MagickColorMatrixImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern ColorspaceType MagickGetImageColorspace(MagickWand *) + * extern MagickBooleanType MagickColorMatrixImage(MagickWand *, const KernelInfo *) * } */ - public static MemorySegment MagickGetImageColorspace$address() { - return MagickGetImageColorspace.ADDR; + public static MemorySegment MagickColorMatrixImage$address() { + return MagickColorMatrixImage.ADDR; } /** * {@snippet lang=c : - * extern ColorspaceType MagickGetImageColorspace(MagickWand *) + * extern MagickBooleanType MagickColorMatrixImage(MagickWand *, const KernelInfo *) * } */ - public static int MagickGetImageColorspace(MemorySegment x0) { - var mh$ = MagickGetImageColorspace.HANDLE; + public static int MagickColorMatrixImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickColorMatrixImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageColorspace", x0); + traceDowncall("MagickColorMatrixImage", x0, x1); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageCompose { + private static class MagickColorThresholdImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageCompose"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickColorThresholdImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5155,57 +19656,58 @@ private static class MagickGetImageCompose { /** * Function descriptor for: * {@snippet lang=c : - * extern CompositeOperator MagickGetImageCompose(MagickWand *) + * extern MagickBooleanType MagickColorThresholdImage(MagickWand *, const PixelWand *, const PixelWand *) * } */ - public static FunctionDescriptor MagickGetImageCompose$descriptor() { - return MagickGetImageCompose.DESC; + public static FunctionDescriptor MagickColorThresholdImage$descriptor() { + return MagickColorThresholdImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern CompositeOperator MagickGetImageCompose(MagickWand *) + * extern MagickBooleanType MagickColorThresholdImage(MagickWand *, const PixelWand *, const PixelWand *) * } */ - public static MethodHandle MagickGetImageCompose$handle() { - return MagickGetImageCompose.HANDLE; + public static MethodHandle MagickColorThresholdImage$handle() { + return MagickColorThresholdImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern CompositeOperator MagickGetImageCompose(MagickWand *) + * extern MagickBooleanType MagickColorThresholdImage(MagickWand *, const PixelWand *, const PixelWand *) * } */ - public static MemorySegment MagickGetImageCompose$address() { - return MagickGetImageCompose.ADDR; + public static MemorySegment MagickColorThresholdImage$address() { + return MagickColorThresholdImage.ADDR; } /** * {@snippet lang=c : - * extern CompositeOperator MagickGetImageCompose(MagickWand *) + * extern MagickBooleanType MagickColorThresholdImage(MagickWand *, const PixelWand *, const PixelWand *) * } */ - public static int MagickGetImageCompose(MemorySegment x0) { - var mh$ = MagickGetImageCompose.HANDLE; + public static int MagickColorThresholdImage(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickColorThresholdImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageCompose", x0); + traceDowncall("MagickColorThresholdImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageCompression { + private static class MagickCommentImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageCompression"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCommentImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5213,57 +19715,62 @@ private static class MagickGetImageCompression { /** * Function descriptor for: * {@snippet lang=c : - * extern CompressionType MagickGetImageCompression(MagickWand *) + * extern MagickBooleanType MagickCommentImage(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickGetImageCompression$descriptor() { - return MagickGetImageCompression.DESC; + public static FunctionDescriptor MagickCommentImage$descriptor() { + return MagickCommentImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern CompressionType MagickGetImageCompression(MagickWand *) + * extern MagickBooleanType MagickCommentImage(MagickWand *, const char *) * } */ - public static MethodHandle MagickGetImageCompression$handle() { - return MagickGetImageCompression.HANDLE; + public static MethodHandle MagickCommentImage$handle() { + return MagickCommentImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern CompressionType MagickGetImageCompression(MagickWand *) + * extern MagickBooleanType MagickCommentImage(MagickWand *, const char *) * } */ - public static MemorySegment MagickGetImageCompression$address() { - return MagickGetImageCompression.ADDR; + public static MemorySegment MagickCommentImage$address() { + return MagickCommentImage.ADDR; } /** * {@snippet lang=c : - * extern CompressionType MagickGetImageCompression(MagickWand *) + * extern MagickBooleanType MagickCommentImage(MagickWand *, const char *) * } */ - public static int MagickGetImageCompression(MemorySegment x0) { - var mh$ = MagickGetImageCompression.HANDLE; + public static int MagickCommentImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickCommentImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageCompression", x0); + traceDowncall("MagickCommentImage", x0, x1); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageDispose { + private static class MagickCompositeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_INT, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageDispose"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCompositeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5271,59 +19778,60 @@ private static class MagickGetImageDispose { /** * Function descriptor for: * {@snippet lang=c : - * extern DisposeType MagickGetImageDispose(MagickWand *) + * extern MagickBooleanType MagickCompositeImage(MagickWand *, const MagickWand *, const CompositeOperator, const MagickBooleanType, const ssize_t, const ssize_t) * } */ - public static FunctionDescriptor MagickGetImageDispose$descriptor() { - return MagickGetImageDispose.DESC; + public static FunctionDescriptor MagickCompositeImage$descriptor() { + return MagickCompositeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern DisposeType MagickGetImageDispose(MagickWand *) + * extern MagickBooleanType MagickCompositeImage(MagickWand *, const MagickWand *, const CompositeOperator, const MagickBooleanType, const ssize_t, const ssize_t) * } */ - public static MethodHandle MagickGetImageDispose$handle() { - return MagickGetImageDispose.HANDLE; + public static MethodHandle MagickCompositeImage$handle() { + return MagickCompositeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern DisposeType MagickGetImageDispose(MagickWand *) + * extern MagickBooleanType MagickCompositeImage(MagickWand *, const MagickWand *, const CompositeOperator, const MagickBooleanType, const ssize_t, const ssize_t) * } */ - public static MemorySegment MagickGetImageDispose$address() { - return MagickGetImageDispose.ADDR; + public static MemorySegment MagickCompositeImage$address() { + return MagickCompositeImage.ADDR; } /** * {@snippet lang=c : - * extern DisposeType MagickGetImageDispose(MagickWand *) + * extern MagickBooleanType MagickCompositeImage(MagickWand *, const MagickWand *, const CompositeOperator, const MagickBooleanType, const ssize_t, const ssize_t) * } */ - public static int MagickGetImageDispose(MemorySegment x0) { - var mh$ = MagickGetImageDispose.HANDLE; + public static int MagickCompositeImage(MemorySegment x0, MemorySegment x1, int x2, int x3, long x4, long x5) { + var mh$ = MagickCompositeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageDispose", x0); + traceDowncall("MagickCompositeImage", x0, x1, x2, x3, x4, x5); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageDistortions { + private static class MagickCompositeImageGravity { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageDistortions"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCompositeImageGravity"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5331,57 +19839,61 @@ private static class MagickGetImageDistortions { /** * Function descriptor for: * {@snippet lang=c : - * extern double *MagickGetImageDistortions(MagickWand *, const MagickWand *, const MetricType) + * extern MagickBooleanType MagickCompositeImageGravity(MagickWand *, const MagickWand *, const CompositeOperator, const GravityType) * } */ - public static FunctionDescriptor MagickGetImageDistortions$descriptor() { - return MagickGetImageDistortions.DESC; + public static FunctionDescriptor MagickCompositeImageGravity$descriptor() { + return MagickCompositeImageGravity.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern double *MagickGetImageDistortions(MagickWand *, const MagickWand *, const MetricType) + * extern MagickBooleanType MagickCompositeImageGravity(MagickWand *, const MagickWand *, const CompositeOperator, const GravityType) * } */ - public static MethodHandle MagickGetImageDistortions$handle() { - return MagickGetImageDistortions.HANDLE; + public static MethodHandle MagickCompositeImageGravity$handle() { + return MagickCompositeImageGravity.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern double *MagickGetImageDistortions(MagickWand *, const MagickWand *, const MetricType) + * extern MagickBooleanType MagickCompositeImageGravity(MagickWand *, const MagickWand *, const CompositeOperator, const GravityType) * } */ - public static MemorySegment MagickGetImageDistortions$address() { - return MagickGetImageDistortions.ADDR; + public static MemorySegment MagickCompositeImageGravity$address() { + return MagickCompositeImageGravity.ADDR; } /** * {@snippet lang=c : - * extern double *MagickGetImageDistortions(MagickWand *, const MagickWand *, const MetricType) + * extern MagickBooleanType MagickCompositeImageGravity(MagickWand *, const MagickWand *, const CompositeOperator, const GravityType) * } */ - public static MemorySegment MagickGetImageDistortions(MemorySegment x0, MemorySegment x1, int x2) { - var mh$ = MagickGetImageDistortions.HANDLE; + public static int MagickCompositeImageGravity(MemorySegment x0, MemorySegment x1, int x2, int x3) { + var mh$ = MagickCompositeImageGravity.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageDistortions", x0, x1, x2); + traceDowncall("MagickCompositeImageGravity", x0, x1, x2, x3); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageFuzz { + private static class MagickCompositeLayers { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_DOUBLE, - MagickWand_h.C_POINTER + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageFuzz"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCompositeLayers"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5389,57 +19901,59 @@ private static class MagickGetImageFuzz { /** * Function descriptor for: * {@snippet lang=c : - * extern double MagickGetImageFuzz(MagickWand *) + * extern MagickBooleanType MagickCompositeLayers(MagickWand *, const MagickWand *, const CompositeOperator, const ssize_t, const ssize_t) * } */ - public static FunctionDescriptor MagickGetImageFuzz$descriptor() { - return MagickGetImageFuzz.DESC; + public static FunctionDescriptor MagickCompositeLayers$descriptor() { + return MagickCompositeLayers.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern double MagickGetImageFuzz(MagickWand *) + * extern MagickBooleanType MagickCompositeLayers(MagickWand *, const MagickWand *, const CompositeOperator, const ssize_t, const ssize_t) * } */ - public static MethodHandle MagickGetImageFuzz$handle() { - return MagickGetImageFuzz.HANDLE; + public static MethodHandle MagickCompositeLayers$handle() { + return MagickCompositeLayers.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern double MagickGetImageFuzz(MagickWand *) + * extern MagickBooleanType MagickCompositeLayers(MagickWand *, const MagickWand *, const CompositeOperator, const ssize_t, const ssize_t) * } */ - public static MemorySegment MagickGetImageFuzz$address() { - return MagickGetImageFuzz.ADDR; + public static MemorySegment MagickCompositeLayers$address() { + return MagickCompositeLayers.ADDR; } /** * {@snippet lang=c : - * extern double MagickGetImageFuzz(MagickWand *) + * extern MagickBooleanType MagickCompositeLayers(MagickWand *, const MagickWand *, const CompositeOperator, const ssize_t, const ssize_t) * } */ - public static double MagickGetImageFuzz(MemorySegment x0) { - var mh$ = MagickGetImageFuzz.HANDLE; + public static int MagickCompositeLayers(MemorySegment x0, MemorySegment x1, int x2, long x3, long x4) { + var mh$ = MagickCompositeLayers.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageFuzz", x0); + traceDowncall("MagickCompositeLayers", x0, x1, x2, x3, x4); } - return (double)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageGamma { + private static class MagickConnectedComponentsImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_DOUBLE, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageGamma"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickConnectedComponentsImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5447,57 +19961,62 @@ private static class MagickGetImageGamma { /** * Function descriptor for: * {@snippet lang=c : - * extern double MagickGetImageGamma(MagickWand *) + * extern MagickBooleanType MagickConnectedComponentsImage(MagickWand *, const size_t, CCObjectInfo **) * } */ - public static FunctionDescriptor MagickGetImageGamma$descriptor() { - return MagickGetImageGamma.DESC; + public static FunctionDescriptor MagickConnectedComponentsImage$descriptor() { + return MagickConnectedComponentsImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern double MagickGetImageGamma(MagickWand *) + * extern MagickBooleanType MagickConnectedComponentsImage(MagickWand *, const size_t, CCObjectInfo **) * } */ - public static MethodHandle MagickGetImageGamma$handle() { - return MagickGetImageGamma.HANDLE; + public static MethodHandle MagickConnectedComponentsImage$handle() { + return MagickConnectedComponentsImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern double MagickGetImageGamma(MagickWand *) + * extern MagickBooleanType MagickConnectedComponentsImage(MagickWand *, const size_t, CCObjectInfo **) * } */ - public static MemorySegment MagickGetImageGamma$address() { - return MagickGetImageGamma.ADDR; + public static MemorySegment MagickConnectedComponentsImage$address() { + return MagickConnectedComponentsImage.ADDR; } /** * {@snippet lang=c : - * extern double MagickGetImageGamma(MagickWand *) + * extern MagickBooleanType MagickConnectedComponentsImage(MagickWand *, const size_t, CCObjectInfo **) * } */ - public static double MagickGetImageGamma(MemorySegment x0) { - var mh$ = MagickGetImageGamma.HANDLE; + public static int MagickConnectedComponentsImage(MemorySegment x0, long x1, MemorySegment x2) { + var mh$ = MagickConnectedComponentsImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageGamma", x0); + traceDowncall("MagickConnectedComponentsImage", x0, x1, x2); } - return (double)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageTotalInkDensity { + private static class MagickConstituteImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_DOUBLE, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageTotalInkDensity"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickConstituteImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5505,57 +20024,58 @@ private static class MagickGetImageTotalInkDensity { /** * Function descriptor for: * {@snippet lang=c : - * extern double MagickGetImageTotalInkDensity(MagickWand *) + * extern MagickBooleanType MagickConstituteImage(MagickWand *, const size_t, const size_t, const char *, const StorageType, const void *) * } */ - public static FunctionDescriptor MagickGetImageTotalInkDensity$descriptor() { - return MagickGetImageTotalInkDensity.DESC; + public static FunctionDescriptor MagickConstituteImage$descriptor() { + return MagickConstituteImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern double MagickGetImageTotalInkDensity(MagickWand *) + * extern MagickBooleanType MagickConstituteImage(MagickWand *, const size_t, const size_t, const char *, const StorageType, const void *) * } */ - public static MethodHandle MagickGetImageTotalInkDensity$handle() { - return MagickGetImageTotalInkDensity.HANDLE; + public static MethodHandle MagickConstituteImage$handle() { + return MagickConstituteImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern double MagickGetImageTotalInkDensity(MagickWand *) + * extern MagickBooleanType MagickConstituteImage(MagickWand *, const size_t, const size_t, const char *, const StorageType, const void *) * } */ - public static MemorySegment MagickGetImageTotalInkDensity$address() { - return MagickGetImageTotalInkDensity.ADDR; + public static MemorySegment MagickConstituteImage$address() { + return MagickConstituteImage.ADDR; } /** * {@snippet lang=c : - * extern double MagickGetImageTotalInkDensity(MagickWand *) + * extern MagickBooleanType MagickConstituteImage(MagickWand *, const size_t, const size_t, const char *, const StorageType, const void *) * } */ - public static double MagickGetImageTotalInkDensity(MemorySegment x0) { - var mh$ = MagickGetImageTotalInkDensity.HANDLE; + public static int MagickConstituteImage(MemorySegment x0, long x1, long x2, MemorySegment x3, int x4, MemorySegment x5) { + var mh$ = MagickConstituteImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageTotalInkDensity", x0); + traceDowncall("MagickConstituteImage", x0, x1, x2, x3, x4, x5); } - return (double)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageEndian { + private static class MagickContrastImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageEndian"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickContrastImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5563,57 +20083,59 @@ private static class MagickGetImageEndian { /** * Function descriptor for: * {@snippet lang=c : - * extern EndianType MagickGetImageEndian(MagickWand *) + * extern MagickBooleanType MagickContrastImage(MagickWand *, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickGetImageEndian$descriptor() { - return MagickGetImageEndian.DESC; + public static FunctionDescriptor MagickContrastImage$descriptor() { + return MagickContrastImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern EndianType MagickGetImageEndian(MagickWand *) + * extern MagickBooleanType MagickContrastImage(MagickWand *, const MagickBooleanType) * } */ - public static MethodHandle MagickGetImageEndian$handle() { - return MagickGetImageEndian.HANDLE; + public static MethodHandle MagickContrastImage$handle() { + return MagickContrastImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern EndianType MagickGetImageEndian(MagickWand *) + * extern MagickBooleanType MagickContrastImage(MagickWand *, const MagickBooleanType) * } */ - public static MemorySegment MagickGetImageEndian$address() { - return MagickGetImageEndian.ADDR; + public static MemorySegment MagickContrastImage$address() { + return MagickContrastImage.ADDR; } /** * {@snippet lang=c : - * extern EndianType MagickGetImageEndian(MagickWand *) + * extern MagickBooleanType MagickContrastImage(MagickWand *, const MagickBooleanType) * } */ - public static int MagickGetImageEndian(MemorySegment x0) { - var mh$ = MagickGetImageEndian.HANDLE; + public static int MagickContrastImage(MemorySegment x0, int x1) { + var mh$ = MagickContrastImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageEndian", x0); + traceDowncall("MagickContrastImage", x0, x1); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageFilter { + private static class MagickContrastStretchImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageFilter"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickContrastStretchImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5621,57 +20143,58 @@ private static class MagickGetImageFilter { /** * Function descriptor for: * {@snippet lang=c : - * extern FilterType MagickGetImageFilter(MagickWand *) + * extern MagickBooleanType MagickContrastStretchImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickGetImageFilter$descriptor() { - return MagickGetImageFilter.DESC; + public static FunctionDescriptor MagickContrastStretchImage$descriptor() { + return MagickContrastStretchImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern FilterType MagickGetImageFilter(MagickWand *) + * extern MagickBooleanType MagickContrastStretchImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickGetImageFilter$handle() { - return MagickGetImageFilter.HANDLE; + public static MethodHandle MagickContrastStretchImage$handle() { + return MagickContrastStretchImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern FilterType MagickGetImageFilter(MagickWand *) + * extern MagickBooleanType MagickContrastStretchImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickGetImageFilter$address() { - return MagickGetImageFilter.ADDR; + public static MemorySegment MagickContrastStretchImage$address() { + return MagickContrastStretchImage.ADDR; } /** * {@snippet lang=c : - * extern FilterType MagickGetImageFilter(MagickWand *) + * extern MagickBooleanType MagickContrastStretchImage(MagickWand *, const double, const double) * } */ - public static int MagickGetImageFilter(MemorySegment x0) { - var mh$ = MagickGetImageFilter.HANDLE; + public static int MagickContrastStretchImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickContrastStretchImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageFilter", x0); + traceDowncall("MagickContrastStretchImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageGravity { + private static class MagickConvolveImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageGravity"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickConvolveImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5679,57 +20202,61 @@ private static class MagickGetImageGravity { /** * Function descriptor for: * {@snippet lang=c : - * extern GravityType MagickGetImageGravity(MagickWand *) + * extern MagickBooleanType MagickConvolveImage(MagickWand *, const KernelInfo *) * } */ - public static FunctionDescriptor MagickGetImageGravity$descriptor() { - return MagickGetImageGravity.DESC; + public static FunctionDescriptor MagickConvolveImage$descriptor() { + return MagickConvolveImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern GravityType MagickGetImageGravity(MagickWand *) + * extern MagickBooleanType MagickConvolveImage(MagickWand *, const KernelInfo *) * } */ - public static MethodHandle MagickGetImageGravity$handle() { - return MagickGetImageGravity.HANDLE; + public static MethodHandle MagickConvolveImage$handle() { + return MagickConvolveImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern GravityType MagickGetImageGravity(MagickWand *) + * extern MagickBooleanType MagickConvolveImage(MagickWand *, const KernelInfo *) * } */ - public static MemorySegment MagickGetImageGravity$address() { - return MagickGetImageGravity.ADDR; + public static MemorySegment MagickConvolveImage$address() { + return MagickConvolveImage.ADDR; } /** * {@snippet lang=c : - * extern GravityType MagickGetImageGravity(MagickWand *) + * extern MagickBooleanType MagickConvolveImage(MagickWand *, const KernelInfo *) * } */ - public static int MagickGetImageGravity(MemorySegment x0) { - var mh$ = MagickGetImageGravity.HANDLE; + public static int MagickConvolveImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickConvolveImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageGravity", x0); + traceDowncall("MagickConvolveImage", x0, x1); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickDestroyImage { + private static class MagickCropImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDestroyImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCropImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5737,57 +20264,58 @@ private static class MagickDestroyImage { /** * Function descriptor for: * {@snippet lang=c : - * extern Image *MagickDestroyImage(Image *) + * extern MagickBooleanType MagickCropImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static FunctionDescriptor MagickDestroyImage$descriptor() { - return MagickDestroyImage.DESC; + public static FunctionDescriptor MagickCropImage$descriptor() { + return MagickCropImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern Image *MagickDestroyImage(Image *) + * extern MagickBooleanType MagickCropImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static MethodHandle MagickDestroyImage$handle() { - return MagickDestroyImage.HANDLE; + public static MethodHandle MagickCropImage$handle() { + return MagickCropImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern Image *MagickDestroyImage(Image *) + * extern MagickBooleanType MagickCropImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static MemorySegment MagickDestroyImage$address() { - return MagickDestroyImage.ADDR; + public static MemorySegment MagickCropImage$address() { + return MagickCropImage.ADDR; } /** * {@snippet lang=c : - * extern Image *MagickDestroyImage(Image *) + * extern MagickBooleanType MagickCropImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static MemorySegment MagickDestroyImage(MemorySegment x0) { - var mh$ = MagickDestroyImage.HANDLE; + public static int MagickCropImage(MemorySegment x0, long x1, long x2, long x3, long x4) { + var mh$ = MagickCropImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickDestroyImage", x0); + traceDowncall("MagickCropImage", x0, x1, x2, x3, x4); } - return (MemorySegment)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class GetImageFromMagickWand { + private static class MagickCycleColormapImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetImageFromMagickWand"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCycleColormapImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5795,57 +20323,58 @@ private static class GetImageFromMagickWand { /** * Function descriptor for: * {@snippet lang=c : - * extern Image *GetImageFromMagickWand(const MagickWand *) + * extern MagickBooleanType MagickCycleColormapImage(MagickWand *, const ssize_t) * } */ - public static FunctionDescriptor GetImageFromMagickWand$descriptor() { - return GetImageFromMagickWand.DESC; + public static FunctionDescriptor MagickCycleColormapImage$descriptor() { + return MagickCycleColormapImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern Image *GetImageFromMagickWand(const MagickWand *) + * extern MagickBooleanType MagickCycleColormapImage(MagickWand *, const ssize_t) * } */ - public static MethodHandle GetImageFromMagickWand$handle() { - return GetImageFromMagickWand.HANDLE; + public static MethodHandle MagickCycleColormapImage$handle() { + return MagickCycleColormapImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern Image *GetImageFromMagickWand(const MagickWand *) + * extern MagickBooleanType MagickCycleColormapImage(MagickWand *, const ssize_t) * } */ - public static MemorySegment GetImageFromMagickWand$address() { - return GetImageFromMagickWand.ADDR; + public static MemorySegment MagickCycleColormapImage$address() { + return MagickCycleColormapImage.ADDR; } /** * {@snippet lang=c : - * extern Image *GetImageFromMagickWand(const MagickWand *) + * extern MagickBooleanType MagickCycleColormapImage(MagickWand *, const ssize_t) * } */ - public static MemorySegment GetImageFromMagickWand(MemorySegment x0) { - var mh$ = GetImageFromMagickWand.HANDLE; + public static int MagickCycleColormapImage(MemorySegment x0, long x1) { + var mh$ = MagickCycleColormapImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("GetImageFromMagickWand", x0); + traceDowncall("MagickCycleColormapImage", x0, x1); } - return (MemorySegment)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageType { + private static class MagickDecipherImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageType"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDecipherImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5853,57 +20382,58 @@ private static class MagickGetImageType { /** * Function descriptor for: * {@snippet lang=c : - * extern ImageType MagickGetImageType(MagickWand *) + * extern MagickBooleanType MagickDecipherImage(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickGetImageType$descriptor() { - return MagickGetImageType.DESC; + public static FunctionDescriptor MagickDecipherImage$descriptor() { + return MagickDecipherImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern ImageType MagickGetImageType(MagickWand *) + * extern MagickBooleanType MagickDecipherImage(MagickWand *, const char *) * } */ - public static MethodHandle MagickGetImageType$handle() { - return MagickGetImageType.HANDLE; + public static MethodHandle MagickDecipherImage$handle() { + return MagickDecipherImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern ImageType MagickGetImageType(MagickWand *) + * extern MagickBooleanType MagickDecipherImage(MagickWand *, const char *) * } */ - public static MemorySegment MagickGetImageType$address() { - return MagickGetImageType.ADDR; + public static MemorySegment MagickDecipherImage$address() { + return MagickDecipherImage.ADDR; } /** * {@snippet lang=c : - * extern ImageType MagickGetImageType(MagickWand *) + * extern MagickBooleanType MagickDecipherImage(MagickWand *, const char *) * } */ - public static int MagickGetImageType(MemorySegment x0) { - var mh$ = MagickGetImageType.HANDLE; + public static int MagickDecipherImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickDecipherImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageType", x0); + traceDowncall("MagickDecipherImage", x0, x1); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickIdentifyImageType { + private static class MagickDeskewImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickIdentifyImageType"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDeskewImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5911,57 +20441,57 @@ private static class MagickIdentifyImageType { /** * Function descriptor for: * {@snippet lang=c : - * extern ImageType MagickIdentifyImageType(MagickWand *) + * extern MagickBooleanType MagickDeskewImage(MagickWand *, const double) * } */ - public static FunctionDescriptor MagickIdentifyImageType$descriptor() { - return MagickIdentifyImageType.DESC; + public static FunctionDescriptor MagickDeskewImage$descriptor() { + return MagickDeskewImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern ImageType MagickIdentifyImageType(MagickWand *) + * extern MagickBooleanType MagickDeskewImage(MagickWand *, const double) * } */ - public static MethodHandle MagickIdentifyImageType$handle() { - return MagickIdentifyImageType.HANDLE; + public static MethodHandle MagickDeskewImage$handle() { + return MagickDeskewImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern ImageType MagickIdentifyImageType(MagickWand *) + * extern MagickBooleanType MagickDeskewImage(MagickWand *, const double) * } */ - public static MemorySegment MagickIdentifyImageType$address() { - return MagickIdentifyImageType.ADDR; + public static MemorySegment MagickDeskewImage$address() { + return MagickDeskewImage.ADDR; } /** * {@snippet lang=c : - * extern ImageType MagickIdentifyImageType(MagickWand *) + * extern MagickBooleanType MagickDeskewImage(MagickWand *, const double) * } */ - public static int MagickIdentifyImageType(MemorySegment x0) { - var mh$ = MagickIdentifyImageType.HANDLE; + public static int MagickDeskewImage(MemorySegment x0, double x1) { + var mh$ = MagickDeskewImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickIdentifyImageType", x0); + traceDowncall("MagickDeskewImage", x0, x1); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageInterlaceScheme { + private static class MagickDespeckleImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageInterlaceScheme"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDespeckleImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -5969,43 +20499,43 @@ private static class MagickGetImageInterlaceScheme { /** * Function descriptor for: * {@snippet lang=c : - * extern InterlaceType MagickGetImageInterlaceScheme(MagickWand *) + * extern MagickBooleanType MagickDespeckleImage(MagickWand *) * } */ - public static FunctionDescriptor MagickGetImageInterlaceScheme$descriptor() { - return MagickGetImageInterlaceScheme.DESC; + public static FunctionDescriptor MagickDespeckleImage$descriptor() { + return MagickDespeckleImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern InterlaceType MagickGetImageInterlaceScheme(MagickWand *) + * extern MagickBooleanType MagickDespeckleImage(MagickWand *) * } */ - public static MethodHandle MagickGetImageInterlaceScheme$handle() { - return MagickGetImageInterlaceScheme.HANDLE; + public static MethodHandle MagickDespeckleImage$handle() { + return MagickDespeckleImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern InterlaceType MagickGetImageInterlaceScheme(MagickWand *) + * extern MagickBooleanType MagickDespeckleImage(MagickWand *) * } */ - public static MemorySegment MagickGetImageInterlaceScheme$address() { - return MagickGetImageInterlaceScheme.ADDR; + public static MemorySegment MagickDespeckleImage$address() { + return MagickDespeckleImage.ADDR; } /** * {@snippet lang=c : - * extern InterlaceType MagickGetImageInterlaceScheme(MagickWand *) + * extern MagickBooleanType MagickDespeckleImage(MagickWand *) * } */ - public static int MagickGetImageInterlaceScheme(MemorySegment x0) { - var mh$ = MagickGetImageInterlaceScheme.HANDLE; + public static int MagickDespeckleImage(MemorySegment x0) { + var mh$ = MagickDespeckleImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageInterlaceScheme", x0); + traceDowncall("MagickDespeckleImage", x0); } return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { @@ -6013,13 +20543,14 @@ public static int MagickGetImageInterlaceScheme(MemorySegment x0) { } } - private static class MagickGetImageInterpolateMethod { + private static class MagickDisplayImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageInterpolateMethod"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDisplayImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6027,59 +20558,58 @@ private static class MagickGetImageInterpolateMethod { /** * Function descriptor for: * {@snippet lang=c : - * extern PixelInterpolateMethod MagickGetImageInterpolateMethod(MagickWand *) + * extern MagickBooleanType MagickDisplayImage(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickGetImageInterpolateMethod$descriptor() { - return MagickGetImageInterpolateMethod.DESC; + public static FunctionDescriptor MagickDisplayImage$descriptor() { + return MagickDisplayImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern PixelInterpolateMethod MagickGetImageInterpolateMethod(MagickWand *) + * extern MagickBooleanType MagickDisplayImage(MagickWand *, const char *) * } */ - public static MethodHandle MagickGetImageInterpolateMethod$handle() { - return MagickGetImageInterpolateMethod.HANDLE; + public static MethodHandle MagickDisplayImage$handle() { + return MagickDisplayImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern PixelInterpolateMethod MagickGetImageInterpolateMethod(MagickWand *) + * extern MagickBooleanType MagickDisplayImage(MagickWand *, const char *) * } */ - public static MemorySegment MagickGetImageInterpolateMethod$address() { - return MagickGetImageInterpolateMethod.ADDR; + public static MemorySegment MagickDisplayImage$address() { + return MagickDisplayImage.ADDR; } /** * {@snippet lang=c : - * extern PixelInterpolateMethod MagickGetImageInterpolateMethod(MagickWand *) + * extern MagickBooleanType MagickDisplayImage(MagickWand *, const char *) * } */ - public static int MagickGetImageInterpolateMethod(MemorySegment x0) { - var mh$ = MagickGetImageInterpolateMethod.HANDLE; + public static int MagickDisplayImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickDisplayImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageInterpolateMethod", x0); + traceDowncall("MagickDisplayImage", x0, x1); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickAdaptiveBlurImage { + private static class MagickDisplayImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAdaptiveBlurImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDisplayImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6087,59 +20617,61 @@ private static class MagickAdaptiveBlurImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveBlurImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickDisplayImages(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickAdaptiveBlurImage$descriptor() { - return MagickAdaptiveBlurImage.DESC; + public static FunctionDescriptor MagickDisplayImages$descriptor() { + return MagickDisplayImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveBlurImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickDisplayImages(MagickWand *, const char *) * } */ - public static MethodHandle MagickAdaptiveBlurImage$handle() { - return MagickAdaptiveBlurImage.HANDLE; + public static MethodHandle MagickDisplayImages$handle() { + return MagickDisplayImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveBlurImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickDisplayImages(MagickWand *, const char *) * } */ - public static MemorySegment MagickAdaptiveBlurImage$address() { - return MagickAdaptiveBlurImage.ADDR; + public static MemorySegment MagickDisplayImages$address() { + return MagickDisplayImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveBlurImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickDisplayImages(MagickWand *, const char *) * } */ - public static int MagickAdaptiveBlurImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickAdaptiveBlurImage.HANDLE; + public static int MagickDisplayImages(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickDisplayImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickAdaptiveBlurImage", x0, x1, x2); + traceDowncall("MagickDisplayImages", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickAdaptiveResizeImage { + private static class MagickDistortImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAdaptiveResizeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDistortImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6147,59 +20679,58 @@ private static class MagickAdaptiveResizeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveResizeImage(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickDistortImage(MagickWand *, const DistortMethod, const size_t, const double *, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickAdaptiveResizeImage$descriptor() { - return MagickAdaptiveResizeImage.DESC; + public static FunctionDescriptor MagickDistortImage$descriptor() { + return MagickDistortImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveResizeImage(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickDistortImage(MagickWand *, const DistortMethod, const size_t, const double *, const MagickBooleanType) * } */ - public static MethodHandle MagickAdaptiveResizeImage$handle() { - return MagickAdaptiveResizeImage.HANDLE; + public static MethodHandle MagickDistortImage$handle() { + return MagickDistortImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveResizeImage(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickDistortImage(MagickWand *, const DistortMethod, const size_t, const double *, const MagickBooleanType) * } */ - public static MemorySegment MagickAdaptiveResizeImage$address() { - return MagickAdaptiveResizeImage.ADDR; + public static MemorySegment MagickDistortImage$address() { + return MagickDistortImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveResizeImage(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickDistortImage(MagickWand *, const DistortMethod, const size_t, const double *, const MagickBooleanType) * } */ - public static int MagickAdaptiveResizeImage(MemorySegment x0, long x1, long x2) { - var mh$ = MagickAdaptiveResizeImage.HANDLE; + public static int MagickDistortImage(MemorySegment x0, int x1, long x2, MemorySegment x3, int x4) { + var mh$ = MagickDistortImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickAdaptiveResizeImage", x0, x1, x2); + traceDowncall("MagickDistortImage", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickAdaptiveSharpenImage { + private static class MagickDrawImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAdaptiveSharpenImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDrawImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6207,60 +20738,58 @@ private static class MagickAdaptiveSharpenImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveSharpenImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickDrawImage(MagickWand *, const DrawingWand *) * } */ - public static FunctionDescriptor MagickAdaptiveSharpenImage$descriptor() { - return MagickAdaptiveSharpenImage.DESC; + public static FunctionDescriptor MagickDrawImage$descriptor() { + return MagickDrawImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveSharpenImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickDrawImage(MagickWand *, const DrawingWand *) * } */ - public static MethodHandle MagickAdaptiveSharpenImage$handle() { - return MagickAdaptiveSharpenImage.HANDLE; + public static MethodHandle MagickDrawImage$handle() { + return MagickDrawImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveSharpenImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickDrawImage(MagickWand *, const DrawingWand *) * } */ - public static MemorySegment MagickAdaptiveSharpenImage$address() { - return MagickAdaptiveSharpenImage.ADDR; + public static MemorySegment MagickDrawImage$address() { + return MagickDrawImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveSharpenImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickDrawImage(MagickWand *, const DrawingWand *) * } */ - public static int MagickAdaptiveSharpenImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickAdaptiveSharpenImage.HANDLE; + public static int MagickDrawImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickDrawImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickAdaptiveSharpenImage", x0, x1, x2); + traceDowncall("MagickDrawImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickAdaptiveThresholdImage { + private static class MagickEdgeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAdaptiveThresholdImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickEdgeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6268,58 +20797,59 @@ private static class MagickAdaptiveThresholdImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveThresholdImage(MagickWand *, const size_t, const size_t, const double) + * extern MagickBooleanType MagickEdgeImage(MagickWand *, const double) * } */ - public static FunctionDescriptor MagickAdaptiveThresholdImage$descriptor() { - return MagickAdaptiveThresholdImage.DESC; + public static FunctionDescriptor MagickEdgeImage$descriptor() { + return MagickEdgeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveThresholdImage(MagickWand *, const size_t, const size_t, const double) + * extern MagickBooleanType MagickEdgeImage(MagickWand *, const double) * } */ - public static MethodHandle MagickAdaptiveThresholdImage$handle() { - return MagickAdaptiveThresholdImage.HANDLE; + public static MethodHandle MagickEdgeImage$handle() { + return MagickEdgeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveThresholdImage(MagickWand *, const size_t, const size_t, const double) + * extern MagickBooleanType MagickEdgeImage(MagickWand *, const double) * } */ - public static MemorySegment MagickAdaptiveThresholdImage$address() { - return MagickAdaptiveThresholdImage.ADDR; + public static MemorySegment MagickEdgeImage$address() { + return MagickEdgeImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickAdaptiveThresholdImage(MagickWand *, const size_t, const size_t, const double) + * extern MagickBooleanType MagickEdgeImage(MagickWand *, const double) * } */ - public static int MagickAdaptiveThresholdImage(MemorySegment x0, long x1, long x2, double x3) { - var mh$ = MagickAdaptiveThresholdImage.HANDLE; + public static int MagickEdgeImage(MemorySegment x0, double x1) { + var mh$ = MagickEdgeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickAdaptiveThresholdImage", x0, x1, x2, x3); + traceDowncall("MagickEdgeImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickAddImage { + private static class MagickEmbossImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAddImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickEmbossImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6327,59 +20857,58 @@ private static class MagickAddImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickAddImage(MagickWand *, const MagickWand *) + * extern MagickBooleanType MagickEmbossImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickAddImage$descriptor() { - return MagickAddImage.DESC; + public static FunctionDescriptor MagickEmbossImage$descriptor() { + return MagickEmbossImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickAddImage(MagickWand *, const MagickWand *) + * extern MagickBooleanType MagickEmbossImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickAddImage$handle() { - return MagickAddImage.HANDLE; + public static MethodHandle MagickEmbossImage$handle() { + return MagickEmbossImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickAddImage(MagickWand *, const MagickWand *) + * extern MagickBooleanType MagickEmbossImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickAddImage$address() { - return MagickAddImage.ADDR; + public static MemorySegment MagickEmbossImage$address() { + return MagickEmbossImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickAddImage(MagickWand *, const MagickWand *) + * extern MagickBooleanType MagickEmbossImage(MagickWand *, const double, const double) * } */ - public static int MagickAddImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickAddImage.HANDLE; + public static int MagickEmbossImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickEmbossImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickAddImage", x0, x1); + traceDowncall("MagickEmbossImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickAddNoiseImage { + private static class MagickEncipherImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAddNoiseImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickEncipherImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6387,58 +20916,57 @@ private static class MagickAddNoiseImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickAddNoiseImage(MagickWand *, const NoiseType, const double) + * extern MagickBooleanType MagickEncipherImage(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickAddNoiseImage$descriptor() { - return MagickAddNoiseImage.DESC; + public static FunctionDescriptor MagickEncipherImage$descriptor() { + return MagickEncipherImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickAddNoiseImage(MagickWand *, const NoiseType, const double) + * extern MagickBooleanType MagickEncipherImage(MagickWand *, const char *) * } */ - public static MethodHandle MagickAddNoiseImage$handle() { - return MagickAddNoiseImage.HANDLE; + public static MethodHandle MagickEncipherImage$handle() { + return MagickEncipherImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickAddNoiseImage(MagickWand *, const NoiseType, const double) + * extern MagickBooleanType MagickEncipherImage(MagickWand *, const char *) * } */ - public static MemorySegment MagickAddNoiseImage$address() { - return MagickAddNoiseImage.ADDR; + public static MemorySegment MagickEncipherImage$address() { + return MagickEncipherImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickAddNoiseImage(MagickWand *, const NoiseType, const double) + * extern MagickBooleanType MagickEncipherImage(MagickWand *, const char *) * } */ - public static int MagickAddNoiseImage(MemorySegment x0, int x1, double x2) { - var mh$ = MagickAddNoiseImage.HANDLE; + public static int MagickEncipherImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickEncipherImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickAddNoiseImage", x0, x1, x2); + traceDowncall("MagickEncipherImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickAffineTransformImage { + private static class MagickEnhanceImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAffineTransformImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickEnhanceImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6446,62 +20974,57 @@ private static class MagickAffineTransformImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickAffineTransformImage(MagickWand *, const DrawingWand *) + * extern MagickBooleanType MagickEnhanceImage(MagickWand *) * } */ - public static FunctionDescriptor MagickAffineTransformImage$descriptor() { - return MagickAffineTransformImage.DESC; + public static FunctionDescriptor MagickEnhanceImage$descriptor() { + return MagickEnhanceImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickAffineTransformImage(MagickWand *, const DrawingWand *) + * extern MagickBooleanType MagickEnhanceImage(MagickWand *) * } */ - public static MethodHandle MagickAffineTransformImage$handle() { - return MagickAffineTransformImage.HANDLE; + public static MethodHandle MagickEnhanceImage$handle() { + return MagickEnhanceImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickAffineTransformImage(MagickWand *, const DrawingWand *) + * extern MagickBooleanType MagickEnhanceImage(MagickWand *) * } */ - public static MemorySegment MagickAffineTransformImage$address() { - return MagickAffineTransformImage.ADDR; + public static MemorySegment MagickEnhanceImage$address() { + return MagickEnhanceImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickAffineTransformImage(MagickWand *, const DrawingWand *) + * extern MagickBooleanType MagickEnhanceImage(MagickWand *) * } */ - public static int MagickAffineTransformImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickAffineTransformImage.HANDLE; + public static int MagickEnhanceImage(MemorySegment x0) { + var mh$ = MagickEnhanceImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickAffineTransformImage", x0, x1); + traceDowncall("MagickEnhanceImage", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickAnnotateImage { + private static class MagickEqualizeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAnnotateImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickEqualizeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6509,58 +21032,59 @@ private static class MagickAnnotateImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickAnnotateImage(MagickWand *, const DrawingWand *, const double, const double, const double, const char *) + * extern MagickBooleanType MagickEqualizeImage(MagickWand *) * } */ - public static FunctionDescriptor MagickAnnotateImage$descriptor() { - return MagickAnnotateImage.DESC; + public static FunctionDescriptor MagickEqualizeImage$descriptor() { + return MagickEqualizeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickAnnotateImage(MagickWand *, const DrawingWand *, const double, const double, const double, const char *) + * extern MagickBooleanType MagickEqualizeImage(MagickWand *) * } */ - public static MethodHandle MagickAnnotateImage$handle() { - return MagickAnnotateImage.HANDLE; + public static MethodHandle MagickEqualizeImage$handle() { + return MagickEqualizeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickAnnotateImage(MagickWand *, const DrawingWand *, const double, const double, const double, const char *) + * extern MagickBooleanType MagickEqualizeImage(MagickWand *) * } */ - public static MemorySegment MagickAnnotateImage$address() { - return MagickAnnotateImage.ADDR; + public static MemorySegment MagickEqualizeImage$address() { + return MagickEqualizeImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickAnnotateImage(MagickWand *, const DrawingWand *, const double, const double, const double, const char *) + * extern MagickBooleanType MagickEqualizeImage(MagickWand *) * } */ - public static int MagickAnnotateImage(MemorySegment x0, MemorySegment x1, double x2, double x3, double x4, MemorySegment x5) { - var mh$ = MagickAnnotateImage.HANDLE; + public static int MagickEqualizeImage(MemorySegment x0) { + var mh$ = MagickEqualizeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickAnnotateImage", x0, x1, x2, x3, x4, x5); + traceDowncall("MagickEqualizeImage", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickAnimateImages { + private static class MagickEvaluateImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_INT, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAnimateImages"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickEvaluateImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6568,57 +21092,64 @@ private static class MagickAnimateImages { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickAnimateImages(MagickWand *, const char *) + * extern MagickBooleanType MagickEvaluateImage(MagickWand *, const MagickEvaluateOperator, const double) * } */ - public static FunctionDescriptor MagickAnimateImages$descriptor() { - return MagickAnimateImages.DESC; + public static FunctionDescriptor MagickEvaluateImage$descriptor() { + return MagickEvaluateImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickAnimateImages(MagickWand *, const char *) + * extern MagickBooleanType MagickEvaluateImage(MagickWand *, const MagickEvaluateOperator, const double) * } */ - public static MethodHandle MagickAnimateImages$handle() { - return MagickAnimateImages.HANDLE; + public static MethodHandle MagickEvaluateImage$handle() { + return MagickEvaluateImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickAnimateImages(MagickWand *, const char *) + * extern MagickBooleanType MagickEvaluateImage(MagickWand *, const MagickEvaluateOperator, const double) * } */ - public static MemorySegment MagickAnimateImages$address() { - return MagickAnimateImages.ADDR; + public static MemorySegment MagickEvaluateImage$address() { + return MagickEvaluateImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickAnimateImages(MagickWand *, const char *) + * extern MagickBooleanType MagickEvaluateImage(MagickWand *, const MagickEvaluateOperator, const double) * } */ - public static int MagickAnimateImages(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickAnimateImages.HANDLE; + public static int MagickEvaluateImage(MemorySegment x0, int x1, double x2) { + var mh$ = MagickEvaluateImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickAnimateImages", x0, x1); + traceDowncall("MagickEvaluateImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickAutoGammaImage { + private static class MagickExportImagePixels { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER, MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAutoGammaImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickExportImagePixels"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6626,57 +21157,61 @@ private static class MagickAutoGammaImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickAutoGammaImage(MagickWand *) + * extern MagickBooleanType MagickExportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, void *) * } */ - public static FunctionDescriptor MagickAutoGammaImage$descriptor() { - return MagickAutoGammaImage.DESC; + public static FunctionDescriptor MagickExportImagePixels$descriptor() { + return MagickExportImagePixels.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickAutoGammaImage(MagickWand *) + * extern MagickBooleanType MagickExportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, void *) * } */ - public static MethodHandle MagickAutoGammaImage$handle() { - return MagickAutoGammaImage.HANDLE; + public static MethodHandle MagickExportImagePixels$handle() { + return MagickExportImagePixels.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickAutoGammaImage(MagickWand *) + * extern MagickBooleanType MagickExportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, void *) * } */ - public static MemorySegment MagickAutoGammaImage$address() { - return MagickAutoGammaImage.ADDR; + public static MemorySegment MagickExportImagePixels$address() { + return MagickExportImagePixels.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickAutoGammaImage(MagickWand *) + * extern MagickBooleanType MagickExportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, void *) * } */ - public static int MagickAutoGammaImage(MemorySegment x0) { - var mh$ = MagickAutoGammaImage.HANDLE; + public static int MagickExportImagePixels(MemorySegment x0, long x1, long x2, long x3, long x4, MemorySegment x5, int x6, MemorySegment x7) { + var mh$ = MagickExportImagePixels.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickAutoGammaImage", x0); + traceDowncall("MagickExportImagePixels", x0, x1, x2, x3, x4, x5, x6, x7); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5, x6, x7); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickAutoLevelImage { + private static class MagickExtentImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAutoLevelImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickExtentImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6684,57 +21219,57 @@ private static class MagickAutoLevelImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickAutoLevelImage(MagickWand *) + * extern MagickBooleanType MagickExtentImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static FunctionDescriptor MagickAutoLevelImage$descriptor() { - return MagickAutoLevelImage.DESC; + public static FunctionDescriptor MagickExtentImage$descriptor() { + return MagickExtentImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickAutoLevelImage(MagickWand *) + * extern MagickBooleanType MagickExtentImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static MethodHandle MagickAutoLevelImage$handle() { - return MagickAutoLevelImage.HANDLE; + public static MethodHandle MagickExtentImage$handle() { + return MagickExtentImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickAutoLevelImage(MagickWand *) + * extern MagickBooleanType MagickExtentImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static MemorySegment MagickAutoLevelImage$address() { - return MagickAutoLevelImage.ADDR; + public static MemorySegment MagickExtentImage$address() { + return MagickExtentImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickAutoLevelImage(MagickWand *) + * extern MagickBooleanType MagickExtentImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static int MagickAutoLevelImage(MemorySegment x0) { - var mh$ = MagickAutoLevelImage.HANDLE; + public static int MagickExtentImage(MemorySegment x0, long x1, long x2, long x3, long x4) { + var mh$ = MagickExtentImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickAutoLevelImage", x0); + traceDowncall("MagickExtentImage", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickAutoOrientImage { + private static class MagickFlipImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAutoOrientImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickFlipImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6742,43 +21277,43 @@ private static class MagickAutoOrientImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickAutoOrientImage(MagickWand *) + * extern MagickBooleanType MagickFlipImage(MagickWand *) * } */ - public static FunctionDescriptor MagickAutoOrientImage$descriptor() { - return MagickAutoOrientImage.DESC; + public static FunctionDescriptor MagickFlipImage$descriptor() { + return MagickFlipImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickAutoOrientImage(MagickWand *) + * extern MagickBooleanType MagickFlipImage(MagickWand *) * } */ - public static MethodHandle MagickAutoOrientImage$handle() { - return MagickAutoOrientImage.HANDLE; + public static MethodHandle MagickFlipImage$handle() { + return MagickFlipImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickAutoOrientImage(MagickWand *) + * extern MagickBooleanType MagickFlipImage(MagickWand *) * } */ - public static MemorySegment MagickAutoOrientImage$address() { - return MagickAutoOrientImage.ADDR; + public static MemorySegment MagickFlipImage$address() { + return MagickFlipImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickAutoOrientImage(MagickWand *) + * extern MagickBooleanType MagickFlipImage(MagickWand *) * } */ - public static int MagickAutoOrientImage(MemorySegment x0) { - var mh$ = MagickAutoOrientImage.HANDLE; + public static int MagickFlipImage(MemorySegment x0) { + var mh$ = MagickFlipImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickAutoOrientImage", x0); + traceDowncall("MagickFlipImage", x0); } return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { @@ -6786,14 +21321,19 @@ public static int MagickAutoOrientImage(MemorySegment x0) { } } - private static class MagickAutoThresholdImage { + private static class MagickFloodfillPaintImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAutoThresholdImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickFloodfillPaintImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6801,61 +21341,57 @@ private static class MagickAutoThresholdImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickAutoThresholdImage(MagickWand *, const AutoThresholdMethod) + * extern MagickBooleanType MagickFloodfillPaintImage(MagickWand *, const PixelWand *, const double, const PixelWand *, const ssize_t, const ssize_t, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickAutoThresholdImage$descriptor() { - return MagickAutoThresholdImage.DESC; + public static FunctionDescriptor MagickFloodfillPaintImage$descriptor() { + return MagickFloodfillPaintImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickAutoThresholdImage(MagickWand *, const AutoThresholdMethod) + * extern MagickBooleanType MagickFloodfillPaintImage(MagickWand *, const PixelWand *, const double, const PixelWand *, const ssize_t, const ssize_t, const MagickBooleanType) * } */ - public static MethodHandle MagickAutoThresholdImage$handle() { - return MagickAutoThresholdImage.HANDLE; + public static MethodHandle MagickFloodfillPaintImage$handle() { + return MagickFloodfillPaintImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickAutoThresholdImage(MagickWand *, const AutoThresholdMethod) + * extern MagickBooleanType MagickFloodfillPaintImage(MagickWand *, const PixelWand *, const double, const PixelWand *, const ssize_t, const ssize_t, const MagickBooleanType) * } */ - public static MemorySegment MagickAutoThresholdImage$address() { - return MagickAutoThresholdImage.ADDR; + public static MemorySegment MagickFloodfillPaintImage$address() { + return MagickFloodfillPaintImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickAutoThresholdImage(MagickWand *, const AutoThresholdMethod) + * extern MagickBooleanType MagickFloodfillPaintImage(MagickWand *, const PixelWand *, const double, const PixelWand *, const ssize_t, const ssize_t, const MagickBooleanType) * } */ - public static int MagickAutoThresholdImage(MemorySegment x0, int x1) { - var mh$ = MagickAutoThresholdImage.HANDLE; + public static int MagickFloodfillPaintImage(MemorySegment x0, MemorySegment x1, double x2, MemorySegment x3, long x4, long x5, int x6) { + var mh$ = MagickFloodfillPaintImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickAutoThresholdImage", x0, x1); + traceDowncall("MagickFloodfillPaintImage", x0, x1, x2, x3, x4, x5, x6); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5, x6); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickBilateralBlurImage { + private static class MagickFlopImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickBilateralBlurImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickFlopImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6863,58 +21399,58 @@ private static class MagickBilateralBlurImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickBilateralBlurImage(MagickWand *, const double, const double, const double, const double) + * extern MagickBooleanType MagickFlopImage(MagickWand *) * } */ - public static FunctionDescriptor MagickBilateralBlurImage$descriptor() { - return MagickBilateralBlurImage.DESC; + public static FunctionDescriptor MagickFlopImage$descriptor() { + return MagickFlopImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickBilateralBlurImage(MagickWand *, const double, const double, const double, const double) + * extern MagickBooleanType MagickFlopImage(MagickWand *) * } */ - public static MethodHandle MagickBilateralBlurImage$handle() { - return MagickBilateralBlurImage.HANDLE; + public static MethodHandle MagickFlopImage$handle() { + return MagickFlopImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickBilateralBlurImage(MagickWand *, const double, const double, const double, const double) + * extern MagickBooleanType MagickFlopImage(MagickWand *) * } */ - public static MemorySegment MagickBilateralBlurImage$address() { - return MagickBilateralBlurImage.ADDR; + public static MemorySegment MagickFlopImage$address() { + return MagickFlopImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickBilateralBlurImage(MagickWand *, const double, const double, const double, const double) + * extern MagickBooleanType MagickFlopImage(MagickWand *) * } */ - public static int MagickBilateralBlurImage(MemorySegment x0, double x1, double x2, double x3, double x4) { - var mh$ = MagickBilateralBlurImage.HANDLE; + public static int MagickFlopImage(MemorySegment x0) { + var mh$ = MagickFlopImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickBilateralBlurImage", x0, x1, x2, x3, x4); + traceDowncall("MagickFlopImage", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickBlackThresholdImage { + private static class MagickForwardFourierTransformImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickBlackThresholdImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickForwardFourierTransformImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6922,43 +21458,43 @@ private static class MagickBlackThresholdImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickBlackThresholdImage(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickForwardFourierTransformImage(MagickWand *, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickBlackThresholdImage$descriptor() { - return MagickBlackThresholdImage.DESC; + public static FunctionDescriptor MagickForwardFourierTransformImage$descriptor() { + return MagickForwardFourierTransformImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickBlackThresholdImage(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickForwardFourierTransformImage(MagickWand *, const MagickBooleanType) * } */ - public static MethodHandle MagickBlackThresholdImage$handle() { - return MagickBlackThresholdImage.HANDLE; + public static MethodHandle MagickForwardFourierTransformImage$handle() { + return MagickForwardFourierTransformImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickBlackThresholdImage(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickForwardFourierTransformImage(MagickWand *, const MagickBooleanType) * } */ - public static MemorySegment MagickBlackThresholdImage$address() { - return MagickBlackThresholdImage.ADDR; + public static MemorySegment MagickForwardFourierTransformImage$address() { + return MagickForwardFourierTransformImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickBlackThresholdImage(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickForwardFourierTransformImage(MagickWand *, const MagickBooleanType) * } */ - public static int MagickBlackThresholdImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickBlackThresholdImage.HANDLE; + public static int MagickForwardFourierTransformImage(MemorySegment x0, int x1) { + var mh$ = MagickForwardFourierTransformImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickBlackThresholdImage", x0, x1); + traceDowncall("MagickForwardFourierTransformImage", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -6966,14 +21502,19 @@ public static int MagickBlackThresholdImage(MemorySegment x0, MemorySegment x1) } } - private static class MagickBlueShiftImage { + private static class MagickFrameImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickBlueShiftImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickFrameImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -6981,59 +21522,60 @@ private static class MagickBlueShiftImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickBlueShiftImage(MagickWand *, const double) + * extern MagickBooleanType MagickFrameImage(MagickWand *, const PixelWand *, const size_t, const size_t, const ssize_t, const ssize_t, const CompositeOperator) * } */ - public static FunctionDescriptor MagickBlueShiftImage$descriptor() { - return MagickBlueShiftImage.DESC; + public static FunctionDescriptor MagickFrameImage$descriptor() { + return MagickFrameImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickBlueShiftImage(MagickWand *, const double) + * extern MagickBooleanType MagickFrameImage(MagickWand *, const PixelWand *, const size_t, const size_t, const ssize_t, const ssize_t, const CompositeOperator) * } */ - public static MethodHandle MagickBlueShiftImage$handle() { - return MagickBlueShiftImage.HANDLE; + public static MethodHandle MagickFrameImage$handle() { + return MagickFrameImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickBlueShiftImage(MagickWand *, const double) + * extern MagickBooleanType MagickFrameImage(MagickWand *, const PixelWand *, const size_t, const size_t, const ssize_t, const ssize_t, const CompositeOperator) * } */ - public static MemorySegment MagickBlueShiftImage$address() { - return MagickBlueShiftImage.ADDR; + public static MemorySegment MagickFrameImage$address() { + return MagickFrameImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickBlueShiftImage(MagickWand *, const double) + * extern MagickBooleanType MagickFrameImage(MagickWand *, const PixelWand *, const size_t, const size_t, const ssize_t, const ssize_t, const CompositeOperator) * } */ - public static int MagickBlueShiftImage(MemorySegment x0, double x1) { - var mh$ = MagickBlueShiftImage.HANDLE; + public static int MagickFrameImage(MemorySegment x0, MemorySegment x1, long x2, long x3, long x4, long x5, int x6) { + var mh$ = MagickFrameImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickBlueShiftImage", x0, x1); + traceDowncall("MagickFrameImage", x0, x1, x2, x3, x4, x5, x6); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5, x6); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickBlurImage { + private static class MagickFunctionImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_INT, + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickBlurImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickFunctionImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7041,61 +21583,58 @@ private static class MagickBlurImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickBlurImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickFunctionImage(MagickWand *, const MagickFunction, const size_t, const double *) * } */ - public static FunctionDescriptor MagickBlurImage$descriptor() { - return MagickBlurImage.DESC; + public static FunctionDescriptor MagickFunctionImage$descriptor() { + return MagickFunctionImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickBlurImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickFunctionImage(MagickWand *, const MagickFunction, const size_t, const double *) * } */ - public static MethodHandle MagickBlurImage$handle() { - return MagickBlurImage.HANDLE; + public static MethodHandle MagickFunctionImage$handle() { + return MagickFunctionImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickBlurImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickFunctionImage(MagickWand *, const MagickFunction, const size_t, const double *) * } */ - public static MemorySegment MagickBlurImage$address() { - return MagickBlurImage.ADDR; + public static MemorySegment MagickFunctionImage$address() { + return MagickFunctionImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickBlurImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickFunctionImage(MagickWand *, const MagickFunction, const size_t, const double *) * } */ - public static int MagickBlurImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickBlurImage.HANDLE; + public static int MagickFunctionImage(MemorySegment x0, int x1, long x2, MemorySegment x3) { + var mh$ = MagickFunctionImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickBlurImage", x0, x1, x2); + traceDowncall("MagickFunctionImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickBorderImage { + private static class MagickGammaImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_INT + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickBorderImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGammaImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7103,51 +21642,51 @@ private static class MagickBorderImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickBorderImage(MagickWand *, const PixelWand *, const size_t, const size_t, const CompositeOperator compose) + * extern MagickBooleanType MagickGammaImage(MagickWand *, const double) * } */ - public static FunctionDescriptor MagickBorderImage$descriptor() { - return MagickBorderImage.DESC; + public static FunctionDescriptor MagickGammaImage$descriptor() { + return MagickGammaImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickBorderImage(MagickWand *, const PixelWand *, const size_t, const size_t, const CompositeOperator compose) + * extern MagickBooleanType MagickGammaImage(MagickWand *, const double) * } */ - public static MethodHandle MagickBorderImage$handle() { - return MagickBorderImage.HANDLE; + public static MethodHandle MagickGammaImage$handle() { + return MagickGammaImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickBorderImage(MagickWand *, const PixelWand *, const size_t, const size_t, const CompositeOperator compose) + * extern MagickBooleanType MagickGammaImage(MagickWand *, const double) * } */ - public static MemorySegment MagickBorderImage$address() { - return MagickBorderImage.ADDR; + public static MemorySegment MagickGammaImage$address() { + return MagickGammaImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickBorderImage(MagickWand *, const PixelWand *, const size_t, const size_t, const CompositeOperator compose) + * extern MagickBooleanType MagickGammaImage(MagickWand *, const double) * } */ - public static int MagickBorderImage(MemorySegment x0, MemorySegment x1, long x2, long x3, int compose) { - var mh$ = MagickBorderImage.HANDLE; + public static int MagickGammaImage(MemorySegment x0, double x1) { + var mh$ = MagickGammaImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickBorderImage", x0, x1, x2, x3, compose); + traceDowncall("MagickGammaImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3, compose); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickBrightnessContrastImage { + private static class MagickGaussianBlurImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, @@ -7155,7 +21694,7 @@ private static class MagickBrightnessContrastImage { MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickBrightnessContrastImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGaussianBlurImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7163,43 +21702,43 @@ private static class MagickBrightnessContrastImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickBrightnessContrastImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickGaussianBlurImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickBrightnessContrastImage$descriptor() { - return MagickBrightnessContrastImage.DESC; + public static FunctionDescriptor MagickGaussianBlurImage$descriptor() { + return MagickGaussianBlurImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickBrightnessContrastImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickGaussianBlurImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickBrightnessContrastImage$handle() { - return MagickBrightnessContrastImage.HANDLE; + public static MethodHandle MagickGaussianBlurImage$handle() { + return MagickGaussianBlurImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickBrightnessContrastImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickGaussianBlurImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickBrightnessContrastImage$address() { - return MagickBrightnessContrastImage.ADDR; + public static MemorySegment MagickGaussianBlurImage$address() { + return MagickGaussianBlurImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickBrightnessContrastImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickGaussianBlurImage(MagickWand *, const double, const double) * } */ - public static int MagickBrightnessContrastImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickBrightnessContrastImage.HANDLE; + public static int MagickGaussianBlurImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickGaussianBlurImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickBrightnessContrastImage", x0, x1, x2); + traceDowncall("MagickGaussianBlurImage", x0, x1, x2); } return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { @@ -7207,17 +21746,13 @@ public static int MagickBrightnessContrastImage(MemorySegment x0, double x1, dou } } - private static class MagickCannyEdgeImage { + private static class MagickGetImageAlphaChannel { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCannyEdgeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageAlphaChannel"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7225,59 +21760,58 @@ private static class MagickCannyEdgeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickCannyEdgeImage(MagickWand *, const double, const double, const double, const double) + * extern MagickBooleanType MagickGetImageAlphaChannel(MagickWand *) * } */ - public static FunctionDescriptor MagickCannyEdgeImage$descriptor() { - return MagickCannyEdgeImage.DESC; + public static FunctionDescriptor MagickGetImageAlphaChannel$descriptor() { + return MagickGetImageAlphaChannel.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickCannyEdgeImage(MagickWand *, const double, const double, const double, const double) + * extern MagickBooleanType MagickGetImageAlphaChannel(MagickWand *) * } */ - public static MethodHandle MagickCannyEdgeImage$handle() { - return MagickCannyEdgeImage.HANDLE; + public static MethodHandle MagickGetImageAlphaChannel$handle() { + return MagickGetImageAlphaChannel.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickCannyEdgeImage(MagickWand *, const double, const double, const double, const double) + * extern MagickBooleanType MagickGetImageAlphaChannel(MagickWand *) * } */ - public static MemorySegment MagickCannyEdgeImage$address() { - return MagickCannyEdgeImage.ADDR; + public static MemorySegment MagickGetImageAlphaChannel$address() { + return MagickGetImageAlphaChannel.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickCannyEdgeImage(MagickWand *, const double, const double, const double, const double) + * extern MagickBooleanType MagickGetImageAlphaChannel(MagickWand *) * } */ - public static int MagickCannyEdgeImage(MemorySegment x0, double x1, double x2, double x3, double x4) { - var mh$ = MagickCannyEdgeImage.HANDLE; + public static int MagickGetImageAlphaChannel(MemorySegment x0) { + var mh$ = MagickGetImageAlphaChannel.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickCannyEdgeImage", x0, x1, x2, x3, x4); + traceDowncall("MagickGetImageAlphaChannel", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickCharcoalImage { + private static class MagickGetImageBackgroundColor { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCharcoalImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageBackgroundColor"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7285,61 +21819,60 @@ private static class MagickCharcoalImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickCharcoalImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickGetImageBackgroundColor(MagickWand *, PixelWand *) * } */ - public static FunctionDescriptor MagickCharcoalImage$descriptor() { - return MagickCharcoalImage.DESC; + public static FunctionDescriptor MagickGetImageBackgroundColor$descriptor() { + return MagickGetImageBackgroundColor.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickCharcoalImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickGetImageBackgroundColor(MagickWand *, PixelWand *) * } */ - public static MethodHandle MagickCharcoalImage$handle() { - return MagickCharcoalImage.HANDLE; + public static MethodHandle MagickGetImageBackgroundColor$handle() { + return MagickGetImageBackgroundColor.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickCharcoalImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickGetImageBackgroundColor(MagickWand *, PixelWand *) * } */ - public static MemorySegment MagickCharcoalImage$address() { - return MagickCharcoalImage.ADDR; + public static MemorySegment MagickGetImageBackgroundColor$address() { + return MagickGetImageBackgroundColor.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickCharcoalImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickGetImageBackgroundColor(MagickWand *, PixelWand *) * } */ - public static int MagickCharcoalImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickCharcoalImage.HANDLE; + public static int MagickGetImageBackgroundColor(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickGetImageBackgroundColor.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickCharcoalImage", x0, x1, x2); + traceDowncall("MagickGetImageBackgroundColor", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickChopImage { + private static class MagickGetImageBluePrimary { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickChopImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageBluePrimary"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7347,61 +21880,58 @@ private static class MagickChopImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickChopImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickGetImageBluePrimary(MagickWand *, double *, double *, double *) * } */ - public static FunctionDescriptor MagickChopImage$descriptor() { - return MagickChopImage.DESC; + public static FunctionDescriptor MagickGetImageBluePrimary$descriptor() { + return MagickGetImageBluePrimary.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickChopImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickGetImageBluePrimary(MagickWand *, double *, double *, double *) * } */ - public static MethodHandle MagickChopImage$handle() { - return MagickChopImage.HANDLE; + public static MethodHandle MagickGetImageBluePrimary$handle() { + return MagickGetImageBluePrimary.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickChopImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickGetImageBluePrimary(MagickWand *, double *, double *, double *) * } */ - public static MemorySegment MagickChopImage$address() { - return MagickChopImage.ADDR; + public static MemorySegment MagickGetImageBluePrimary$address() { + return MagickGetImageBluePrimary.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickChopImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickGetImageBluePrimary(MagickWand *, double *, double *, double *) * } */ - public static int MagickChopImage(MemorySegment x0, long x1, long x2, long x3, long x4) { - var mh$ = MagickChopImage.HANDLE; + public static int MagickGetImageBluePrimary(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { + var mh$ = MagickGetImageBluePrimary.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickChopImage", x0, x1, x2, x3, x4); + traceDowncall("MagickGetImageBluePrimary", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickCLAHEImage { + private static class MagickGetImageBorderColor { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCLAHEImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageBorderColor"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7409,57 +21939,59 @@ private static class MagickCLAHEImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickCLAHEImage(MagickWand *, const size_t, const size_t, const double, const double) + * extern MagickBooleanType MagickGetImageBorderColor(MagickWand *, PixelWand *) * } */ - public static FunctionDescriptor MagickCLAHEImage$descriptor() { - return MagickCLAHEImage.DESC; + public static FunctionDescriptor MagickGetImageBorderColor$descriptor() { + return MagickGetImageBorderColor.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickCLAHEImage(MagickWand *, const size_t, const size_t, const double, const double) + * extern MagickBooleanType MagickGetImageBorderColor(MagickWand *, PixelWand *) * } */ - public static MethodHandle MagickCLAHEImage$handle() { - return MagickCLAHEImage.HANDLE; + public static MethodHandle MagickGetImageBorderColor$handle() { + return MagickGetImageBorderColor.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickCLAHEImage(MagickWand *, const size_t, const size_t, const double, const double) + * extern MagickBooleanType MagickGetImageBorderColor(MagickWand *, PixelWand *) * } */ - public static MemorySegment MagickCLAHEImage$address() { - return MagickCLAHEImage.ADDR; + public static MemorySegment MagickGetImageBorderColor$address() { + return MagickGetImageBorderColor.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickCLAHEImage(MagickWand *, const size_t, const size_t, const double, const double) + * extern MagickBooleanType MagickGetImageBorderColor(MagickWand *, PixelWand *) * } */ - public static int MagickCLAHEImage(MemorySegment x0, long x1, long x2, double x3, double x4) { - var mh$ = MagickCLAHEImage.HANDLE; + public static int MagickGetImageBorderColor(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickGetImageBorderColor.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickCLAHEImage", x0, x1, x2, x3, x4); + traceDowncall("MagickGetImageBorderColor", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickClampImage { + private static class MagickGetImageKurtosis { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickClampImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageKurtosis"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7467,57 +21999,59 @@ private static class MagickClampImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickClampImage(MagickWand *) + * extern MagickBooleanType MagickGetImageKurtosis(MagickWand *, double *, double *) * } */ - public static FunctionDescriptor MagickClampImage$descriptor() { - return MagickClampImage.DESC; + public static FunctionDescriptor MagickGetImageKurtosis$descriptor() { + return MagickGetImageKurtosis.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickClampImage(MagickWand *) + * extern MagickBooleanType MagickGetImageKurtosis(MagickWand *, double *, double *) * } */ - public static MethodHandle MagickClampImage$handle() { - return MagickClampImage.HANDLE; + public static MethodHandle MagickGetImageKurtosis$handle() { + return MagickGetImageKurtosis.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickClampImage(MagickWand *) + * extern MagickBooleanType MagickGetImageKurtosis(MagickWand *, double *, double *) * } */ - public static MemorySegment MagickClampImage$address() { - return MagickClampImage.ADDR; + public static MemorySegment MagickGetImageKurtosis$address() { + return MagickGetImageKurtosis.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickClampImage(MagickWand *) + * extern MagickBooleanType MagickGetImageKurtosis(MagickWand *, double *, double *) * } */ - public static int MagickClampImage(MemorySegment x0) { - var mh$ = MagickClampImage.HANDLE; + public static int MagickGetImageKurtosis(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickGetImageKurtosis.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickClampImage", x0); + traceDowncall("MagickGetImageKurtosis", x0, x1, x2); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickClipImage { + private static class MagickGetImageMean { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickClipImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageMean"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7525,59 +22059,59 @@ private static class MagickClipImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickClipImage(MagickWand *) + * extern MagickBooleanType MagickGetImageMean(MagickWand *, double *, double *) * } */ - public static FunctionDescriptor MagickClipImage$descriptor() { - return MagickClipImage.DESC; + public static FunctionDescriptor MagickGetImageMean$descriptor() { + return MagickGetImageMean.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickClipImage(MagickWand *) + * extern MagickBooleanType MagickGetImageMean(MagickWand *, double *, double *) * } */ - public static MethodHandle MagickClipImage$handle() { - return MagickClipImage.HANDLE; + public static MethodHandle MagickGetImageMean$handle() { + return MagickGetImageMean.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickClipImage(MagickWand *) + * extern MagickBooleanType MagickGetImageMean(MagickWand *, double *, double *) * } */ - public static MemorySegment MagickClipImage$address() { - return MagickClipImage.ADDR; + public static MemorySegment MagickGetImageMean$address() { + return MagickGetImageMean.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickClipImage(MagickWand *) + * extern MagickBooleanType MagickGetImageMean(MagickWand *, double *, double *) * } */ - public static int MagickClipImage(MemorySegment x0) { - var mh$ = MagickClipImage.HANDLE; + public static int MagickGetImageMean(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickGetImageMean.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickClipImage", x0); + traceDowncall("MagickGetImageMean", x0, x1, x2); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickClipImagePath { + private static class MagickGetImageRange { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickClipImagePath"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageRange"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7585,43 +22119,43 @@ private static class MagickClipImagePath { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickClipImagePath(MagickWand *, const char *, const MagickBooleanType) + * extern MagickBooleanType MagickGetImageRange(MagickWand *, double *, double *) * } */ - public static FunctionDescriptor MagickClipImagePath$descriptor() { - return MagickClipImagePath.DESC; + public static FunctionDescriptor MagickGetImageRange$descriptor() { + return MagickGetImageRange.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickClipImagePath(MagickWand *, const char *, const MagickBooleanType) + * extern MagickBooleanType MagickGetImageRange(MagickWand *, double *, double *) * } */ - public static MethodHandle MagickClipImagePath$handle() { - return MagickClipImagePath.HANDLE; + public static MethodHandle MagickGetImageRange$handle() { + return MagickGetImageRange.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickClipImagePath(MagickWand *, const char *, const MagickBooleanType) + * extern MagickBooleanType MagickGetImageRange(MagickWand *, double *, double *) * } */ - public static MemorySegment MagickClipImagePath$address() { - return MagickClipImagePath.ADDR; + public static MemorySegment MagickGetImageRange$address() { + return MagickGetImageRange.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickClipImagePath(MagickWand *, const char *, const MagickBooleanType) + * extern MagickBooleanType MagickGetImageRange(MagickWand *, double *, double *) * } */ - public static int MagickClipImagePath(MemorySegment x0, MemorySegment x1, int x2) { - var mh$ = MagickClipImagePath.HANDLE; + public static int MagickGetImageRange(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickGetImageRange.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickClipImagePath", x0, x1, x2); + traceDowncall("MagickGetImageRange", x0, x1, x2); } return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { @@ -7629,15 +22163,15 @@ public static int MagickClipImagePath(MemorySegment x0, MemorySegment x1, int x2 } } - private static class MagickClutImage { + private static class MagickGetImageColormapColor { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickClutImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageColormapColor"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7645,43 +22179,43 @@ private static class MagickClutImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickClutImage(MagickWand *, const MagickWand *, const PixelInterpolateMethod) + * extern MagickBooleanType MagickGetImageColormapColor(MagickWand *, const size_t, PixelWand *) * } */ - public static FunctionDescriptor MagickClutImage$descriptor() { - return MagickClutImage.DESC; + public static FunctionDescriptor MagickGetImageColormapColor$descriptor() { + return MagickGetImageColormapColor.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickClutImage(MagickWand *, const MagickWand *, const PixelInterpolateMethod) + * extern MagickBooleanType MagickGetImageColormapColor(MagickWand *, const size_t, PixelWand *) * } */ - public static MethodHandle MagickClutImage$handle() { - return MagickClutImage.HANDLE; + public static MethodHandle MagickGetImageColormapColor$handle() { + return MagickGetImageColormapColor.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickClutImage(MagickWand *, const MagickWand *, const PixelInterpolateMethod) + * extern MagickBooleanType MagickGetImageColormapColor(MagickWand *, const size_t, PixelWand *) * } */ - public static MemorySegment MagickClutImage$address() { - return MagickClutImage.ADDR; + public static MemorySegment MagickGetImageColormapColor$address() { + return MagickGetImageColormapColor.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickClutImage(MagickWand *, const MagickWand *, const PixelInterpolateMethod) + * extern MagickBooleanType MagickGetImageColormapColor(MagickWand *, const size_t, PixelWand *) * } */ - public static int MagickClutImage(MemorySegment x0, MemorySegment x1, int x2) { - var mh$ = MagickClutImage.HANDLE; + public static int MagickGetImageColormapColor(MemorySegment x0, long x1, MemorySegment x2) { + var mh$ = MagickGetImageColormapColor.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickClutImage", x0, x1, x2); + traceDowncall("MagickGetImageColormapColor", x0, x1, x2); } return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { @@ -7689,14 +22223,16 @@ public static int MagickClutImage(MemorySegment x0, MemorySegment x1, int x2) { } } - private static class MagickColorDecisionListImage { + private static class MagickGetImageDistortion { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickColorDecisionListImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageDistortion"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7704,59 +22240,60 @@ private static class MagickColorDecisionListImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickColorDecisionListImage(MagickWand *, const char *) + * extern MagickBooleanType MagickGetImageDistortion(MagickWand *, const MagickWand *, const MetricType, double *) * } */ - public static FunctionDescriptor MagickColorDecisionListImage$descriptor() { - return MagickColorDecisionListImage.DESC; + public static FunctionDescriptor MagickGetImageDistortion$descriptor() { + return MagickGetImageDistortion.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickColorDecisionListImage(MagickWand *, const char *) + * extern MagickBooleanType MagickGetImageDistortion(MagickWand *, const MagickWand *, const MetricType, double *) * } */ - public static MethodHandle MagickColorDecisionListImage$handle() { - return MagickColorDecisionListImage.HANDLE; + public static MethodHandle MagickGetImageDistortion$handle() { + return MagickGetImageDistortion.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickColorDecisionListImage(MagickWand *, const char *) + * extern MagickBooleanType MagickGetImageDistortion(MagickWand *, const MagickWand *, const MetricType, double *) * } */ - public static MemorySegment MagickColorDecisionListImage$address() { - return MagickColorDecisionListImage.ADDR; + public static MemorySegment MagickGetImageDistortion$address() { + return MagickGetImageDistortion.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickColorDecisionListImage(MagickWand *, const char *) + * extern MagickBooleanType MagickGetImageDistortion(MagickWand *, const MagickWand *, const MetricType, double *) * } */ - public static int MagickColorDecisionListImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickColorDecisionListImage.HANDLE; + public static int MagickGetImageDistortion(MemorySegment x0, MemorySegment x1, int x2, MemorySegment x3) { + var mh$ = MagickGetImageDistortion.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickColorDecisionListImage", x0, x1); + traceDowncall("MagickGetImageDistortion", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickColorizeImage { + private static class MagickGetImageGreenPrimary { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickColorizeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageGreenPrimary"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7764,58 +22301,58 @@ private static class MagickColorizeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickColorizeImage(MagickWand *, const PixelWand *, const PixelWand *) + * extern MagickBooleanType MagickGetImageGreenPrimary(MagickWand *, double *, double *, double *) * } */ - public static FunctionDescriptor MagickColorizeImage$descriptor() { - return MagickColorizeImage.DESC; + public static FunctionDescriptor MagickGetImageGreenPrimary$descriptor() { + return MagickGetImageGreenPrimary.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickColorizeImage(MagickWand *, const PixelWand *, const PixelWand *) + * extern MagickBooleanType MagickGetImageGreenPrimary(MagickWand *, double *, double *, double *) * } */ - public static MethodHandle MagickColorizeImage$handle() { - return MagickColorizeImage.HANDLE; + public static MethodHandle MagickGetImageGreenPrimary$handle() { + return MagickGetImageGreenPrimary.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickColorizeImage(MagickWand *, const PixelWand *, const PixelWand *) + * extern MagickBooleanType MagickGetImageGreenPrimary(MagickWand *, double *, double *, double *) * } */ - public static MemorySegment MagickColorizeImage$address() { - return MagickColorizeImage.ADDR; + public static MemorySegment MagickGetImageGreenPrimary$address() { + return MagickGetImageGreenPrimary.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickColorizeImage(MagickWand *, const PixelWand *, const PixelWand *) + * extern MagickBooleanType MagickGetImageGreenPrimary(MagickWand *, double *, double *, double *) * } */ - public static int MagickColorizeImage(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickColorizeImage.HANDLE; + public static int MagickGetImageGreenPrimary(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { + var mh$ = MagickGetImageGreenPrimary.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickColorizeImage", x0, x1, x2); + traceDowncall("MagickGetImageGreenPrimary", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickColorMatrixImage { + private static class MagickGetImageLength { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickColorMatrixImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageLength"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7823,43 +22360,43 @@ private static class MagickColorMatrixImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickColorMatrixImage(MagickWand *, const KernelInfo *) + * extern MagickBooleanType MagickGetImageLength(MagickWand *, MagickSizeType *) * } */ - public static FunctionDescriptor MagickColorMatrixImage$descriptor() { - return MagickColorMatrixImage.DESC; + public static FunctionDescriptor MagickGetImageLength$descriptor() { + return MagickGetImageLength.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickColorMatrixImage(MagickWand *, const KernelInfo *) + * extern MagickBooleanType MagickGetImageLength(MagickWand *, MagickSizeType *) * } */ - public static MethodHandle MagickColorMatrixImage$handle() { - return MagickColorMatrixImage.HANDLE; + public static MethodHandle MagickGetImageLength$handle() { + return MagickGetImageLength.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickColorMatrixImage(MagickWand *, const KernelInfo *) + * extern MagickBooleanType MagickGetImageLength(MagickWand *, MagickSizeType *) * } */ - public static MemorySegment MagickColorMatrixImage$address() { - return MagickColorMatrixImage.ADDR; + public static MemorySegment MagickGetImageLength$address() { + return MagickGetImageLength.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickColorMatrixImage(MagickWand *, const KernelInfo *) + * extern MagickBooleanType MagickGetImageLength(MagickWand *, MagickSizeType *) * } */ - public static int MagickColorMatrixImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickColorMatrixImage.HANDLE; + public static int MagickGetImageLength(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickGetImageLength.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickColorMatrixImage", x0, x1); + traceDowncall("MagickGetImageLength", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -7867,15 +22404,14 @@ public static int MagickColorMatrixImage(MemorySegment x0, MemorySegment x1) { } } - private static class MagickColorThresholdImage { + private static class MagickGetImageMatteColor { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickColorThresholdImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageMatteColor"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7883,58 +22419,61 @@ private static class MagickColorThresholdImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickColorThresholdImage(MagickWand *, const PixelWand *, const PixelWand *) + * extern MagickBooleanType MagickGetImageMatteColor(MagickWand *, PixelWand *) * } */ - public static FunctionDescriptor MagickColorThresholdImage$descriptor() { - return MagickColorThresholdImage.DESC; + public static FunctionDescriptor MagickGetImageMatteColor$descriptor() { + return MagickGetImageMatteColor.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickColorThresholdImage(MagickWand *, const PixelWand *, const PixelWand *) + * extern MagickBooleanType MagickGetImageMatteColor(MagickWand *, PixelWand *) * } */ - public static MethodHandle MagickColorThresholdImage$handle() { - return MagickColorThresholdImage.HANDLE; + public static MethodHandle MagickGetImageMatteColor$handle() { + return MagickGetImageMatteColor.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickColorThresholdImage(MagickWand *, const PixelWand *, const PixelWand *) + * extern MagickBooleanType MagickGetImageMatteColor(MagickWand *, PixelWand *) * } */ - public static MemorySegment MagickColorThresholdImage$address() { - return MagickColorThresholdImage.ADDR; + public static MemorySegment MagickGetImageMatteColor$address() { + return MagickGetImageMatteColor.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickColorThresholdImage(MagickWand *, const PixelWand *, const PixelWand *) + * extern MagickBooleanType MagickGetImageMatteColor(MagickWand *, PixelWand *) * } */ - public static int MagickColorThresholdImage(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickColorThresholdImage.HANDLE; + public static int MagickGetImageMatteColor(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickGetImageMatteColor.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickColorThresholdImage", x0, x1, x2); + traceDowncall("MagickGetImageMatteColor", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickCommentImage { + private static class MagickGetImagePage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCommentImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImagePage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -7942,62 +22481,60 @@ private static class MagickCommentImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickCommentImage(MagickWand *, const char *) + * extern MagickBooleanType MagickGetImagePage(MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) * } */ - public static FunctionDescriptor MagickCommentImage$descriptor() { - return MagickCommentImage.DESC; + public static FunctionDescriptor MagickGetImagePage$descriptor() { + return MagickGetImagePage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickCommentImage(MagickWand *, const char *) + * extern MagickBooleanType MagickGetImagePage(MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) * } */ - public static MethodHandle MagickCommentImage$handle() { - return MagickCommentImage.HANDLE; + public static MethodHandle MagickGetImagePage$handle() { + return MagickGetImagePage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickCommentImage(MagickWand *, const char *) + * extern MagickBooleanType MagickGetImagePage(MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) * } */ - public static MemorySegment MagickCommentImage$address() { - return MagickCommentImage.ADDR; + public static MemorySegment MagickGetImagePage$address() { + return MagickGetImagePage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickCommentImage(MagickWand *, const char *) + * extern MagickBooleanType MagickGetImagePage(MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) * } */ - public static int MagickCommentImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickCommentImage.HANDLE; + public static int MagickGetImagePage(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = MagickGetImagePage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickCommentImage", x0, x1); + traceDowncall("MagickGetImagePage", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickCompositeImage { + private static class MagickGetImagePixelColor { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_INT, MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCompositeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImagePixelColor"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8005,60 +22542,60 @@ private static class MagickCompositeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickCompositeImage(MagickWand *, const MagickWand *, const CompositeOperator, const MagickBooleanType, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickGetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, PixelWand *) * } */ - public static FunctionDescriptor MagickCompositeImage$descriptor() { - return MagickCompositeImage.DESC; + public static FunctionDescriptor MagickGetImagePixelColor$descriptor() { + return MagickGetImagePixelColor.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickCompositeImage(MagickWand *, const MagickWand *, const CompositeOperator, const MagickBooleanType, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickGetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, PixelWand *) * } */ - public static MethodHandle MagickCompositeImage$handle() { - return MagickCompositeImage.HANDLE; + public static MethodHandle MagickGetImagePixelColor$handle() { + return MagickGetImagePixelColor.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickCompositeImage(MagickWand *, const MagickWand *, const CompositeOperator, const MagickBooleanType, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickGetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, PixelWand *) * } */ - public static MemorySegment MagickCompositeImage$address() { - return MagickCompositeImage.ADDR; + public static MemorySegment MagickGetImagePixelColor$address() { + return MagickGetImagePixelColor.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickCompositeImage(MagickWand *, const MagickWand *, const CompositeOperator, const MagickBooleanType, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickGetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, PixelWand *) * } */ - public static int MagickCompositeImage(MemorySegment x0, MemorySegment x1, int x2, int x3, long x4, long x5) { - var mh$ = MagickCompositeImage.HANDLE; + public static int MagickGetImagePixelColor(MemorySegment x0, long x1, long x2, MemorySegment x3) { + var mh$ = MagickGetImagePixelColor.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickCompositeImage", x0, x1, x2, x3, x4, x5); + traceDowncall("MagickGetImagePixelColor", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickCompositeImageGravity { + private static class MagickGetImageRedPrimary { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_INT + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCompositeImageGravity"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageRedPrimary"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8066,43 +22603,43 @@ private static class MagickCompositeImageGravity { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickCompositeImageGravity(MagickWand *, const MagickWand *, const CompositeOperator, const GravityType) + * extern MagickBooleanType MagickGetImageRedPrimary(MagickWand *, double *, double *, double *) * } */ - public static FunctionDescriptor MagickCompositeImageGravity$descriptor() { - return MagickCompositeImageGravity.DESC; + public static FunctionDescriptor MagickGetImageRedPrimary$descriptor() { + return MagickGetImageRedPrimary.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickCompositeImageGravity(MagickWand *, const MagickWand *, const CompositeOperator, const GravityType) + * extern MagickBooleanType MagickGetImageRedPrimary(MagickWand *, double *, double *, double *) * } */ - public static MethodHandle MagickCompositeImageGravity$handle() { - return MagickCompositeImageGravity.HANDLE; + public static MethodHandle MagickGetImageRedPrimary$handle() { + return MagickGetImageRedPrimary.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickCompositeImageGravity(MagickWand *, const MagickWand *, const CompositeOperator, const GravityType) + * extern MagickBooleanType MagickGetImageRedPrimary(MagickWand *, double *, double *, double *) * } */ - public static MemorySegment MagickCompositeImageGravity$address() { - return MagickCompositeImageGravity.ADDR; + public static MemorySegment MagickGetImageRedPrimary$address() { + return MagickGetImageRedPrimary.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickCompositeImageGravity(MagickWand *, const MagickWand *, const CompositeOperator, const GravityType) + * extern MagickBooleanType MagickGetImageRedPrimary(MagickWand *, double *, double *, double *) * } */ - public static int MagickCompositeImageGravity(MemorySegment x0, MemorySegment x1, int x2, int x3) { - var mh$ = MagickCompositeImageGravity.HANDLE; + public static int MagickGetImageRedPrimary(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { + var mh$ = MagickGetImageRedPrimary.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickCompositeImageGravity", x0, x1, x2, x3); + traceDowncall("MagickGetImageRedPrimary", x0, x1, x2, x3); } return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { @@ -8110,17 +22647,15 @@ public static int MagickCompositeImageGravity(MemorySegment x0, MemorySegment x1 } } - private static class MagickCompositeLayers { + private static class MagickGetImageResolution { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCompositeLayers"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageResolution"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8128,59 +22663,60 @@ private static class MagickCompositeLayers { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickCompositeLayers(MagickWand *, const MagickWand *, const CompositeOperator, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickGetImageResolution(MagickWand *, double *, double *) * } */ - public static FunctionDescriptor MagickCompositeLayers$descriptor() { - return MagickCompositeLayers.DESC; + public static FunctionDescriptor MagickGetImageResolution$descriptor() { + return MagickGetImageResolution.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickCompositeLayers(MagickWand *, const MagickWand *, const CompositeOperator, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickGetImageResolution(MagickWand *, double *, double *) * } */ - public static MethodHandle MagickCompositeLayers$handle() { - return MagickCompositeLayers.HANDLE; + public static MethodHandle MagickGetImageResolution$handle() { + return MagickGetImageResolution.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickCompositeLayers(MagickWand *, const MagickWand *, const CompositeOperator, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickGetImageResolution(MagickWand *, double *, double *) * } */ - public static MemorySegment MagickCompositeLayers$address() { - return MagickCompositeLayers.ADDR; + public static MemorySegment MagickGetImageResolution$address() { + return MagickGetImageResolution.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickCompositeLayers(MagickWand *, const MagickWand *, const CompositeOperator, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickGetImageResolution(MagickWand *, double *, double *) * } */ - public static int MagickCompositeLayers(MemorySegment x0, MemorySegment x1, int x2, long x3, long x4) { - var mh$ = MagickCompositeLayers.HANDLE; + public static int MagickGetImageResolution(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickGetImageResolution.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickCompositeLayers", x0, x1, x2, x3, x4); + traceDowncall("MagickGetImageResolution", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickConnectedComponentsImage { + private static class MagickGetImageWhitePoint { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickConnectedComponentsImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageWhitePoint"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8188,62 +22724,58 @@ private static class MagickConnectedComponentsImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickConnectedComponentsImage(MagickWand *, const size_t, CCObjectInfo **) + * extern MagickBooleanType MagickGetImageWhitePoint(MagickWand *, double *, double *, double *) * } */ - public static FunctionDescriptor MagickConnectedComponentsImage$descriptor() { - return MagickConnectedComponentsImage.DESC; + public static FunctionDescriptor MagickGetImageWhitePoint$descriptor() { + return MagickGetImageWhitePoint.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickConnectedComponentsImage(MagickWand *, const size_t, CCObjectInfo **) + * extern MagickBooleanType MagickGetImageWhitePoint(MagickWand *, double *, double *, double *) * } */ - public static MethodHandle MagickConnectedComponentsImage$handle() { - return MagickConnectedComponentsImage.HANDLE; + public static MethodHandle MagickGetImageWhitePoint$handle() { + return MagickGetImageWhitePoint.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickConnectedComponentsImage(MagickWand *, const size_t, CCObjectInfo **) + * extern MagickBooleanType MagickGetImageWhitePoint(MagickWand *, double *, double *, double *) * } */ - public static MemorySegment MagickConnectedComponentsImage$address() { - return MagickConnectedComponentsImage.ADDR; + public static MemorySegment MagickGetImageWhitePoint$address() { + return MagickGetImageWhitePoint.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickConnectedComponentsImage(MagickWand *, const size_t, CCObjectInfo **) + * extern MagickBooleanType MagickGetImageWhitePoint(MagickWand *, double *, double *, double *) * } */ - public static int MagickConnectedComponentsImage(MemorySegment x0, long x1, MemorySegment x2) { - var mh$ = MagickConnectedComponentsImage.HANDLE; + public static int MagickGetImageWhitePoint(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { + var mh$ = MagickGetImageWhitePoint.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickConnectedComponentsImage", x0, x1, x2); + traceDowncall("MagickGetImageWhitePoint", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickConstituteImage { + private static class MagickHaldClutImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickConstituteImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickHaldClutImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8251,58 +22783,57 @@ private static class MagickConstituteImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickConstituteImage(MagickWand *, const size_t, const size_t, const char *, const StorageType, const void *) + * extern MagickBooleanType MagickHaldClutImage(MagickWand *, const MagickWand *) * } */ - public static FunctionDescriptor MagickConstituteImage$descriptor() { - return MagickConstituteImage.DESC; + public static FunctionDescriptor MagickHaldClutImage$descriptor() { + return MagickHaldClutImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickConstituteImage(MagickWand *, const size_t, const size_t, const char *, const StorageType, const void *) + * extern MagickBooleanType MagickHaldClutImage(MagickWand *, const MagickWand *) * } */ - public static MethodHandle MagickConstituteImage$handle() { - return MagickConstituteImage.HANDLE; + public static MethodHandle MagickHaldClutImage$handle() { + return MagickHaldClutImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickConstituteImage(MagickWand *, const size_t, const size_t, const char *, const StorageType, const void *) + * extern MagickBooleanType MagickHaldClutImage(MagickWand *, const MagickWand *) * } */ - public static MemorySegment MagickConstituteImage$address() { - return MagickConstituteImage.ADDR; + public static MemorySegment MagickHaldClutImage$address() { + return MagickHaldClutImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickConstituteImage(MagickWand *, const size_t, const size_t, const char *, const StorageType, const void *) + * extern MagickBooleanType MagickHaldClutImage(MagickWand *, const MagickWand *) * } */ - public static int MagickConstituteImage(MemorySegment x0, long x1, long x2, MemorySegment x3, int x4, MemorySegment x5) { - var mh$ = MagickConstituteImage.HANDLE; + public static int MagickHaldClutImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickHaldClutImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickConstituteImage", x0, x1, x2, x3, x4, x5); + traceDowncall("MagickHaldClutImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickContrastImage { + private static class MagickHasNextImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickContrastImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickHasNextImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8310,59 +22841,57 @@ private static class MagickContrastImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickContrastImage(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickHasNextImage(MagickWand *) * } */ - public static FunctionDescriptor MagickContrastImage$descriptor() { - return MagickContrastImage.DESC; + public static FunctionDescriptor MagickHasNextImage$descriptor() { + return MagickHasNextImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickContrastImage(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickHasNextImage(MagickWand *) * } */ - public static MethodHandle MagickContrastImage$handle() { - return MagickContrastImage.HANDLE; + public static MethodHandle MagickHasNextImage$handle() { + return MagickHasNextImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickContrastImage(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickHasNextImage(MagickWand *) * } */ - public static MemorySegment MagickContrastImage$address() { - return MagickContrastImage.ADDR; + public static MemorySegment MagickHasNextImage$address() { + return MagickHasNextImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickContrastImage(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickHasNextImage(MagickWand *) * } */ - public static int MagickContrastImage(MemorySegment x0, int x1) { - var mh$ = MagickContrastImage.HANDLE; + public static int MagickHasNextImage(MemorySegment x0) { + var mh$ = MagickHasNextImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickContrastImage", x0, x1); + traceDowncall("MagickHasNextImage", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickContrastStretchImage { + private static class MagickHasPreviousImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickContrastStretchImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickHasPreviousImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8370,58 +22899,60 @@ private static class MagickContrastStretchImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickContrastStretchImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickHasPreviousImage(MagickWand *) * } */ - public static FunctionDescriptor MagickContrastStretchImage$descriptor() { - return MagickContrastStretchImage.DESC; + public static FunctionDescriptor MagickHasPreviousImage$descriptor() { + return MagickHasPreviousImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickContrastStretchImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickHasPreviousImage(MagickWand *) * } */ - public static MethodHandle MagickContrastStretchImage$handle() { - return MagickContrastStretchImage.HANDLE; + public static MethodHandle MagickHasPreviousImage$handle() { + return MagickHasPreviousImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickContrastStretchImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickHasPreviousImage(MagickWand *) * } */ - public static MemorySegment MagickContrastStretchImage$address() { - return MagickContrastStretchImage.ADDR; + public static MemorySegment MagickHasPreviousImage$address() { + return MagickHasPreviousImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickContrastStretchImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickHasPreviousImage(MagickWand *) * } */ - public static int MagickContrastStretchImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickContrastStretchImage.HANDLE; + public static int MagickHasPreviousImage(MemorySegment x0) { + var mh$ = MagickHasPreviousImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickContrastStretchImage", x0, x1, x2); + traceDowncall("MagickHasPreviousImage", x0); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickConvolveImage { + private static class MagickHoughLineImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickConvolveImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickHoughLineImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8429,61 +22960,59 @@ private static class MagickConvolveImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickConvolveImage(MagickWand *, const KernelInfo *) + * extern MagickBooleanType MagickHoughLineImage(MagickWand *, const size_t, const size_t, const size_t) * } - */ - public static FunctionDescriptor MagickConvolveImage$descriptor() { - return MagickConvolveImage.DESC; + */ + public static FunctionDescriptor MagickHoughLineImage$descriptor() { + return MagickHoughLineImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickConvolveImage(MagickWand *, const KernelInfo *) + * extern MagickBooleanType MagickHoughLineImage(MagickWand *, const size_t, const size_t, const size_t) * } */ - public static MethodHandle MagickConvolveImage$handle() { - return MagickConvolveImage.HANDLE; + public static MethodHandle MagickHoughLineImage$handle() { + return MagickHoughLineImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickConvolveImage(MagickWand *, const KernelInfo *) + * extern MagickBooleanType MagickHoughLineImage(MagickWand *, const size_t, const size_t, const size_t) * } */ - public static MemorySegment MagickConvolveImage$address() { - return MagickConvolveImage.ADDR; + public static MemorySegment MagickHoughLineImage$address() { + return MagickHoughLineImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickConvolveImage(MagickWand *, const KernelInfo *) + * extern MagickBooleanType MagickHoughLineImage(MagickWand *, const size_t, const size_t, const size_t) * } */ - public static int MagickConvolveImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickConvolveImage.HANDLE; + public static int MagickHoughLineImage(MemorySegment x0, long x1, long x2, long x3) { + var mh$ = MagickHoughLineImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickConvolveImage", x0, x1); + traceDowncall("MagickHoughLineImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickCropImage { + private static class MagickImplodeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_DOUBLE, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCropImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickImplodeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8491,58 +23020,64 @@ private static class MagickCropImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickCropImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickImplodeImage(MagickWand *, const double, const PixelInterpolateMethod) * } */ - public static FunctionDescriptor MagickCropImage$descriptor() { - return MagickCropImage.DESC; + public static FunctionDescriptor MagickImplodeImage$descriptor() { + return MagickImplodeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickCropImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickImplodeImage(MagickWand *, const double, const PixelInterpolateMethod) * } */ - public static MethodHandle MagickCropImage$handle() { - return MagickCropImage.HANDLE; + public static MethodHandle MagickImplodeImage$handle() { + return MagickImplodeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickCropImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickImplodeImage(MagickWand *, const double, const PixelInterpolateMethod) * } */ - public static MemorySegment MagickCropImage$address() { - return MagickCropImage.ADDR; + public static MemorySegment MagickImplodeImage$address() { + return MagickImplodeImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickCropImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickImplodeImage(MagickWand *, const double, const PixelInterpolateMethod) * } */ - public static int MagickCropImage(MemorySegment x0, long x1, long x2, long x3, long x4) { - var mh$ = MagickCropImage.HANDLE; + public static int MagickImplodeImage(MemorySegment x0, double x1, int x2) { + var mh$ = MagickImplodeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickCropImage", x0, x1, x2, x3, x4); + traceDowncall("MagickImplodeImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickCycleColormapImage { + private static class MagickImportImagePixels { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCycleColormapImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickImportImagePixels"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8550,58 +23085,60 @@ private static class MagickCycleColormapImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickCycleColormapImage(MagickWand *, const ssize_t) + * extern MagickBooleanType MagickImportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, const void *) * } */ - public static FunctionDescriptor MagickCycleColormapImage$descriptor() { - return MagickCycleColormapImage.DESC; + public static FunctionDescriptor MagickImportImagePixels$descriptor() { + return MagickImportImagePixels.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickCycleColormapImage(MagickWand *, const ssize_t) + * extern MagickBooleanType MagickImportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, const void *) * } */ - public static MethodHandle MagickCycleColormapImage$handle() { - return MagickCycleColormapImage.HANDLE; + public static MethodHandle MagickImportImagePixels$handle() { + return MagickImportImagePixels.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickCycleColormapImage(MagickWand *, const ssize_t) + * extern MagickBooleanType MagickImportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, const void *) * } */ - public static MemorySegment MagickCycleColormapImage$address() { - return MagickCycleColormapImage.ADDR; + public static MemorySegment MagickImportImagePixels$address() { + return MagickImportImagePixels.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickCycleColormapImage(MagickWand *, const ssize_t) + * extern MagickBooleanType MagickImportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, const void *) * } */ - public static int MagickCycleColormapImage(MemorySegment x0, long x1) { - var mh$ = MagickCycleColormapImage.HANDLE; + public static int MagickImportImagePixels(MemorySegment x0, long x1, long x2, long x3, long x4, MemorySegment x5, int x6, MemorySegment x7) { + var mh$ = MagickImportImagePixels.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickCycleColormapImage", x0, x1); + traceDowncall("MagickImportImagePixels", x0, x1, x2, x3, x4, x5, x6, x7); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5, x6, x7); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickDecipherImage { + private static class MagickInterpolativeResizeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDecipherImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickInterpolativeResizeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8609,58 +23146,59 @@ private static class MagickDecipherImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickDecipherImage(MagickWand *, const char *) + * extern MagickBooleanType MagickInterpolativeResizeImage(MagickWand *, const size_t, const size_t, const PixelInterpolateMethod) * } */ - public static FunctionDescriptor MagickDecipherImage$descriptor() { - return MagickDecipherImage.DESC; + public static FunctionDescriptor MagickInterpolativeResizeImage$descriptor() { + return MagickInterpolativeResizeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickDecipherImage(MagickWand *, const char *) + * extern MagickBooleanType MagickInterpolativeResizeImage(MagickWand *, const size_t, const size_t, const PixelInterpolateMethod) * } */ - public static MethodHandle MagickDecipherImage$handle() { - return MagickDecipherImage.HANDLE; + public static MethodHandle MagickInterpolativeResizeImage$handle() { + return MagickInterpolativeResizeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickDecipherImage(MagickWand *, const char *) + * extern MagickBooleanType MagickInterpolativeResizeImage(MagickWand *, const size_t, const size_t, const PixelInterpolateMethod) * } */ - public static MemorySegment MagickDecipherImage$address() { - return MagickDecipherImage.ADDR; + public static MemorySegment MagickInterpolativeResizeImage$address() { + return MagickInterpolativeResizeImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickDecipherImage(MagickWand *, const char *) + * extern MagickBooleanType MagickInterpolativeResizeImage(MagickWand *, const size_t, const size_t, const PixelInterpolateMethod) * } */ - public static int MagickDecipherImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickDecipherImage.HANDLE; + public static int MagickInterpolativeResizeImage(MemorySegment x0, long x1, long x2, int x3) { + var mh$ = MagickInterpolativeResizeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickDecipherImage", x0, x1); + traceDowncall("MagickInterpolativeResizeImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickDeskewImage { + private static class MagickInverseFourierTransformImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDeskewImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickInverseFourierTransformImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8668,57 +23206,60 @@ private static class MagickDeskewImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickDeskewImage(MagickWand *, const double) + * extern MagickBooleanType MagickInverseFourierTransformImage(MagickWand *, MagickWand *, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickDeskewImage$descriptor() { - return MagickDeskewImage.DESC; + public static FunctionDescriptor MagickInverseFourierTransformImage$descriptor() { + return MagickInverseFourierTransformImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickDeskewImage(MagickWand *, const double) + * extern MagickBooleanType MagickInverseFourierTransformImage(MagickWand *, MagickWand *, const MagickBooleanType) * } */ - public static MethodHandle MagickDeskewImage$handle() { - return MagickDeskewImage.HANDLE; + public static MethodHandle MagickInverseFourierTransformImage$handle() { + return MagickInverseFourierTransformImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickDeskewImage(MagickWand *, const double) + * extern MagickBooleanType MagickInverseFourierTransformImage(MagickWand *, MagickWand *, const MagickBooleanType) * } */ - public static MemorySegment MagickDeskewImage$address() { - return MagickDeskewImage.ADDR; + public static MemorySegment MagickInverseFourierTransformImage$address() { + return MagickInverseFourierTransformImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickDeskewImage(MagickWand *, const double) + * extern MagickBooleanType MagickInverseFourierTransformImage(MagickWand *, MagickWand *, const MagickBooleanType) * } */ - public static int MagickDeskewImage(MemorySegment x0, double x1) { - var mh$ = MagickDeskewImage.HANDLE; + public static int MagickInverseFourierTransformImage(MemorySegment x0, MemorySegment x1, int x2) { + var mh$ = MagickInverseFourierTransformImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickDeskewImage", x0, x1); + traceDowncall("MagickInverseFourierTransformImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickDespeckleImage { + private static class MagickKmeansImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDespeckleImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickKmeansImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8726,58 +23267,59 @@ private static class MagickDespeckleImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickDespeckleImage(MagickWand *) + * extern MagickBooleanType MagickKmeansImage(MagickWand *, const size_t, const size_t, const double) * } */ - public static FunctionDescriptor MagickDespeckleImage$descriptor() { - return MagickDespeckleImage.DESC; + public static FunctionDescriptor MagickKmeansImage$descriptor() { + return MagickKmeansImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickDespeckleImage(MagickWand *) + * extern MagickBooleanType MagickKmeansImage(MagickWand *, const size_t, const size_t, const double) * } */ - public static MethodHandle MagickDespeckleImage$handle() { - return MagickDespeckleImage.HANDLE; + public static MethodHandle MagickKmeansImage$handle() { + return MagickKmeansImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickDespeckleImage(MagickWand *) + * extern MagickBooleanType MagickKmeansImage(MagickWand *, const size_t, const size_t, const double) * } */ - public static MemorySegment MagickDespeckleImage$address() { - return MagickDespeckleImage.ADDR; + public static MemorySegment MagickKmeansImage$address() { + return MagickKmeansImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickDespeckleImage(MagickWand *) + * extern MagickBooleanType MagickKmeansImage(MagickWand *, const size_t, const size_t, const double) * } */ - public static int MagickDespeckleImage(MemorySegment x0) { - var mh$ = MagickDespeckleImage.HANDLE; + public static int MagickKmeansImage(MemorySegment x0, long x1, long x2, double x3) { + var mh$ = MagickKmeansImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickDespeckleImage", x0); + traceDowncall("MagickKmeansImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickDisplayImage { + private static class MagickKuwaharaImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDisplayImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickKuwaharaImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8785,58 +23327,58 @@ private static class MagickDisplayImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickDisplayImage(MagickWand *, const char *) + * extern MagickBooleanType MagickKuwaharaImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickDisplayImage$descriptor() { - return MagickDisplayImage.DESC; + public static FunctionDescriptor MagickKuwaharaImage$descriptor() { + return MagickKuwaharaImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickDisplayImage(MagickWand *, const char *) + * extern MagickBooleanType MagickKuwaharaImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickDisplayImage$handle() { - return MagickDisplayImage.HANDLE; + public static MethodHandle MagickKuwaharaImage$handle() { + return MagickKuwaharaImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickDisplayImage(MagickWand *, const char *) + * extern MagickBooleanType MagickKuwaharaImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickDisplayImage$address() { - return MagickDisplayImage.ADDR; + public static MemorySegment MagickKuwaharaImage$address() { + return MagickKuwaharaImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickDisplayImage(MagickWand *, const char *) + * extern MagickBooleanType MagickKuwaharaImage(MagickWand *, const double, const double) * } */ - public static int MagickDisplayImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickDisplayImage.HANDLE; + public static int MagickKuwaharaImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickKuwaharaImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickDisplayImage", x0, x1); + traceDowncall("MagickKuwaharaImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickDisplayImages { + private static class MagickLabelImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDisplayImages"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickLabelImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8844,43 +23386,43 @@ private static class MagickDisplayImages { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickDisplayImages(MagickWand *, const char *) + * extern MagickBooleanType MagickLabelImage(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickDisplayImages$descriptor() { - return MagickDisplayImages.DESC; + public static FunctionDescriptor MagickLabelImage$descriptor() { + return MagickLabelImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickDisplayImages(MagickWand *, const char *) + * extern MagickBooleanType MagickLabelImage(MagickWand *, const char *) * } */ - public static MethodHandle MagickDisplayImages$handle() { - return MagickDisplayImages.HANDLE; + public static MethodHandle MagickLabelImage$handle() { + return MagickLabelImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickDisplayImages(MagickWand *, const char *) + * extern MagickBooleanType MagickLabelImage(MagickWand *, const char *) * } */ - public static MemorySegment MagickDisplayImages$address() { - return MagickDisplayImages.ADDR; + public static MemorySegment MagickLabelImage$address() { + return MagickLabelImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickDisplayImages(MagickWand *, const char *) + * extern MagickBooleanType MagickLabelImage(MagickWand *, const char *) * } */ - public static int MagickDisplayImages(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickDisplayImages.HANDLE; + public static int MagickLabelImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickLabelImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickDisplayImages", x0, x1); + traceDowncall("MagickLabelImage", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -8888,17 +23430,16 @@ public static int MagickDisplayImages(MemorySegment x0, MemorySegment x1) { } } - private static class MagickDistortImage { + private static class MagickLevelImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_LONG, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDistortImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickLevelImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8906,58 +23447,60 @@ private static class MagickDistortImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickDistortImage(MagickWand *, const DistortMethod, const size_t, const double *, const MagickBooleanType) + * extern MagickBooleanType MagickLevelImage(MagickWand *, const double, const double, const double) * } */ - public static FunctionDescriptor MagickDistortImage$descriptor() { - return MagickDistortImage.DESC; + public static FunctionDescriptor MagickLevelImage$descriptor() { + return MagickLevelImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickDistortImage(MagickWand *, const DistortMethod, const size_t, const double *, const MagickBooleanType) + * extern MagickBooleanType MagickLevelImage(MagickWand *, const double, const double, const double) * } */ - public static MethodHandle MagickDistortImage$handle() { - return MagickDistortImage.HANDLE; + public static MethodHandle MagickLevelImage$handle() { + return MagickLevelImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickDistortImage(MagickWand *, const DistortMethod, const size_t, const double *, const MagickBooleanType) + * extern MagickBooleanType MagickLevelImage(MagickWand *, const double, const double, const double) * } */ - public static MemorySegment MagickDistortImage$address() { - return MagickDistortImage.ADDR; + public static MemorySegment MagickLevelImage$address() { + return MagickLevelImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickDistortImage(MagickWand *, const DistortMethod, const size_t, const double *, const MagickBooleanType) + * extern MagickBooleanType MagickLevelImage(MagickWand *, const double, const double, const double) * } */ - public static int MagickDistortImage(MemorySegment x0, int x1, long x2, MemorySegment x3, int x4) { - var mh$ = MagickDistortImage.HANDLE; + public static int MagickLevelImage(MemorySegment x0, double x1, double x2, double x3) { + var mh$ = MagickLevelImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickDistortImage", x0, x1, x2, x3, x4); + traceDowncall("MagickLevelImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickDrawImage { + private static class MagickLevelImageColors { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDrawImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickLevelImageColors"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -8965,58 +23508,60 @@ private static class MagickDrawImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickDrawImage(MagickWand *, const DrawingWand *) + * extern MagickBooleanType MagickLevelImageColors(MagickWand *, const PixelWand *, const PixelWand *, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickDrawImage$descriptor() { - return MagickDrawImage.DESC; + public static FunctionDescriptor MagickLevelImageColors$descriptor() { + return MagickLevelImageColors.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickDrawImage(MagickWand *, const DrawingWand *) + * extern MagickBooleanType MagickLevelImageColors(MagickWand *, const PixelWand *, const PixelWand *, const MagickBooleanType) * } */ - public static MethodHandle MagickDrawImage$handle() { - return MagickDrawImage.HANDLE; + public static MethodHandle MagickLevelImageColors$handle() { + return MagickLevelImageColors.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickDrawImage(MagickWand *, const DrawingWand *) + * extern MagickBooleanType MagickLevelImageColors(MagickWand *, const PixelWand *, const PixelWand *, const MagickBooleanType) * } */ - public static MemorySegment MagickDrawImage$address() { - return MagickDrawImage.ADDR; + public static MemorySegment MagickLevelImageColors$address() { + return MagickLevelImageColors.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickDrawImage(MagickWand *, const DrawingWand *) + * extern MagickBooleanType MagickLevelImageColors(MagickWand *, const PixelWand *, const PixelWand *, const MagickBooleanType) * } */ - public static int MagickDrawImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickDrawImage.HANDLE; + public static int MagickLevelImageColors(MemorySegment x0, MemorySegment x1, MemorySegment x2, int x3) { + var mh$ = MagickLevelImageColors.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickDrawImage", x0, x1); + traceDowncall("MagickLevelImageColors", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickEdgeImage { + private static class MagickLevelizeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickEdgeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickLevelizeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9024,51 +23569,51 @@ private static class MagickEdgeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickEdgeImage(MagickWand *, const double) + * extern MagickBooleanType MagickLevelizeImage(MagickWand *, const double, const double, const double) * } */ - public static FunctionDescriptor MagickEdgeImage$descriptor() { - return MagickEdgeImage.DESC; + public static FunctionDescriptor MagickLevelizeImage$descriptor() { + return MagickLevelizeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickEdgeImage(MagickWand *, const double) + * extern MagickBooleanType MagickLevelizeImage(MagickWand *, const double, const double, const double) * } */ - public static MethodHandle MagickEdgeImage$handle() { - return MagickEdgeImage.HANDLE; + public static MethodHandle MagickLevelizeImage$handle() { + return MagickLevelizeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickEdgeImage(MagickWand *, const double) + * extern MagickBooleanType MagickLevelizeImage(MagickWand *, const double, const double, const double) * } */ - public static MemorySegment MagickEdgeImage$address() { - return MagickEdgeImage.ADDR; + public static MemorySegment MagickLevelizeImage$address() { + return MagickLevelizeImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickEdgeImage(MagickWand *, const double) + * extern MagickBooleanType MagickLevelizeImage(MagickWand *, const double, const double, const double) * } */ - public static int MagickEdgeImage(MemorySegment x0, double x1) { - var mh$ = MagickEdgeImage.HANDLE; + public static int MagickLevelizeImage(MemorySegment x0, double x1, double x2, double x3) { + var mh$ = MagickLevelizeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickEdgeImage", x0, x1); + traceDowncall("MagickLevelizeImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickEmbossImage { + private static class MagickLinearStretchImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, @@ -9076,7 +23621,7 @@ private static class MagickEmbossImage { MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickEmbossImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickLinearStretchImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9084,43 +23629,43 @@ private static class MagickEmbossImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickEmbossImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickLinearStretchImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickEmbossImage$descriptor() { - return MagickEmbossImage.DESC; + public static FunctionDescriptor MagickLinearStretchImage$descriptor() { + return MagickLinearStretchImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickEmbossImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickLinearStretchImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickEmbossImage$handle() { - return MagickEmbossImage.HANDLE; + public static MethodHandle MagickLinearStretchImage$handle() { + return MagickLinearStretchImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickEmbossImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickLinearStretchImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickEmbossImage$address() { - return MagickEmbossImage.ADDR; + public static MemorySegment MagickLinearStretchImage$address() { + return MagickLinearStretchImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickEmbossImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickLinearStretchImage(MagickWand *, const double, const double) * } */ - public static int MagickEmbossImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickEmbossImage.HANDLE; + public static int MagickLinearStretchImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickLinearStretchImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickEmbossImage", x0, x1, x2); + traceDowncall("MagickLinearStretchImage", x0, x1, x2); } return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { @@ -9128,14 +23673,17 @@ public static int MagickEmbossImage(MemorySegment x0, double x1, double x2) { } } - private static class MagickEncipherImage { + private static class MagickLiquidRescaleImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickEncipherImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickLiquidRescaleImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9143,57 +23691,59 @@ private static class MagickEncipherImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickEncipherImage(MagickWand *, const char *) + * extern MagickBooleanType MagickLiquidRescaleImage(MagickWand *, const size_t, const size_t, const double, const double) * } */ - public static FunctionDescriptor MagickEncipherImage$descriptor() { - return MagickEncipherImage.DESC; + public static FunctionDescriptor MagickLiquidRescaleImage$descriptor() { + return MagickLiquidRescaleImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickEncipherImage(MagickWand *, const char *) + * extern MagickBooleanType MagickLiquidRescaleImage(MagickWand *, const size_t, const size_t, const double, const double) * } */ - public static MethodHandle MagickEncipherImage$handle() { - return MagickEncipherImage.HANDLE; + public static MethodHandle MagickLiquidRescaleImage$handle() { + return MagickLiquidRescaleImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickEncipherImage(MagickWand *, const char *) + * extern MagickBooleanType MagickLiquidRescaleImage(MagickWand *, const size_t, const size_t, const double, const double) * } */ - public static MemorySegment MagickEncipherImage$address() { - return MagickEncipherImage.ADDR; + public static MemorySegment MagickLiquidRescaleImage$address() { + return MagickLiquidRescaleImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickEncipherImage(MagickWand *, const char *) + * extern MagickBooleanType MagickLiquidRescaleImage(MagickWand *, const size_t, const size_t, const double, const double) * } */ - public static int MagickEncipherImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickEncipherImage.HANDLE; + public static int MagickLiquidRescaleImage(MemorySegment x0, long x1, long x2, double x3, double x4) { + var mh$ = MagickLiquidRescaleImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickEncipherImage", x0, x1); + traceDowncall("MagickLiquidRescaleImage", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickEnhanceImage { + private static class MagickLocalContrastImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickEnhanceImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickLocalContrastImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9201,57 +23751,57 @@ private static class MagickEnhanceImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickEnhanceImage(MagickWand *) + * extern MagickBooleanType MagickLocalContrastImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickEnhanceImage$descriptor() { - return MagickEnhanceImage.DESC; + public static FunctionDescriptor MagickLocalContrastImage$descriptor() { + return MagickLocalContrastImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickEnhanceImage(MagickWand *) + * extern MagickBooleanType MagickLocalContrastImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickEnhanceImage$handle() { - return MagickEnhanceImage.HANDLE; + public static MethodHandle MagickLocalContrastImage$handle() { + return MagickLocalContrastImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickEnhanceImage(MagickWand *) + * extern MagickBooleanType MagickLocalContrastImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickEnhanceImage$address() { - return MagickEnhanceImage.ADDR; + public static MemorySegment MagickLocalContrastImage$address() { + return MagickLocalContrastImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickEnhanceImage(MagickWand *) + * extern MagickBooleanType MagickLocalContrastImage(MagickWand *, const double, const double) * } */ - public static int MagickEnhanceImage(MemorySegment x0) { - var mh$ = MagickEnhanceImage.HANDLE; + public static int MagickLocalContrastImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickLocalContrastImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickEnhanceImage", x0); + traceDowncall("MagickLocalContrastImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickEqualizeImage { + private static class MagickMagnifyImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickEqualizeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMagnifyImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9259,43 +23809,43 @@ private static class MagickEqualizeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickEqualizeImage(MagickWand *) + * extern MagickBooleanType MagickMagnifyImage(MagickWand *) * } */ - public static FunctionDescriptor MagickEqualizeImage$descriptor() { - return MagickEqualizeImage.DESC; + public static FunctionDescriptor MagickMagnifyImage$descriptor() { + return MagickMagnifyImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickEqualizeImage(MagickWand *) + * extern MagickBooleanType MagickMagnifyImage(MagickWand *) * } */ - public static MethodHandle MagickEqualizeImage$handle() { - return MagickEqualizeImage.HANDLE; + public static MethodHandle MagickMagnifyImage$handle() { + return MagickMagnifyImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickEqualizeImage(MagickWand *) + * extern MagickBooleanType MagickMagnifyImage(MagickWand *) * } */ - public static MemorySegment MagickEqualizeImage$address() { - return MagickEqualizeImage.ADDR; + public static MemorySegment MagickMagnifyImage$address() { + return MagickMagnifyImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickEqualizeImage(MagickWand *) + * extern MagickBooleanType MagickMagnifyImage(MagickWand *) * } */ - public static int MagickEqualizeImage(MemorySegment x0) { - var mh$ = MagickEqualizeImage.HANDLE; + public static int MagickMagnifyImage(MemorySegment x0) { + var mh$ = MagickMagnifyImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickEqualizeImage", x0); + traceDowncall("MagickMagnifyImage", x0); } return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { @@ -9303,15 +23853,16 @@ public static int MagickEqualizeImage(MemorySegment x0) { } } - private static class MagickEvaluateImage { + private static class MagickMeanShiftImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickEvaluateImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMeanShiftImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9319,64 +23870,57 @@ private static class MagickEvaluateImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickEvaluateImage(MagickWand *, const MagickEvaluateOperator, const double) + * extern MagickBooleanType MagickMeanShiftImage(MagickWand *, const size_t, const size_t, const double) * } */ - public static FunctionDescriptor MagickEvaluateImage$descriptor() { - return MagickEvaluateImage.DESC; + public static FunctionDescriptor MagickMeanShiftImage$descriptor() { + return MagickMeanShiftImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickEvaluateImage(MagickWand *, const MagickEvaluateOperator, const double) + * extern MagickBooleanType MagickMeanShiftImage(MagickWand *, const size_t, const size_t, const double) * } */ - public static MethodHandle MagickEvaluateImage$handle() { - return MagickEvaluateImage.HANDLE; + public static MethodHandle MagickMeanShiftImage$handle() { + return MagickMeanShiftImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickEvaluateImage(MagickWand *, const MagickEvaluateOperator, const double) + * extern MagickBooleanType MagickMeanShiftImage(MagickWand *, const size_t, const size_t, const double) * } */ - public static MemorySegment MagickEvaluateImage$address() { - return MagickEvaluateImage.ADDR; + public static MemorySegment MagickMeanShiftImage$address() { + return MagickMeanShiftImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickEvaluateImage(MagickWand *, const MagickEvaluateOperator, const double) + * extern MagickBooleanType MagickMeanShiftImage(MagickWand *, const size_t, const size_t, const double) * } */ - public static int MagickEvaluateImage(MemorySegment x0, int x1, double x2) { - var mh$ = MagickEvaluateImage.HANDLE; + public static int MagickMeanShiftImage(MemorySegment x0, long x1, long x2, double x3) { + var mh$ = MagickMeanShiftImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickEvaluateImage", x0, x1, x2); + traceDowncall("MagickMeanShiftImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickExportImagePixels { + private static class MagickMinifyImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_POINTER, MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickExportImagePixels"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMinifyImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9384,61 +23928,58 @@ private static class MagickExportImagePixels { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickExportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, void *) + * extern MagickBooleanType MagickMinifyImage(MagickWand *) * } */ - public static FunctionDescriptor MagickExportImagePixels$descriptor() { - return MagickExportImagePixels.DESC; + public static FunctionDescriptor MagickMinifyImage$descriptor() { + return MagickMinifyImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickExportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, void *) + * extern MagickBooleanType MagickMinifyImage(MagickWand *) * } */ - public static MethodHandle MagickExportImagePixels$handle() { - return MagickExportImagePixels.HANDLE; + public static MethodHandle MagickMinifyImage$handle() { + return MagickMinifyImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickExportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, void *) + * extern MagickBooleanType MagickMinifyImage(MagickWand *) * } */ - public static MemorySegment MagickExportImagePixels$address() { - return MagickExportImagePixels.ADDR; + public static MemorySegment MagickMinifyImage$address() { + return MagickMinifyImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickExportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, void *) + * extern MagickBooleanType MagickMinifyImage(MagickWand *) * } */ - public static int MagickExportImagePixels(MemorySegment x0, long x1, long x2, long x3, long x4, MemorySegment x5, int x6, MemorySegment x7) { - var mh$ = MagickExportImagePixels.HANDLE; + public static int MagickMinifyImage(MemorySegment x0) { + var mh$ = MagickMinifyImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickExportImagePixels", x0, x1, x2, x3, x4, x5, x6, x7); + traceDowncall("MagickMinifyImage", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5, x6, x7); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickExtentImage { + private static class MagickModeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickExtentImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickModeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9446,57 +23987,60 @@ private static class MagickExtentImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickExtentImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickModeImage(MagickWand *, const double) * } */ - public static FunctionDescriptor MagickExtentImage$descriptor() { - return MagickExtentImage.DESC; + public static FunctionDescriptor MagickModeImage$descriptor() { + return MagickModeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickExtentImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickModeImage(MagickWand *, const double) * } */ - public static MethodHandle MagickExtentImage$handle() { - return MagickExtentImage.HANDLE; + public static MethodHandle MagickModeImage$handle() { + return MagickModeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickExtentImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickModeImage(MagickWand *, const double) * } */ - public static MemorySegment MagickExtentImage$address() { - return MagickExtentImage.ADDR; + public static MemorySegment MagickModeImage$address() { + return MagickModeImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickExtentImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickModeImage(MagickWand *, const double) * } */ - public static int MagickExtentImage(MemorySegment x0, long x1, long x2, long x3, long x4) { - var mh$ = MagickExtentImage.HANDLE; + public static int MagickModeImage(MemorySegment x0, double x1) { + var mh$ = MagickModeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickExtentImage", x0, x1, x2, x3, x4); + traceDowncall("MagickModeImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickFlipImage { + private static class MagickModulateImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickFlipImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickModulateImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9504,63 +24048,60 @@ private static class MagickFlipImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickFlipImage(MagickWand *) + * extern MagickBooleanType MagickModulateImage(MagickWand *, const double, const double, const double) * } */ - public static FunctionDescriptor MagickFlipImage$descriptor() { - return MagickFlipImage.DESC; + public static FunctionDescriptor MagickModulateImage$descriptor() { + return MagickModulateImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickFlipImage(MagickWand *) + * extern MagickBooleanType MagickModulateImage(MagickWand *, const double, const double, const double) * } */ - public static MethodHandle MagickFlipImage$handle() { - return MagickFlipImage.HANDLE; + public static MethodHandle MagickModulateImage$handle() { + return MagickModulateImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickFlipImage(MagickWand *) + * extern MagickBooleanType MagickModulateImage(MagickWand *, const double, const double, const double) * } */ - public static MemorySegment MagickFlipImage$address() { - return MagickFlipImage.ADDR; + public static MemorySegment MagickModulateImage$address() { + return MagickModulateImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickFlipImage(MagickWand *) + * extern MagickBooleanType MagickModulateImage(MagickWand *, const double, const double, const double) * } */ - public static int MagickFlipImage(MemorySegment x0) { - var mh$ = MagickFlipImage.HANDLE; + public static int MagickModulateImage(MemorySegment x0, double x1, double x2, double x3) { + var mh$ = MagickModulateImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickFlipImage", x0); + traceDowncall("MagickModulateImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickFloodfillPaintImage { + private static class MagickMorphologyImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, + MagickWand_h.C_INT, MagickWand_h.C_LONG, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickFloodfillPaintImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMorphologyImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9568,57 +24109,60 @@ private static class MagickFloodfillPaintImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickFloodfillPaintImage(MagickWand *, const PixelWand *, const double, const PixelWand *, const ssize_t, const ssize_t, const MagickBooleanType) + * extern MagickBooleanType MagickMorphologyImage(MagickWand *, const MorphologyMethod, const ssize_t, const KernelInfo *) * } */ - public static FunctionDescriptor MagickFloodfillPaintImage$descriptor() { - return MagickFloodfillPaintImage.DESC; + public static FunctionDescriptor MagickMorphologyImage$descriptor() { + return MagickMorphologyImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickFloodfillPaintImage(MagickWand *, const PixelWand *, const double, const PixelWand *, const ssize_t, const ssize_t, const MagickBooleanType) + * extern MagickBooleanType MagickMorphologyImage(MagickWand *, const MorphologyMethod, const ssize_t, const KernelInfo *) * } */ - public static MethodHandle MagickFloodfillPaintImage$handle() { - return MagickFloodfillPaintImage.HANDLE; + public static MethodHandle MagickMorphologyImage$handle() { + return MagickMorphologyImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickFloodfillPaintImage(MagickWand *, const PixelWand *, const double, const PixelWand *, const ssize_t, const ssize_t, const MagickBooleanType) + * extern MagickBooleanType MagickMorphologyImage(MagickWand *, const MorphologyMethod, const ssize_t, const KernelInfo *) * } */ - public static MemorySegment MagickFloodfillPaintImage$address() { - return MagickFloodfillPaintImage.ADDR; + public static MemorySegment MagickMorphologyImage$address() { + return MagickMorphologyImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickFloodfillPaintImage(MagickWand *, const PixelWand *, const double, const PixelWand *, const ssize_t, const ssize_t, const MagickBooleanType) + * extern MagickBooleanType MagickMorphologyImage(MagickWand *, const MorphologyMethod, const ssize_t, const KernelInfo *) * } */ - public static int MagickFloodfillPaintImage(MemorySegment x0, MemorySegment x1, double x2, MemorySegment x3, long x4, long x5, int x6) { - var mh$ = MagickFloodfillPaintImage.HANDLE; + public static int MagickMorphologyImage(MemorySegment x0, int x1, long x2, MemorySegment x3) { + var mh$ = MagickMorphologyImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickFloodfillPaintImage", x0, x1, x2, x3, x4, x5, x6); + traceDowncall("MagickMorphologyImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5, x6); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickFlopImage { + private static class MagickMotionBlurImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickFlopImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMotionBlurImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9626,58 +24170,58 @@ private static class MagickFlopImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickFlopImage(MagickWand *) + * extern MagickBooleanType MagickMotionBlurImage(MagickWand *, const double, const double, const double) * } */ - public static FunctionDescriptor MagickFlopImage$descriptor() { - return MagickFlopImage.DESC; + public static FunctionDescriptor MagickMotionBlurImage$descriptor() { + return MagickMotionBlurImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickFlopImage(MagickWand *) + * extern MagickBooleanType MagickMotionBlurImage(MagickWand *, const double, const double, const double) * } */ - public static MethodHandle MagickFlopImage$handle() { - return MagickFlopImage.HANDLE; + public static MethodHandle MagickMotionBlurImage$handle() { + return MagickMotionBlurImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickFlopImage(MagickWand *) + * extern MagickBooleanType MagickMotionBlurImage(MagickWand *, const double, const double, const double) * } */ - public static MemorySegment MagickFlopImage$address() { - return MagickFlopImage.ADDR; + public static MemorySegment MagickMotionBlurImage$address() { + return MagickMotionBlurImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickFlopImage(MagickWand *) + * extern MagickBooleanType MagickMotionBlurImage(MagickWand *, const double, const double, const double) * } */ - public static int MagickFlopImage(MemorySegment x0) { - var mh$ = MagickFlopImage.HANDLE; + public static int MagickMotionBlurImage(MemorySegment x0, double x1, double x2, double x3) { + var mh$ = MagickMotionBlurImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickFlopImage", x0); + traceDowncall("MagickMotionBlurImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickForwardFourierTransformImage { + private static class MagickNegateImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickForwardFourierTransformImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickNegateImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9685,43 +24229,43 @@ private static class MagickForwardFourierTransformImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickForwardFourierTransformImage(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickNegateImage(MagickWand *, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickForwardFourierTransformImage$descriptor() { - return MagickForwardFourierTransformImage.DESC; + public static FunctionDescriptor MagickNegateImage$descriptor() { + return MagickNegateImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickForwardFourierTransformImage(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickNegateImage(MagickWand *, const MagickBooleanType) * } */ - public static MethodHandle MagickForwardFourierTransformImage$handle() { - return MagickForwardFourierTransformImage.HANDLE; + public static MethodHandle MagickNegateImage$handle() { + return MagickNegateImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickForwardFourierTransformImage(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickNegateImage(MagickWand *, const MagickBooleanType) * } */ - public static MemorySegment MagickForwardFourierTransformImage$address() { - return MagickForwardFourierTransformImage.ADDR; + public static MemorySegment MagickNegateImage$address() { + return MagickNegateImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickForwardFourierTransformImage(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickNegateImage(MagickWand *, const MagickBooleanType) * } */ - public static int MagickForwardFourierTransformImage(MemorySegment x0, int x1) { - var mh$ = MagickForwardFourierTransformImage.HANDLE; + public static int MagickNegateImage(MemorySegment x0, int x1) { + var mh$ = MagickNegateImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickForwardFourierTransformImage", x0, x1); + traceDowncall("MagickNegateImage", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -9729,19 +24273,16 @@ public static int MagickForwardFourierTransformImage(MemorySegment x0, int x1) { } } - private static class MagickFrameImage { + private static class MagickNewImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, MagickWand_h.C_LONG, MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickFrameImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickNewImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9749,60 +24290,57 @@ private static class MagickFrameImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickFrameImage(MagickWand *, const PixelWand *, const size_t, const size_t, const ssize_t, const ssize_t, const CompositeOperator) + * extern MagickBooleanType MagickNewImage(MagickWand *, const size_t, const size_t, const PixelWand *) * } */ - public static FunctionDescriptor MagickFrameImage$descriptor() { - return MagickFrameImage.DESC; + public static FunctionDescriptor MagickNewImage$descriptor() { + return MagickNewImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickFrameImage(MagickWand *, const PixelWand *, const size_t, const size_t, const ssize_t, const ssize_t, const CompositeOperator) + * extern MagickBooleanType MagickNewImage(MagickWand *, const size_t, const size_t, const PixelWand *) * } */ - public static MethodHandle MagickFrameImage$handle() { - return MagickFrameImage.HANDLE; + public static MethodHandle MagickNewImage$handle() { + return MagickNewImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickFrameImage(MagickWand *, const PixelWand *, const size_t, const size_t, const ssize_t, const ssize_t, const CompositeOperator) + * extern MagickBooleanType MagickNewImage(MagickWand *, const size_t, const size_t, const PixelWand *) * } */ - public static MemorySegment MagickFrameImage$address() { - return MagickFrameImage.ADDR; + public static MemorySegment MagickNewImage$address() { + return MagickNewImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickFrameImage(MagickWand *, const PixelWand *, const size_t, const size_t, const ssize_t, const ssize_t, const CompositeOperator) + * extern MagickBooleanType MagickNewImage(MagickWand *, const size_t, const size_t, const PixelWand *) * } */ - public static int MagickFrameImage(MemorySegment x0, MemorySegment x1, long x2, long x3, long x4, long x5, int x6) { - var mh$ = MagickFrameImage.HANDLE; + public static int MagickNewImage(MemorySegment x0, long x1, long x2, MemorySegment x3) { + var mh$ = MagickNewImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickFrameImage", x0, x1, x2, x3, x4, x5, x6); + traceDowncall("MagickNewImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5, x6); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickFunctionImage { + private static class MagickNextImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_LONG, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickFunctionImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickNextImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9810,58 +24348,57 @@ private static class MagickFunctionImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickFunctionImage(MagickWand *, const MagickFunction, const size_t, const double *) + * extern MagickBooleanType MagickNextImage(MagickWand *) * } */ - public static FunctionDescriptor MagickFunctionImage$descriptor() { - return MagickFunctionImage.DESC; + public static FunctionDescriptor MagickNextImage$descriptor() { + return MagickNextImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickFunctionImage(MagickWand *, const MagickFunction, const size_t, const double *) + * extern MagickBooleanType MagickNextImage(MagickWand *) * } */ - public static MethodHandle MagickFunctionImage$handle() { - return MagickFunctionImage.HANDLE; + public static MethodHandle MagickNextImage$handle() { + return MagickNextImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickFunctionImage(MagickWand *, const MagickFunction, const size_t, const double *) + * extern MagickBooleanType MagickNextImage(MagickWand *) * } */ - public static MemorySegment MagickFunctionImage$address() { - return MagickFunctionImage.ADDR; + public static MemorySegment MagickNextImage$address() { + return MagickNextImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickFunctionImage(MagickWand *, const MagickFunction, const size_t, const double *) + * extern MagickBooleanType MagickNextImage(MagickWand *) * } */ - public static int MagickFunctionImage(MemorySegment x0, int x1, long x2, MemorySegment x3) { - var mh$ = MagickFunctionImage.HANDLE; + public static int MagickNextImage(MemorySegment x0) { + var mh$ = MagickNextImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickFunctionImage", x0, x1, x2, x3); + traceDowncall("MagickNextImage", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGammaImage { + private static class MagickNormalizeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGammaImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickNormalizeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9869,51 +24406,51 @@ private static class MagickGammaImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGammaImage(MagickWand *, const double) + * extern MagickBooleanType MagickNormalizeImage(MagickWand *) * } */ - public static FunctionDescriptor MagickGammaImage$descriptor() { - return MagickGammaImage.DESC; + public static FunctionDescriptor MagickNormalizeImage$descriptor() { + return MagickNormalizeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGammaImage(MagickWand *, const double) + * extern MagickBooleanType MagickNormalizeImage(MagickWand *) * } */ - public static MethodHandle MagickGammaImage$handle() { - return MagickGammaImage.HANDLE; + public static MethodHandle MagickNormalizeImage$handle() { + return MagickNormalizeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGammaImage(MagickWand *, const double) + * extern MagickBooleanType MagickNormalizeImage(MagickWand *) * } */ - public static MemorySegment MagickGammaImage$address() { - return MagickGammaImage.ADDR; + public static MemorySegment MagickNormalizeImage$address() { + return MagickNormalizeImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGammaImage(MagickWand *, const double) + * extern MagickBooleanType MagickNormalizeImage(MagickWand *) * } */ - public static int MagickGammaImage(MemorySegment x0, double x1) { - var mh$ = MagickGammaImage.HANDLE; + public static int MagickNormalizeImage(MemorySegment x0) { + var mh$ = MagickNormalizeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGammaImage", x0, x1); + traceDowncall("MagickNormalizeImage", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGaussianBlurImage { + private static class MagickOilPaintImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, @@ -9921,7 +24458,7 @@ private static class MagickGaussianBlurImage { MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGaussianBlurImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickOilPaintImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9929,43 +24466,43 @@ private static class MagickGaussianBlurImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGaussianBlurImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickOilPaintImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickGaussianBlurImage$descriptor() { - return MagickGaussianBlurImage.DESC; + public static FunctionDescriptor MagickOilPaintImage$descriptor() { + return MagickOilPaintImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGaussianBlurImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickOilPaintImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickGaussianBlurImage$handle() { - return MagickGaussianBlurImage.HANDLE; + public static MethodHandle MagickOilPaintImage$handle() { + return MagickOilPaintImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGaussianBlurImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickOilPaintImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickGaussianBlurImage$address() { - return MagickGaussianBlurImage.ADDR; + public static MemorySegment MagickOilPaintImage$address() { + return MagickOilPaintImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGaussianBlurImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickOilPaintImage(MagickWand *, const double, const double) * } */ - public static int MagickGaussianBlurImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickGaussianBlurImage.HANDLE; + public static int MagickOilPaintImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickOilPaintImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGaussianBlurImage", x0, x1, x2); + traceDowncall("MagickOilPaintImage", x0, x1, x2); } return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { @@ -9973,13 +24510,17 @@ public static int MagickGaussianBlurImage(MemorySegment x0, double x1, double x2 } } - private static class MagickGetImageAlphaChannel { + private static class MagickOpaquePaintImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageAlphaChannel"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickOpaquePaintImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -9987,58 +24528,57 @@ private static class MagickGetImageAlphaChannel { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageAlphaChannel(MagickWand *) + * extern MagickBooleanType MagickOpaquePaintImage(MagickWand *, const PixelWand *, const PixelWand *, const double, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickGetImageAlphaChannel$descriptor() { - return MagickGetImageAlphaChannel.DESC; + public static FunctionDescriptor MagickOpaquePaintImage$descriptor() { + return MagickOpaquePaintImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageAlphaChannel(MagickWand *) + * extern MagickBooleanType MagickOpaquePaintImage(MagickWand *, const PixelWand *, const PixelWand *, const double, const MagickBooleanType) * } */ - public static MethodHandle MagickGetImageAlphaChannel$handle() { - return MagickGetImageAlphaChannel.HANDLE; + public static MethodHandle MagickOpaquePaintImage$handle() { + return MagickOpaquePaintImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageAlphaChannel(MagickWand *) + * extern MagickBooleanType MagickOpaquePaintImage(MagickWand *, const PixelWand *, const PixelWand *, const double, const MagickBooleanType) * } */ - public static MemorySegment MagickGetImageAlphaChannel$address() { - return MagickGetImageAlphaChannel.ADDR; + public static MemorySegment MagickOpaquePaintImage$address() { + return MagickOpaquePaintImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageAlphaChannel(MagickWand *) + * extern MagickBooleanType MagickOpaquePaintImage(MagickWand *, const PixelWand *, const PixelWand *, const double, const MagickBooleanType) * } */ - public static int MagickGetImageAlphaChannel(MemorySegment x0) { - var mh$ = MagickGetImageAlphaChannel.HANDLE; + public static int MagickOpaquePaintImage(MemorySegment x0, MemorySegment x1, MemorySegment x2, double x3, int x4) { + var mh$ = MagickOpaquePaintImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageAlphaChannel", x0); + traceDowncall("MagickOpaquePaintImage", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageBackgroundColor { + private static class MagickOptimizeImageTransparency { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageBackgroundColor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickOptimizeImageTransparency"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10046,60 +24586,58 @@ private static class MagickGetImageBackgroundColor { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageBackgroundColor(MagickWand *, PixelWand *) + * extern MagickBooleanType MagickOptimizeImageTransparency(MagickWand *) * } */ - public static FunctionDescriptor MagickGetImageBackgroundColor$descriptor() { - return MagickGetImageBackgroundColor.DESC; + public static FunctionDescriptor MagickOptimizeImageTransparency$descriptor() { + return MagickOptimizeImageTransparency.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageBackgroundColor(MagickWand *, PixelWand *) + * extern MagickBooleanType MagickOptimizeImageTransparency(MagickWand *) * } */ - public static MethodHandle MagickGetImageBackgroundColor$handle() { - return MagickGetImageBackgroundColor.HANDLE; + public static MethodHandle MagickOptimizeImageTransparency$handle() { + return MagickOptimizeImageTransparency.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageBackgroundColor(MagickWand *, PixelWand *) + * extern MagickBooleanType MagickOptimizeImageTransparency(MagickWand *) * } */ - public static MemorySegment MagickGetImageBackgroundColor$address() { - return MagickGetImageBackgroundColor.ADDR; + public static MemorySegment MagickOptimizeImageTransparency$address() { + return MagickOptimizeImageTransparency.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageBackgroundColor(MagickWand *, PixelWand *) + * extern MagickBooleanType MagickOptimizeImageTransparency(MagickWand *) * } */ - public static int MagickGetImageBackgroundColor(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickGetImageBackgroundColor.HANDLE; + public static int MagickOptimizeImageTransparency(MemorySegment x0) { + var mh$ = MagickOptimizeImageTransparency.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageBackgroundColor", x0, x1); + traceDowncall("MagickOptimizeImageTransparency", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageBluePrimary { + private static class MagickOrderedDitherImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageBluePrimary"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickOrderedDitherImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10107,58 +24645,59 @@ private static class MagickGetImageBluePrimary { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageBluePrimary(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickOrderedDitherImage(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickGetImageBluePrimary$descriptor() { - return MagickGetImageBluePrimary.DESC; + public static FunctionDescriptor MagickOrderedDitherImage$descriptor() { + return MagickOrderedDitherImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageBluePrimary(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickOrderedDitherImage(MagickWand *, const char *) * } */ - public static MethodHandle MagickGetImageBluePrimary$handle() { - return MagickGetImageBluePrimary.HANDLE; + public static MethodHandle MagickOrderedDitherImage$handle() { + return MagickOrderedDitherImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageBluePrimary(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickOrderedDitherImage(MagickWand *, const char *) * } */ - public static MemorySegment MagickGetImageBluePrimary$address() { - return MagickGetImageBluePrimary.ADDR; + public static MemorySegment MagickOrderedDitherImage$address() { + return MagickOrderedDitherImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageBluePrimary(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickOrderedDitherImage(MagickWand *, const char *) * } */ - public static int MagickGetImageBluePrimary(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { - var mh$ = MagickGetImageBluePrimary.HANDLE; + public static int MagickOrderedDitherImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickOrderedDitherImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageBluePrimary", x0, x1, x2, x3); + traceDowncall("MagickOrderedDitherImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageBorderColor { + private static class MagickPolynomialImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageBorderColor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPolynomialImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10166,59 +24705,61 @@ private static class MagickGetImageBorderColor { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageBorderColor(MagickWand *, PixelWand *) + * extern MagickBooleanType MagickPolynomialImage(MagickWand *, const size_t, const double *) * } */ - public static FunctionDescriptor MagickGetImageBorderColor$descriptor() { - return MagickGetImageBorderColor.DESC; + public static FunctionDescriptor MagickPolynomialImage$descriptor() { + return MagickPolynomialImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageBorderColor(MagickWand *, PixelWand *) + * extern MagickBooleanType MagickPolynomialImage(MagickWand *, const size_t, const double *) * } */ - public static MethodHandle MagickGetImageBorderColor$handle() { - return MagickGetImageBorderColor.HANDLE; + public static MethodHandle MagickPolynomialImage$handle() { + return MagickPolynomialImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageBorderColor(MagickWand *, PixelWand *) + * extern MagickBooleanType MagickPolynomialImage(MagickWand *, const size_t, const double *) * } */ - public static MemorySegment MagickGetImageBorderColor$address() { - return MagickGetImageBorderColor.ADDR; + public static MemorySegment MagickPolynomialImage$address() { + return MagickPolynomialImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageBorderColor(MagickWand *, PixelWand *) + * extern MagickBooleanType MagickPolynomialImage(MagickWand *, const size_t, const double *) * } */ - public static int MagickGetImageBorderColor(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickGetImageBorderColor.HANDLE; + public static int MagickPolynomialImage(MemorySegment x0, long x1, MemorySegment x2) { + var mh$ = MagickPolynomialImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageBorderColor", x0, x1); + traceDowncall("MagickPolynomialImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageKurtosis { + private static class MagickTransparentPaintImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageKurtosis"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickTransparentPaintImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10226,59 +24767,58 @@ private static class MagickGetImageKurtosis { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageKurtosis(MagickWand *, double *, double *) + * extern MagickBooleanType MagickTransparentPaintImage(MagickWand *, const PixelWand *, const double, const double, const MagickBooleanType invert) * } */ - public static FunctionDescriptor MagickGetImageKurtosis$descriptor() { - return MagickGetImageKurtosis.DESC; + public static FunctionDescriptor MagickTransparentPaintImage$descriptor() { + return MagickTransparentPaintImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageKurtosis(MagickWand *, double *, double *) + * extern MagickBooleanType MagickTransparentPaintImage(MagickWand *, const PixelWand *, const double, const double, const MagickBooleanType invert) * } */ - public static MethodHandle MagickGetImageKurtosis$handle() { - return MagickGetImageKurtosis.HANDLE; + public static MethodHandle MagickTransparentPaintImage$handle() { + return MagickTransparentPaintImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageKurtosis(MagickWand *, double *, double *) + * extern MagickBooleanType MagickTransparentPaintImage(MagickWand *, const PixelWand *, const double, const double, const MagickBooleanType invert) * } */ - public static MemorySegment MagickGetImageKurtosis$address() { - return MagickGetImageKurtosis.ADDR; + public static MemorySegment MagickTransparentPaintImage$address() { + return MagickTransparentPaintImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageKurtosis(MagickWand *, double *, double *) + * extern MagickBooleanType MagickTransparentPaintImage(MagickWand *, const PixelWand *, const double, const double, const MagickBooleanType invert) * } */ - public static int MagickGetImageKurtosis(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickGetImageKurtosis.HANDLE; + public static int MagickTransparentPaintImage(MemorySegment x0, MemorySegment x1, double x2, double x3, int invert) { + var mh$ = MagickTransparentPaintImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageKurtosis", x0, x1, x2); + traceDowncall("MagickTransparentPaintImage", x0, x1, x2, x3, invert); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2, x3, invert); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageMean { + private static class MagickPingImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageMean"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPingImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10286,59 +24826,59 @@ private static class MagickGetImageMean { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageMean(MagickWand *, double *, double *) + * extern MagickBooleanType MagickPingImage(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickGetImageMean$descriptor() { - return MagickGetImageMean.DESC; + public static FunctionDescriptor MagickPingImage$descriptor() { + return MagickPingImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageMean(MagickWand *, double *, double *) + * extern MagickBooleanType MagickPingImage(MagickWand *, const char *) * } */ - public static MethodHandle MagickGetImageMean$handle() { - return MagickGetImageMean.HANDLE; + public static MethodHandle MagickPingImage$handle() { + return MagickPingImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageMean(MagickWand *, double *, double *) + * extern MagickBooleanType MagickPingImage(MagickWand *, const char *) * } */ - public static MemorySegment MagickGetImageMean$address() { - return MagickGetImageMean.ADDR; + public static MemorySegment MagickPingImage$address() { + return MagickPingImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageMean(MagickWand *, double *, double *) + * extern MagickBooleanType MagickPingImage(MagickWand *, const char *) * } */ - public static int MagickGetImageMean(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickGetImageMean.HANDLE; + public static int MagickPingImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickPingImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageMean", x0, x1, x2); + traceDowncall("MagickPingImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageRange { + private static class MagickPingImageBlob { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageRange"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPingImageBlob"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10346,43 +24886,43 @@ private static class MagickGetImageRange { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageRange(MagickWand *, double *, double *) + * extern MagickBooleanType MagickPingImageBlob(MagickWand *, const void *, const size_t) * } */ - public static FunctionDescriptor MagickGetImageRange$descriptor() { - return MagickGetImageRange.DESC; + public static FunctionDescriptor MagickPingImageBlob$descriptor() { + return MagickPingImageBlob.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageRange(MagickWand *, double *, double *) + * extern MagickBooleanType MagickPingImageBlob(MagickWand *, const void *, const size_t) * } */ - public static MethodHandle MagickGetImageRange$handle() { - return MagickGetImageRange.HANDLE; + public static MethodHandle MagickPingImageBlob$handle() { + return MagickPingImageBlob.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageRange(MagickWand *, double *, double *) + * extern MagickBooleanType MagickPingImageBlob(MagickWand *, const void *, const size_t) * } */ - public static MemorySegment MagickGetImageRange$address() { - return MagickGetImageRange.ADDR; + public static MemorySegment MagickPingImageBlob$address() { + return MagickPingImageBlob.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageRange(MagickWand *, double *, double *) + * extern MagickBooleanType MagickPingImageBlob(MagickWand *, const void *, const size_t) * } */ - public static int MagickGetImageRange(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickGetImageRange.HANDLE; + public static int MagickPingImageBlob(MemorySegment x0, MemorySegment x1, long x2) { + var mh$ = MagickPingImageBlob.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageRange", x0, x1, x2); + traceDowncall("MagickPingImageBlob", x0, x1, x2); } return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { @@ -10390,15 +24930,14 @@ public static int MagickGetImageRange(MemorySegment x0, MemorySegment x1, Memory } } - private static class MagickGetImageColormapColor { + private static class MagickPingImageFile { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageColormapColor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPingImageFile"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10406,60 +24945,61 @@ private static class MagickGetImageColormapColor { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageColormapColor(MagickWand *, const size_t, PixelWand *) + * extern MagickBooleanType MagickPingImageFile(MagickWand *, FILE *) * } */ - public static FunctionDescriptor MagickGetImageColormapColor$descriptor() { - return MagickGetImageColormapColor.DESC; + public static FunctionDescriptor MagickPingImageFile$descriptor() { + return MagickPingImageFile.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageColormapColor(MagickWand *, const size_t, PixelWand *) + * extern MagickBooleanType MagickPingImageFile(MagickWand *, FILE *) * } */ - public static MethodHandle MagickGetImageColormapColor$handle() { - return MagickGetImageColormapColor.HANDLE; + public static MethodHandle MagickPingImageFile$handle() { + return MagickPingImageFile.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageColormapColor(MagickWand *, const size_t, PixelWand *) + * extern MagickBooleanType MagickPingImageFile(MagickWand *, FILE *) * } */ - public static MemorySegment MagickGetImageColormapColor$address() { - return MagickGetImageColormapColor.ADDR; + public static MemorySegment MagickPingImageFile$address() { + return MagickPingImageFile.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageColormapColor(MagickWand *, const size_t, PixelWand *) + * extern MagickBooleanType MagickPingImageFile(MagickWand *, FILE *) * } */ - public static int MagickGetImageColormapColor(MemorySegment x0, long x1, MemorySegment x2) { - var mh$ = MagickGetImageColormapColor.HANDLE; + public static int MagickPingImageFile(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickPingImageFile.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageColormapColor", x0, x1, x2); + traceDowncall("MagickPingImageFile", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageDistortion { + private static class MagickPolaroidImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageDistortion"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPolaroidImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10467,60 +25007,59 @@ private static class MagickGetImageDistortion { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageDistortion(MagickWand *, const MagickWand *, const MetricType, double *) + * extern MagickBooleanType MagickPolaroidImage(MagickWand *, const DrawingWand *, const char *, const double, const PixelInterpolateMethod) * } */ - public static FunctionDescriptor MagickGetImageDistortion$descriptor() { - return MagickGetImageDistortion.DESC; + public static FunctionDescriptor MagickPolaroidImage$descriptor() { + return MagickPolaroidImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageDistortion(MagickWand *, const MagickWand *, const MetricType, double *) + * extern MagickBooleanType MagickPolaroidImage(MagickWand *, const DrawingWand *, const char *, const double, const PixelInterpolateMethod) * } */ - public static MethodHandle MagickGetImageDistortion$handle() { - return MagickGetImageDistortion.HANDLE; + public static MethodHandle MagickPolaroidImage$handle() { + return MagickPolaroidImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageDistortion(MagickWand *, const MagickWand *, const MetricType, double *) + * extern MagickBooleanType MagickPolaroidImage(MagickWand *, const DrawingWand *, const char *, const double, const PixelInterpolateMethod) * } */ - public static MemorySegment MagickGetImageDistortion$address() { - return MagickGetImageDistortion.ADDR; + public static MemorySegment MagickPolaroidImage$address() { + return MagickPolaroidImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageDistortion(MagickWand *, const MagickWand *, const MetricType, double *) + * extern MagickBooleanType MagickPolaroidImage(MagickWand *, const DrawingWand *, const char *, const double, const PixelInterpolateMethod) * } */ - public static int MagickGetImageDistortion(MemorySegment x0, MemorySegment x1, int x2, MemorySegment x3) { - var mh$ = MagickGetImageDistortion.HANDLE; + public static int MagickPolaroidImage(MemorySegment x0, MemorySegment x1, MemorySegment x2, double x3, int x4) { + var mh$ = MagickPolaroidImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageDistortion", x0, x1, x2, x3); + traceDowncall("MagickPolaroidImage", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageGreenPrimary { + private static class MagickPosterizeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageGreenPrimary"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPosterizeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10528,58 +25067,57 @@ private static class MagickGetImageGreenPrimary { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageGreenPrimary(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickPosterizeImage(MagickWand *, const size_t, const DitherMethod) * } */ - public static FunctionDescriptor MagickGetImageGreenPrimary$descriptor() { - return MagickGetImageGreenPrimary.DESC; + public static FunctionDescriptor MagickPosterizeImage$descriptor() { + return MagickPosterizeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageGreenPrimary(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickPosterizeImage(MagickWand *, const size_t, const DitherMethod) * } */ - public static MethodHandle MagickGetImageGreenPrimary$handle() { - return MagickGetImageGreenPrimary.HANDLE; + public static MethodHandle MagickPosterizeImage$handle() { + return MagickPosterizeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageGreenPrimary(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickPosterizeImage(MagickWand *, const size_t, const DitherMethod) * } */ - public static MemorySegment MagickGetImageGreenPrimary$address() { - return MagickGetImageGreenPrimary.ADDR; + public static MemorySegment MagickPosterizeImage$address() { + return MagickPosterizeImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageGreenPrimary(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickPosterizeImage(MagickWand *, const size_t, const DitherMethod) * } */ - public static int MagickGetImageGreenPrimary(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { - var mh$ = MagickGetImageGreenPrimary.HANDLE; + public static int MagickPosterizeImage(MemorySegment x0, long x1, int x2) { + var mh$ = MagickPosterizeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageGreenPrimary", x0, x1, x2, x3); + traceDowncall("MagickPosterizeImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageLength { + private static class MagickPreviousImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageLength"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPreviousImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10587,58 +25125,62 @@ private static class MagickGetImageLength { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageLength(MagickWand *, MagickSizeType *) + * extern MagickBooleanType MagickPreviousImage(MagickWand *) * } */ - public static FunctionDescriptor MagickGetImageLength$descriptor() { - return MagickGetImageLength.DESC; + public static FunctionDescriptor MagickPreviousImage$descriptor() { + return MagickPreviousImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageLength(MagickWand *, MagickSizeType *) + * extern MagickBooleanType MagickPreviousImage(MagickWand *) * } */ - public static MethodHandle MagickGetImageLength$handle() { - return MagickGetImageLength.HANDLE; + public static MethodHandle MagickPreviousImage$handle() { + return MagickPreviousImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageLength(MagickWand *, MagickSizeType *) + * extern MagickBooleanType MagickPreviousImage(MagickWand *) * } */ - public static MemorySegment MagickGetImageLength$address() { - return MagickGetImageLength.ADDR; + public static MemorySegment MagickPreviousImage$address() { + return MagickPreviousImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageLength(MagickWand *, MagickSizeType *) + * extern MagickBooleanType MagickPreviousImage(MagickWand *) * } */ - public static int MagickGetImageLength(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickGetImageLength.HANDLE; + public static int MagickPreviousImage(MemorySegment x0) { + var mh$ = MagickPreviousImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageLength", x0, x1); + traceDowncall("MagickPreviousImage", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageMatteColor { + private static class MagickQuantizeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageMatteColor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQuantizeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10646,61 +25188,62 @@ private static class MagickGetImageMatteColor { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageMatteColor(MagickWand *, PixelWand *) + * extern MagickBooleanType MagickQuantizeImage(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickGetImageMatteColor$descriptor() { - return MagickGetImageMatteColor.DESC; + public static FunctionDescriptor MagickQuantizeImage$descriptor() { + return MagickQuantizeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageMatteColor(MagickWand *, PixelWand *) + * extern MagickBooleanType MagickQuantizeImage(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) * } */ - public static MethodHandle MagickGetImageMatteColor$handle() { - return MagickGetImageMatteColor.HANDLE; + public static MethodHandle MagickQuantizeImage$handle() { + return MagickQuantizeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageMatteColor(MagickWand *, PixelWand *) + * extern MagickBooleanType MagickQuantizeImage(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) * } */ - public static MemorySegment MagickGetImageMatteColor$address() { - return MagickGetImageMatteColor.ADDR; + public static MemorySegment MagickQuantizeImage$address() { + return MagickQuantizeImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageMatteColor(MagickWand *, PixelWand *) + * extern MagickBooleanType MagickQuantizeImage(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) * } */ - public static int MagickGetImageMatteColor(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickGetImageMatteColor.HANDLE; + public static int MagickQuantizeImage(MemorySegment x0, long x1, int x2, long x3, int x4, int x5) { + var mh$ = MagickQuantizeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageMatteColor", x0, x1); + traceDowncall("MagickQuantizeImage", x0, x1, x2, x3, x4, x5); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImagePage { + private static class MagickQuantizeImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImagePage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQuantizeImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10708,60 +25251,61 @@ private static class MagickGetImagePage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImagePage(MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) + * extern MagickBooleanType MagickQuantizeImages(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickGetImagePage$descriptor() { - return MagickGetImagePage.DESC; + public static FunctionDescriptor MagickQuantizeImages$descriptor() { + return MagickQuantizeImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImagePage(MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) + * extern MagickBooleanType MagickQuantizeImages(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) * } */ - public static MethodHandle MagickGetImagePage$handle() { - return MagickGetImagePage.HANDLE; + public static MethodHandle MagickQuantizeImages$handle() { + return MagickQuantizeImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImagePage(MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) + * extern MagickBooleanType MagickQuantizeImages(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) * } */ - public static MemorySegment MagickGetImagePage$address() { - return MagickGetImagePage.ADDR; + public static MemorySegment MagickQuantizeImages$address() { + return MagickQuantizeImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImagePage(MagickWand *, size_t *, size_t *, ssize_t *, ssize_t *) + * extern MagickBooleanType MagickQuantizeImages(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) * } */ - public static int MagickGetImagePage(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { - var mh$ = MagickGetImagePage.HANDLE; + public static int MagickQuantizeImages(MemorySegment x0, long x1, int x2, long x3, int x4, int x5) { + var mh$ = MagickQuantizeImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImagePage", x0, x1, x2, x3, x4); + traceDowncall("MagickQuantizeImages", x0, x1, x2, x3, x4, x5); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImagePixelColor { + private static class MagickRangeThresholdImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_POINTER + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImagePixelColor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRangeThresholdImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10769,60 +25313,58 @@ private static class MagickGetImagePixelColor { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, PixelWand *) + * extern MagickBooleanType MagickRangeThresholdImage(MagickWand *, const double, const double, const double, const double) * } */ - public static FunctionDescriptor MagickGetImagePixelColor$descriptor() { - return MagickGetImagePixelColor.DESC; + public static FunctionDescriptor MagickRangeThresholdImage$descriptor() { + return MagickRangeThresholdImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, PixelWand *) + * extern MagickBooleanType MagickRangeThresholdImage(MagickWand *, const double, const double, const double, const double) * } */ - public static MethodHandle MagickGetImagePixelColor$handle() { - return MagickGetImagePixelColor.HANDLE; + public static MethodHandle MagickRangeThresholdImage$handle() { + return MagickRangeThresholdImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, PixelWand *) + * extern MagickBooleanType MagickRangeThresholdImage(MagickWand *, const double, const double, const double, const double) * } */ - public static MemorySegment MagickGetImagePixelColor$address() { - return MagickGetImagePixelColor.ADDR; + public static MemorySegment MagickRangeThresholdImage$address() { + return MagickRangeThresholdImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, PixelWand *) + * extern MagickBooleanType MagickRangeThresholdImage(MagickWand *, const double, const double, const double, const double) * } */ - public static int MagickGetImagePixelColor(MemorySegment x0, long x1, long x2, MemorySegment x3) { - var mh$ = MagickGetImagePixelColor.HANDLE; + public static int MagickRangeThresholdImage(MemorySegment x0, double x1, double x2, double x3, double x4) { + var mh$ = MagickRangeThresholdImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImagePixelColor", x0, x1, x2, x3); + traceDowncall("MagickRangeThresholdImage", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageRedPrimary { + private static class MagickRotationalBlurImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageRedPrimary"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRotationalBlurImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10830,59 +25372,62 @@ private static class MagickGetImageRedPrimary { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageRedPrimary(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickRotationalBlurImage(MagickWand *, const double) * } */ - public static FunctionDescriptor MagickGetImageRedPrimary$descriptor() { - return MagickGetImageRedPrimary.DESC; + public static FunctionDescriptor MagickRotationalBlurImage$descriptor() { + return MagickRotationalBlurImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageRedPrimary(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickRotationalBlurImage(MagickWand *, const double) * } */ - public static MethodHandle MagickGetImageRedPrimary$handle() { - return MagickGetImageRedPrimary.HANDLE; + public static MethodHandle MagickRotationalBlurImage$handle() { + return MagickRotationalBlurImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageRedPrimary(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickRotationalBlurImage(MagickWand *, const double) * } */ - public static MemorySegment MagickGetImageRedPrimary$address() { - return MagickGetImageRedPrimary.ADDR; + public static MemorySegment MagickRotationalBlurImage$address() { + return MagickRotationalBlurImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageRedPrimary(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickRotationalBlurImage(MagickWand *, const double) * } */ - public static int MagickGetImageRedPrimary(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { - var mh$ = MagickGetImageRedPrimary.HANDLE; + public static int MagickRotationalBlurImage(MemorySegment x0, double x1) { + var mh$ = MagickRotationalBlurImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageRedPrimary", x0, x1, x2, x3); + traceDowncall("MagickRotationalBlurImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageResolution { + private static class MagickRaiseImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageResolution"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRaiseImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10890,60 +25435,59 @@ private static class MagickGetImageResolution { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageResolution(MagickWand *, double *, double *) + * extern MagickBooleanType MagickRaiseImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickGetImageResolution$descriptor() { - return MagickGetImageResolution.DESC; + public static FunctionDescriptor MagickRaiseImage$descriptor() { + return MagickRaiseImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageResolution(MagickWand *, double *, double *) + * extern MagickBooleanType MagickRaiseImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t, const MagickBooleanType) * } */ - public static MethodHandle MagickGetImageResolution$handle() { - return MagickGetImageResolution.HANDLE; + public static MethodHandle MagickRaiseImage$handle() { + return MagickRaiseImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageResolution(MagickWand *, double *, double *) + * extern MagickBooleanType MagickRaiseImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t, const MagickBooleanType) * } */ - public static MemorySegment MagickGetImageResolution$address() { - return MagickGetImageResolution.ADDR; + public static MemorySegment MagickRaiseImage$address() { + return MagickRaiseImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageResolution(MagickWand *, double *, double *) + * extern MagickBooleanType MagickRaiseImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t, const MagickBooleanType) * } */ - public static int MagickGetImageResolution(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickGetImageResolution.HANDLE; + public static int MagickRaiseImage(MemorySegment x0, long x1, long x2, long x3, long x4, int x5) { + var mh$ = MagickRaiseImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageResolution", x0, x1, x2); + traceDowncall("MagickRaiseImage", x0, x1, x2, x3, x4, x5); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageWhitePoint { + private static class MagickRandomThresholdImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageWhitePoint"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRandomThresholdImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -10951,58 +25495,58 @@ private static class MagickGetImageWhitePoint { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageWhitePoint(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickRandomThresholdImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickGetImageWhitePoint$descriptor() { - return MagickGetImageWhitePoint.DESC; + public static FunctionDescriptor MagickRandomThresholdImage$descriptor() { + return MagickRandomThresholdImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageWhitePoint(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickRandomThresholdImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickGetImageWhitePoint$handle() { - return MagickGetImageWhitePoint.HANDLE; + public static MethodHandle MagickRandomThresholdImage$handle() { + return MagickRandomThresholdImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageWhitePoint(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickRandomThresholdImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickGetImageWhitePoint$address() { - return MagickGetImageWhitePoint.ADDR; + public static MemorySegment MagickRandomThresholdImage$address() { + return MagickRandomThresholdImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickGetImageWhitePoint(MagickWand *, double *, double *, double *) + * extern MagickBooleanType MagickRandomThresholdImage(MagickWand *, const double, const double) * } */ - public static int MagickGetImageWhitePoint(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { - var mh$ = MagickGetImageWhitePoint.HANDLE; + public static int MagickRandomThresholdImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickRandomThresholdImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageWhitePoint", x0, x1, x2, x3); + traceDowncall("MagickRandomThresholdImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickHaldClutImage { + private static class MagickReadImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickHaldClutImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickReadImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11010,43 +25554,43 @@ private static class MagickHaldClutImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickHaldClutImage(MagickWand *, const MagickWand *) + * extern MagickBooleanType MagickReadImage(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickHaldClutImage$descriptor() { - return MagickHaldClutImage.DESC; + public static FunctionDescriptor MagickReadImage$descriptor() { + return MagickReadImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickHaldClutImage(MagickWand *, const MagickWand *) + * extern MagickBooleanType MagickReadImage(MagickWand *, const char *) * } */ - public static MethodHandle MagickHaldClutImage$handle() { - return MagickHaldClutImage.HANDLE; + public static MethodHandle MagickReadImage$handle() { + return MagickReadImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickHaldClutImage(MagickWand *, const MagickWand *) + * extern MagickBooleanType MagickReadImage(MagickWand *, const char *) * } */ - public static MemorySegment MagickHaldClutImage$address() { - return MagickHaldClutImage.ADDR; + public static MemorySegment MagickReadImage$address() { + return MagickReadImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickHaldClutImage(MagickWand *, const MagickWand *) + * extern MagickBooleanType MagickReadImage(MagickWand *, const char *) * } */ - public static int MagickHaldClutImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickHaldClutImage.HANDLE; + public static int MagickReadImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickReadImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickHaldClutImage", x0, x1); + traceDowncall("MagickReadImage", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -11054,13 +25598,15 @@ public static int MagickHaldClutImage(MemorySegment x0, MemorySegment x1) { } } - private static class MagickHasNextImage { + private static class MagickReadImageBlob { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickHasNextImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickReadImageBlob"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11068,57 +25614,58 @@ private static class MagickHasNextImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickHasNextImage(MagickWand *) + * extern MagickBooleanType MagickReadImageBlob(MagickWand *, const void *, const size_t) * } */ - public static FunctionDescriptor MagickHasNextImage$descriptor() { - return MagickHasNextImage.DESC; + public static FunctionDescriptor MagickReadImageBlob$descriptor() { + return MagickReadImageBlob.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickHasNextImage(MagickWand *) + * extern MagickBooleanType MagickReadImageBlob(MagickWand *, const void *, const size_t) * } */ - public static MethodHandle MagickHasNextImage$handle() { - return MagickHasNextImage.HANDLE; + public static MethodHandle MagickReadImageBlob$handle() { + return MagickReadImageBlob.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickHasNextImage(MagickWand *) + * extern MagickBooleanType MagickReadImageBlob(MagickWand *, const void *, const size_t) * } */ - public static MemorySegment MagickHasNextImage$address() { - return MagickHasNextImage.ADDR; + public static MemorySegment MagickReadImageBlob$address() { + return MagickReadImageBlob.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickHasNextImage(MagickWand *) + * extern MagickBooleanType MagickReadImageBlob(MagickWand *, const void *, const size_t) * } */ - public static int MagickHasNextImage(MemorySegment x0) { - var mh$ = MagickHasNextImage.HANDLE; + public static int MagickReadImageBlob(MemorySegment x0, MemorySegment x1, long x2) { + var mh$ = MagickReadImageBlob.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickHasNextImage", x0); + traceDowncall("MagickReadImageBlob", x0, x1, x2); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickHasPreviousImage { + private static class MagickReadImageFile { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickHasPreviousImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickReadImageFile"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11126,60 +25673,58 @@ private static class MagickHasPreviousImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickHasPreviousImage(MagickWand *) + * extern MagickBooleanType MagickReadImageFile(MagickWand *, FILE *) * } */ - public static FunctionDescriptor MagickHasPreviousImage$descriptor() { - return MagickHasPreviousImage.DESC; + public static FunctionDescriptor MagickReadImageFile$descriptor() { + return MagickReadImageFile.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickHasPreviousImage(MagickWand *) + * extern MagickBooleanType MagickReadImageFile(MagickWand *, FILE *) * } */ - public static MethodHandle MagickHasPreviousImage$handle() { - return MagickHasPreviousImage.HANDLE; + public static MethodHandle MagickReadImageFile$handle() { + return MagickReadImageFile.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickHasPreviousImage(MagickWand *) + * extern MagickBooleanType MagickReadImageFile(MagickWand *, FILE *) * } */ - public static MemorySegment MagickHasPreviousImage$address() { - return MagickHasPreviousImage.ADDR; + public static MemorySegment MagickReadImageFile$address() { + return MagickReadImageFile.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickHasPreviousImage(MagickWand *) + * extern MagickBooleanType MagickReadImageFile(MagickWand *, FILE *) * } */ - public static int MagickHasPreviousImage(MemorySegment x0) { - var mh$ = MagickHasPreviousImage.HANDLE; + public static int MagickReadImageFile(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickReadImageFile.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickHasPreviousImage", x0); + traceDowncall("MagickReadImageFile", x0, x1); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickHoughLineImage { + private static class MagickReduceNoiseImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickHoughLineImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickReduceNoiseImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11187,59 +25732,59 @@ private static class MagickHoughLineImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickHoughLineImage(MagickWand *, const size_t, const size_t, const size_t) + * extern MagickBooleanType MagickReduceNoiseImage(MagickWand *, const double) * } */ - public static FunctionDescriptor MagickHoughLineImage$descriptor() { - return MagickHoughLineImage.DESC; + public static FunctionDescriptor MagickReduceNoiseImage$descriptor() { + return MagickReduceNoiseImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickHoughLineImage(MagickWand *, const size_t, const size_t, const size_t) + * extern MagickBooleanType MagickReduceNoiseImage(MagickWand *, const double) * } */ - public static MethodHandle MagickHoughLineImage$handle() { - return MagickHoughLineImage.HANDLE; + public static MethodHandle MagickReduceNoiseImage$handle() { + return MagickReduceNoiseImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickHoughLineImage(MagickWand *, const size_t, const size_t, const size_t) + * extern MagickBooleanType MagickReduceNoiseImage(MagickWand *, const double) * } */ - public static MemorySegment MagickHoughLineImage$address() { - return MagickHoughLineImage.ADDR; + public static MemorySegment MagickReduceNoiseImage$address() { + return MagickReduceNoiseImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickHoughLineImage(MagickWand *, const size_t, const size_t, const size_t) + * extern MagickBooleanType MagickReduceNoiseImage(MagickWand *, const double) * } */ - public static int MagickHoughLineImage(MemorySegment x0, long x1, long x2, long x3) { - var mh$ = MagickHoughLineImage.HANDLE; + public static int MagickReduceNoiseImage(MemorySegment x0, double x1) { + var mh$ = MagickReduceNoiseImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickHoughLineImage", x0, x1, x2, x3); + traceDowncall("MagickReduceNoiseImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickImplodeImage { + private static class MagickRemapImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, + MagickWand_h.C_POINTER, MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickImplodeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRemapImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11247,43 +25792,43 @@ private static class MagickImplodeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickImplodeImage(MagickWand *, const double, const PixelInterpolateMethod) + * extern MagickBooleanType MagickRemapImage(MagickWand *, const MagickWand *, const DitherMethod) * } */ - public static FunctionDescriptor MagickImplodeImage$descriptor() { - return MagickImplodeImage.DESC; + public static FunctionDescriptor MagickRemapImage$descriptor() { + return MagickRemapImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickImplodeImage(MagickWand *, const double, const PixelInterpolateMethod) + * extern MagickBooleanType MagickRemapImage(MagickWand *, const MagickWand *, const DitherMethod) * } */ - public static MethodHandle MagickImplodeImage$handle() { - return MagickImplodeImage.HANDLE; + public static MethodHandle MagickRemapImage$handle() { + return MagickRemapImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickImplodeImage(MagickWand *, const double, const PixelInterpolateMethod) + * extern MagickBooleanType MagickRemapImage(MagickWand *, const MagickWand *, const DitherMethod) * } */ - public static MemorySegment MagickImplodeImage$address() { - return MagickImplodeImage.ADDR; + public static MemorySegment MagickRemapImage$address() { + return MagickRemapImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickImplodeImage(MagickWand *, const double, const PixelInterpolateMethod) + * extern MagickBooleanType MagickRemapImage(MagickWand *, const MagickWand *, const DitherMethod) * } */ - public static int MagickImplodeImage(MemorySegment x0, double x1, int x2) { - var mh$ = MagickImplodeImage.HANDLE; + public static int MagickRemapImage(MemorySegment x0, MemorySegment x1, int x2) { + var mh$ = MagickRemapImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickImplodeImage", x0, x1, x2); + traceDowncall("MagickRemapImage", x0, x1, x2); } return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { @@ -11291,20 +25836,13 @@ public static int MagickImplodeImage(MemorySegment x0, double x1, int x2) { } } - private static class MagickImportImagePixels { + private static class MagickRemoveImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_POINTER, MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickImportImagePixels"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRemoveImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11312,60 +25850,60 @@ private static class MagickImportImagePixels { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickImportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, const void *) + * extern MagickBooleanType MagickRemoveImage(MagickWand *) * } */ - public static FunctionDescriptor MagickImportImagePixels$descriptor() { - return MagickImportImagePixels.DESC; + public static FunctionDescriptor MagickRemoveImage$descriptor() { + return MagickRemoveImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickImportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, const void *) + * extern MagickBooleanType MagickRemoveImage(MagickWand *) * } */ - public static MethodHandle MagickImportImagePixels$handle() { - return MagickImportImagePixels.HANDLE; + public static MethodHandle MagickRemoveImage$handle() { + return MagickRemoveImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickImportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, const void *) + * extern MagickBooleanType MagickRemoveImage(MagickWand *) * } */ - public static MemorySegment MagickImportImagePixels$address() { - return MagickImportImagePixels.ADDR; + public static MemorySegment MagickRemoveImage$address() { + return MagickRemoveImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickImportImagePixels(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t, const char *, const StorageType, const void *) + * extern MagickBooleanType MagickRemoveImage(MagickWand *) * } */ - public static int MagickImportImagePixels(MemorySegment x0, long x1, long x2, long x3, long x4, MemorySegment x5, int x6, MemorySegment x7) { - var mh$ = MagickImportImagePixels.HANDLE; + public static int MagickRemoveImage(MemorySegment x0) { + var mh$ = MagickRemoveImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickImportImagePixels", x0, x1, x2, x3, x4, x5, x6, x7); + traceDowncall("MagickRemoveImage", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5, x6, x7); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickInterpolativeResizeImage { + private static class MagickResampleImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickInterpolativeResizeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickResampleImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11373,43 +25911,43 @@ private static class MagickInterpolativeResizeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickInterpolativeResizeImage(MagickWand *, const size_t, const size_t, const PixelInterpolateMethod) + * extern MagickBooleanType MagickResampleImage(MagickWand *, const double, const double, const FilterType) * } */ - public static FunctionDescriptor MagickInterpolativeResizeImage$descriptor() { - return MagickInterpolativeResizeImage.DESC; + public static FunctionDescriptor MagickResampleImage$descriptor() { + return MagickResampleImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickInterpolativeResizeImage(MagickWand *, const size_t, const size_t, const PixelInterpolateMethod) + * extern MagickBooleanType MagickResampleImage(MagickWand *, const double, const double, const FilterType) * } */ - public static MethodHandle MagickInterpolativeResizeImage$handle() { - return MagickInterpolativeResizeImage.HANDLE; + public static MethodHandle MagickResampleImage$handle() { + return MagickResampleImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickInterpolativeResizeImage(MagickWand *, const size_t, const size_t, const PixelInterpolateMethod) + * extern MagickBooleanType MagickResampleImage(MagickWand *, const double, const double, const FilterType) * } */ - public static MemorySegment MagickInterpolativeResizeImage$address() { - return MagickInterpolativeResizeImage.ADDR; + public static MemorySegment MagickResampleImage$address() { + return MagickResampleImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickInterpolativeResizeImage(MagickWand *, const size_t, const size_t, const PixelInterpolateMethod) + * extern MagickBooleanType MagickResampleImage(MagickWand *, const double, const double, const FilterType) * } */ - public static int MagickInterpolativeResizeImage(MemorySegment x0, long x1, long x2, int x3) { - var mh$ = MagickInterpolativeResizeImage.HANDLE; + public static int MagickResampleImage(MemorySegment x0, double x1, double x2, int x3) { + var mh$ = MagickResampleImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickInterpolativeResizeImage", x0, x1, x2, x3); + traceDowncall("MagickResampleImage", x0, x1, x2, x3); } return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { @@ -11417,15 +25955,14 @@ public static int MagickInterpolativeResizeImage(MemorySegment x0, long x1, long } } - private static class MagickInverseFourierTransformImage { + private static class MagickResetImagePage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickInverseFourierTransformImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickResetImagePage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11433,60 +25970,60 @@ private static class MagickInverseFourierTransformImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickInverseFourierTransformImage(MagickWand *, MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickResetImagePage(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickInverseFourierTransformImage$descriptor() { - return MagickInverseFourierTransformImage.DESC; + public static FunctionDescriptor MagickResetImagePage$descriptor() { + return MagickResetImagePage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickInverseFourierTransformImage(MagickWand *, MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickResetImagePage(MagickWand *, const char *) * } */ - public static MethodHandle MagickInverseFourierTransformImage$handle() { - return MagickInverseFourierTransformImage.HANDLE; + public static MethodHandle MagickResetImagePage$handle() { + return MagickResetImagePage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickInverseFourierTransformImage(MagickWand *, MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickResetImagePage(MagickWand *, const char *) * } */ - public static MemorySegment MagickInverseFourierTransformImage$address() { - return MagickInverseFourierTransformImage.ADDR; + public static MemorySegment MagickResetImagePage$address() { + return MagickResetImagePage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickInverseFourierTransformImage(MagickWand *, MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickResetImagePage(MagickWand *, const char *) * } */ - public static int MagickInverseFourierTransformImage(MemorySegment x0, MemorySegment x1, int x2) { - var mh$ = MagickInverseFourierTransformImage.HANDLE; + public static int MagickResetImagePage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickResetImagePage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickInverseFourierTransformImage", x0, x1, x2); + traceDowncall("MagickResetImagePage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickKmeansImage { + private static class MagickResizeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_LONG, MagickWand_h.C_LONG, - MagickWand_h.C_DOUBLE + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickKmeansImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickResizeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11494,43 +26031,43 @@ private static class MagickKmeansImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickKmeansImage(MagickWand *, const size_t, const size_t, const double) + * extern MagickBooleanType MagickResizeImage(MagickWand *, const size_t, const size_t, const FilterType) * } */ - public static FunctionDescriptor MagickKmeansImage$descriptor() { - return MagickKmeansImage.DESC; + public static FunctionDescriptor MagickResizeImage$descriptor() { + return MagickResizeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickKmeansImage(MagickWand *, const size_t, const size_t, const double) + * extern MagickBooleanType MagickResizeImage(MagickWand *, const size_t, const size_t, const FilterType) * } */ - public static MethodHandle MagickKmeansImage$handle() { - return MagickKmeansImage.HANDLE; + public static MethodHandle MagickResizeImage$handle() { + return MagickResizeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickKmeansImage(MagickWand *, const size_t, const size_t, const double) + * extern MagickBooleanType MagickResizeImage(MagickWand *, const size_t, const size_t, const FilterType) * } */ - public static MemorySegment MagickKmeansImage$address() { - return MagickKmeansImage.ADDR; + public static MemorySegment MagickResizeImage$address() { + return MagickResizeImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickKmeansImage(MagickWand *, const size_t, const size_t, const double) + * extern MagickBooleanType MagickResizeImage(MagickWand *, const size_t, const size_t, const FilterType) * } */ - public static int MagickKmeansImage(MemorySegment x0, long x1, long x2, double x3) { - var mh$ = MagickKmeansImage.HANDLE; + public static int MagickResizeImage(MemorySegment x0, long x1, long x2, int x3) { + var mh$ = MagickResizeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickKmeansImage", x0, x1, x2, x3); + traceDowncall("MagickResizeImage", x0, x1, x2, x3); } return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { @@ -11538,15 +26075,15 @@ public static int MagickKmeansImage(MemorySegment x0, long x1, long x2, double x } } - private static class MagickKuwaharaImage { + private static class MagickRollImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickKuwaharaImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRollImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11554,43 +26091,43 @@ private static class MagickKuwaharaImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickKuwaharaImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickRollImage(MagickWand *, const ssize_t, const ssize_t) * } */ - public static FunctionDescriptor MagickKuwaharaImage$descriptor() { - return MagickKuwaharaImage.DESC; + public static FunctionDescriptor MagickRollImage$descriptor() { + return MagickRollImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickKuwaharaImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickRollImage(MagickWand *, const ssize_t, const ssize_t) * } */ - public static MethodHandle MagickKuwaharaImage$handle() { - return MagickKuwaharaImage.HANDLE; + public static MethodHandle MagickRollImage$handle() { + return MagickRollImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickKuwaharaImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickRollImage(MagickWand *, const ssize_t, const ssize_t) * } */ - public static MemorySegment MagickKuwaharaImage$address() { - return MagickKuwaharaImage.ADDR; + public static MemorySegment MagickRollImage$address() { + return MagickRollImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickKuwaharaImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickRollImage(MagickWand *, const ssize_t, const ssize_t) * } */ - public static int MagickKuwaharaImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickKuwaharaImage.HANDLE; + public static int MagickRollImage(MemorySegment x0, long x1, long x2) { + var mh$ = MagickRollImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickKuwaharaImage", x0, x1, x2); + traceDowncall("MagickRollImage", x0, x1, x2); } return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { @@ -11598,14 +26135,15 @@ public static int MagickKuwaharaImage(MemorySegment x0, double x1, double x2) { } } - private static class MagickLabelImage { + private static class MagickRotateImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickLabelImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRotateImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11613,60 +26151,59 @@ private static class MagickLabelImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickLabelImage(MagickWand *, const char *) + * extern MagickBooleanType MagickRotateImage(MagickWand *, const PixelWand *, const double) * } */ - public static FunctionDescriptor MagickLabelImage$descriptor() { - return MagickLabelImage.DESC; + public static FunctionDescriptor MagickRotateImage$descriptor() { + return MagickRotateImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickLabelImage(MagickWand *, const char *) + * extern MagickBooleanType MagickRotateImage(MagickWand *, const PixelWand *, const double) * } */ - public static MethodHandle MagickLabelImage$handle() { - return MagickLabelImage.HANDLE; + public static MethodHandle MagickRotateImage$handle() { + return MagickRotateImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickLabelImage(MagickWand *, const char *) + * extern MagickBooleanType MagickRotateImage(MagickWand *, const PixelWand *, const double) * } */ - public static MemorySegment MagickLabelImage$address() { - return MagickLabelImage.ADDR; + public static MemorySegment MagickRotateImage$address() { + return MagickRotateImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickLabelImage(MagickWand *, const char *) + * extern MagickBooleanType MagickRotateImage(MagickWand *, const PixelWand *, const double) * } */ - public static int MagickLabelImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickLabelImage.HANDLE; + public static int MagickRotateImage(MemorySegment x0, MemorySegment x1, double x2) { + var mh$ = MagickRotateImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickLabelImage", x0, x1); + traceDowncall("MagickRotateImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickLevelImage { + private static class MagickSampleImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickLevelImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSampleImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11674,60 +26211,59 @@ private static class MagickLevelImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickLevelImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSampleImage(MagickWand *, const size_t, const size_t) * } */ - public static FunctionDescriptor MagickLevelImage$descriptor() { - return MagickLevelImage.DESC; + public static FunctionDescriptor MagickSampleImage$descriptor() { + return MagickSampleImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickLevelImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSampleImage(MagickWand *, const size_t, const size_t) * } */ - public static MethodHandle MagickLevelImage$handle() { - return MagickLevelImage.HANDLE; + public static MethodHandle MagickSampleImage$handle() { + return MagickSampleImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickLevelImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSampleImage(MagickWand *, const size_t, const size_t) * } */ - public static MemorySegment MagickLevelImage$address() { - return MagickLevelImage.ADDR; + public static MemorySegment MagickSampleImage$address() { + return MagickSampleImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickLevelImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSampleImage(MagickWand *, const size_t, const size_t) * } */ - public static int MagickLevelImage(MemorySegment x0, double x1, double x2, double x3) { - var mh$ = MagickLevelImage.HANDLE; + public static int MagickSampleImage(MemorySegment x0, long x1, long x2) { + var mh$ = MagickSampleImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickLevelImage", x0, x1, x2, x3); + traceDowncall("MagickSampleImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickLevelImageColors { + private static class MagickScaleImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickLevelImageColors"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickScaleImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11735,60 +26271,61 @@ private static class MagickLevelImageColors { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickLevelImageColors(MagickWand *, const PixelWand *, const PixelWand *, const MagickBooleanType) + * extern MagickBooleanType MagickScaleImage(MagickWand *, const size_t, const size_t) * } */ - public static FunctionDescriptor MagickLevelImageColors$descriptor() { - return MagickLevelImageColors.DESC; + public static FunctionDescriptor MagickScaleImage$descriptor() { + return MagickScaleImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickLevelImageColors(MagickWand *, const PixelWand *, const PixelWand *, const MagickBooleanType) + * extern MagickBooleanType MagickScaleImage(MagickWand *, const size_t, const size_t) * } */ - public static MethodHandle MagickLevelImageColors$handle() { - return MagickLevelImageColors.HANDLE; + public static MethodHandle MagickScaleImage$handle() { + return MagickScaleImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickLevelImageColors(MagickWand *, const PixelWand *, const PixelWand *, const MagickBooleanType) + * extern MagickBooleanType MagickScaleImage(MagickWand *, const size_t, const size_t) * } */ - public static MemorySegment MagickLevelImageColors$address() { - return MagickLevelImageColors.ADDR; + public static MemorySegment MagickScaleImage$address() { + return MagickScaleImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickLevelImageColors(MagickWand *, const PixelWand *, const PixelWand *, const MagickBooleanType) + * extern MagickBooleanType MagickScaleImage(MagickWand *, const size_t, const size_t) * } */ - public static int MagickLevelImageColors(MemorySegment x0, MemorySegment x1, MemorySegment x2, int x3) { - var mh$ = MagickLevelImageColors.HANDLE; + public static int MagickScaleImage(MemorySegment x0, long x1, long x2) { + var mh$ = MagickScaleImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickLevelImageColors", x0, x1, x2, x3); + traceDowncall("MagickScaleImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickLevelizeImage { + private static class MagickSegmentImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, + MagickWand_h.C_INT, + MagickWand_h.C_INT, MagickWand_h.C_DOUBLE, MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickLevelizeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSegmentImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11796,59 +26333,60 @@ private static class MagickLevelizeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickLevelizeImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSegmentImage(MagickWand *, const ColorspaceType, const MagickBooleanType, const double, const double) * } */ - public static FunctionDescriptor MagickLevelizeImage$descriptor() { - return MagickLevelizeImage.DESC; + public static FunctionDescriptor MagickSegmentImage$descriptor() { + return MagickSegmentImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickLevelizeImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSegmentImage(MagickWand *, const ColorspaceType, const MagickBooleanType, const double, const double) * } */ - public static MethodHandle MagickLevelizeImage$handle() { - return MagickLevelizeImage.HANDLE; + public static MethodHandle MagickSegmentImage$handle() { + return MagickSegmentImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickLevelizeImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSegmentImage(MagickWand *, const ColorspaceType, const MagickBooleanType, const double, const double) * } */ - public static MemorySegment MagickLevelizeImage$address() { - return MagickLevelizeImage.ADDR; + public static MemorySegment MagickSegmentImage$address() { + return MagickSegmentImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickLevelizeImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSegmentImage(MagickWand *, const ColorspaceType, const MagickBooleanType, const double, const double) * } */ - public static int MagickLevelizeImage(MemorySegment x0, double x1, double x2, double x3) { - var mh$ = MagickLevelizeImage.HANDLE; + public static int MagickSegmentImage(MemorySegment x0, int x1, int x2, double x3, double x4) { + var mh$ = MagickSegmentImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickLevelizeImage", x0, x1, x2, x3); + traceDowncall("MagickSegmentImage", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickLinearStretchImage { + private static class MagickSelectiveBlurImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickLinearStretchImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSelectiveBlurImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11856,61 +26394,58 @@ private static class MagickLinearStretchImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickLinearStretchImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSelectiveBlurImage(MagickWand *, const double, const double, const double) * } */ - public static FunctionDescriptor MagickLinearStretchImage$descriptor() { - return MagickLinearStretchImage.DESC; + public static FunctionDescriptor MagickSelectiveBlurImage$descriptor() { + return MagickSelectiveBlurImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickLinearStretchImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSelectiveBlurImage(MagickWand *, const double, const double, const double) * } */ - public static MethodHandle MagickLinearStretchImage$handle() { - return MagickLinearStretchImage.HANDLE; + public static MethodHandle MagickSelectiveBlurImage$handle() { + return MagickSelectiveBlurImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickLinearStretchImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSelectiveBlurImage(MagickWand *, const double, const double, const double) * } */ - public static MemorySegment MagickLinearStretchImage$address() { - return MagickLinearStretchImage.ADDR; + public static MemorySegment MagickSelectiveBlurImage$address() { + return MagickSelectiveBlurImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickLinearStretchImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSelectiveBlurImage(MagickWand *, const double, const double, const double) * } */ - public static int MagickLinearStretchImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickLinearStretchImage.HANDLE; + public static int MagickSelectiveBlurImage(MemorySegment x0, double x1, double x2, double x3) { + var mh$ = MagickSelectiveBlurImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickLinearStretchImage", x0, x1, x2); + traceDowncall("MagickSelectiveBlurImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickLiquidRescaleImage { + private static class MagickSeparateImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickLiquidRescaleImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSeparateImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11918,59 +26453,58 @@ private static class MagickLiquidRescaleImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickLiquidRescaleImage(MagickWand *, const size_t, const size_t, const double, const double) + * extern MagickBooleanType MagickSeparateImage(MagickWand *, const ChannelType) * } */ - public static FunctionDescriptor MagickLiquidRescaleImage$descriptor() { - return MagickLiquidRescaleImage.DESC; + public static FunctionDescriptor MagickSeparateImage$descriptor() { + return MagickSeparateImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickLiquidRescaleImage(MagickWand *, const size_t, const size_t, const double, const double) + * extern MagickBooleanType MagickSeparateImage(MagickWand *, const ChannelType) * } */ - public static MethodHandle MagickLiquidRescaleImage$handle() { - return MagickLiquidRescaleImage.HANDLE; + public static MethodHandle MagickSeparateImage$handle() { + return MagickSeparateImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickLiquidRescaleImage(MagickWand *, const size_t, const size_t, const double, const double) + * extern MagickBooleanType MagickSeparateImage(MagickWand *, const ChannelType) * } */ - public static MemorySegment MagickLiquidRescaleImage$address() { - return MagickLiquidRescaleImage.ADDR; + public static MemorySegment MagickSeparateImage$address() { + return MagickSeparateImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickLiquidRescaleImage(MagickWand *, const size_t, const size_t, const double, const double) + * extern MagickBooleanType MagickSeparateImage(MagickWand *, const ChannelType) * } */ - public static int MagickLiquidRescaleImage(MemorySegment x0, long x1, long x2, double x3, double x4) { - var mh$ = MagickLiquidRescaleImage.HANDLE; + public static int MagickSeparateImage(MemorySegment x0, int x1) { + var mh$ = MagickSeparateImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickLiquidRescaleImage", x0, x1, x2, x3, x4); + traceDowncall("MagickSeparateImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickLocalContrastImage { + private static class MagickSepiaToneImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickLocalContrastImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSepiaToneImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -11978,57 +26512,58 @@ private static class MagickLocalContrastImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickLocalContrastImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSepiaToneImage(MagickWand *, const double) * } */ - public static FunctionDescriptor MagickLocalContrastImage$descriptor() { - return MagickLocalContrastImage.DESC; + public static FunctionDescriptor MagickSepiaToneImage$descriptor() { + return MagickSepiaToneImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickLocalContrastImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSepiaToneImage(MagickWand *, const double) * } */ - public static MethodHandle MagickLocalContrastImage$handle() { - return MagickLocalContrastImage.HANDLE; + public static MethodHandle MagickSepiaToneImage$handle() { + return MagickSepiaToneImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickLocalContrastImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSepiaToneImage(MagickWand *, const double) * } */ - public static MemorySegment MagickLocalContrastImage$address() { - return MagickLocalContrastImage.ADDR; + public static MemorySegment MagickSepiaToneImage$address() { + return MagickSepiaToneImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickLocalContrastImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSepiaToneImage(MagickWand *, const double) * } */ - public static int MagickLocalContrastImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickLocalContrastImage.HANDLE; + public static int MagickSepiaToneImage(MemorySegment x0, double x1) { + var mh$ = MagickSepiaToneImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickLocalContrastImage", x0, x1, x2); + traceDowncall("MagickSepiaToneImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickMagnifyImage { + private static class MagickSetImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMagnifyImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12036,60 +26571,58 @@ private static class MagickMagnifyImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickMagnifyImage(MagickWand *) + * extern MagickBooleanType MagickSetImage(MagickWand *, const MagickWand *) * } */ - public static FunctionDescriptor MagickMagnifyImage$descriptor() { - return MagickMagnifyImage.DESC; + public static FunctionDescriptor MagickSetImage$descriptor() { + return MagickSetImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickMagnifyImage(MagickWand *) + * extern MagickBooleanType MagickSetImage(MagickWand *, const MagickWand *) * } */ - public static MethodHandle MagickMagnifyImage$handle() { - return MagickMagnifyImage.HANDLE; + public static MethodHandle MagickSetImage$handle() { + return MagickSetImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickMagnifyImage(MagickWand *) + * extern MagickBooleanType MagickSetImage(MagickWand *, const MagickWand *) * } */ - public static MemorySegment MagickMagnifyImage$address() { - return MagickMagnifyImage.ADDR; + public static MemorySegment MagickSetImage$address() { + return MagickSetImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickMagnifyImage(MagickWand *) + * extern MagickBooleanType MagickSetImage(MagickWand *, const MagickWand *) * } */ - public static int MagickMagnifyImage(MemorySegment x0) { - var mh$ = MagickMagnifyImage.HANDLE; + public static int MagickSetImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickMagnifyImage", x0); + traceDowncall("MagickSetImage", x0, x1); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickMeanShiftImage { + private static class MagickSetImageAlpha { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMeanShiftImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageAlpha"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12097,57 +26630,58 @@ private static class MagickMeanShiftImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickMeanShiftImage(MagickWand *, const size_t, const size_t, const double) + * extern MagickBooleanType MagickSetImageAlpha(MagickWand *, const double) * } */ - public static FunctionDescriptor MagickMeanShiftImage$descriptor() { - return MagickMeanShiftImage.DESC; + public static FunctionDescriptor MagickSetImageAlpha$descriptor() { + return MagickSetImageAlpha.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickMeanShiftImage(MagickWand *, const size_t, const size_t, const double) + * extern MagickBooleanType MagickSetImageAlpha(MagickWand *, const double) * } */ - public static MethodHandle MagickMeanShiftImage$handle() { - return MagickMeanShiftImage.HANDLE; + public static MethodHandle MagickSetImageAlpha$handle() { + return MagickSetImageAlpha.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickMeanShiftImage(MagickWand *, const size_t, const size_t, const double) + * extern MagickBooleanType MagickSetImageAlpha(MagickWand *, const double) * } */ - public static MemorySegment MagickMeanShiftImage$address() { - return MagickMeanShiftImage.ADDR; + public static MemorySegment MagickSetImageAlpha$address() { + return MagickSetImageAlpha.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickMeanShiftImage(MagickWand *, const size_t, const size_t, const double) + * extern MagickBooleanType MagickSetImageAlpha(MagickWand *, const double) * } */ - public static int MagickMeanShiftImage(MemorySegment x0, long x1, long x2, double x3) { - var mh$ = MagickMeanShiftImage.HANDLE; + public static int MagickSetImageAlpha(MemorySegment x0, double x1) { + var mh$ = MagickSetImageAlpha.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickMeanShiftImage", x0, x1, x2, x3); + traceDowncall("MagickSetImageAlpha", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickMinifyImage { + private static class MagickSetImageAlphaChannel { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMinifyImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageAlphaChannel"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12155,60 +26689,58 @@ private static class MagickMinifyImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickMinifyImage(MagickWand *) + * extern MagickBooleanType MagickSetImageAlphaChannel(MagickWand *, const AlphaChannelOption) * } */ - public static FunctionDescriptor MagickMinifyImage$descriptor() { - return MagickMinifyImage.DESC; + public static FunctionDescriptor MagickSetImageAlphaChannel$descriptor() { + return MagickSetImageAlphaChannel.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickMinifyImage(MagickWand *) + * extern MagickBooleanType MagickSetImageAlphaChannel(MagickWand *, const AlphaChannelOption) * } */ - public static MethodHandle MagickMinifyImage$handle() { - return MagickMinifyImage.HANDLE; + public static MethodHandle MagickSetImageAlphaChannel$handle() { + return MagickSetImageAlphaChannel.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickMinifyImage(MagickWand *) + * extern MagickBooleanType MagickSetImageAlphaChannel(MagickWand *, const AlphaChannelOption) * } */ - public static MemorySegment MagickMinifyImage$address() { - return MagickMinifyImage.ADDR; + public static MemorySegment MagickSetImageAlphaChannel$address() { + return MagickSetImageAlphaChannel.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickMinifyImage(MagickWand *) + * extern MagickBooleanType MagickSetImageAlphaChannel(MagickWand *, const AlphaChannelOption) * } */ - public static int MagickMinifyImage(MemorySegment x0) { - var mh$ = MagickMinifyImage.HANDLE; + public static int MagickSetImageAlphaChannel(MemorySegment x0, int x1) { + var mh$ = MagickSetImageAlphaChannel.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickMinifyImage", x0); + traceDowncall("MagickSetImageAlphaChannel", x0, x1); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickModulateImage { + private static class MagickSetImageBackgroundColor { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickModulateImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageBackgroundColor"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12216,60 +26748,60 @@ private static class MagickModulateImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickModulateImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSetImageBackgroundColor(MagickWand *, const PixelWand *) * } */ - public static FunctionDescriptor MagickModulateImage$descriptor() { - return MagickModulateImage.DESC; + public static FunctionDescriptor MagickSetImageBackgroundColor$descriptor() { + return MagickSetImageBackgroundColor.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickModulateImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSetImageBackgroundColor(MagickWand *, const PixelWand *) * } */ - public static MethodHandle MagickModulateImage$handle() { - return MagickModulateImage.HANDLE; + public static MethodHandle MagickSetImageBackgroundColor$handle() { + return MagickSetImageBackgroundColor.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickModulateImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSetImageBackgroundColor(MagickWand *, const PixelWand *) * } */ - public static MemorySegment MagickModulateImage$address() { - return MagickModulateImage.ADDR; + public static MemorySegment MagickSetImageBackgroundColor$address() { + return MagickSetImageBackgroundColor.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickModulateImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSetImageBackgroundColor(MagickWand *, const PixelWand *) * } */ - public static int MagickModulateImage(MemorySegment x0, double x1, double x2, double x3) { - var mh$ = MagickModulateImage.HANDLE; + public static int MagickSetImageBackgroundColor(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetImageBackgroundColor.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickModulateImage", x0, x1, x2, x3); + traceDowncall("MagickSetImageBackgroundColor", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickMorphologyImage { + private static class MagickSetImageBluePrimary { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_LONG, - MagickWand_h.C_POINTER + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMorphologyImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageBluePrimary"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12277,43 +26809,43 @@ private static class MagickMorphologyImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickMorphologyImage(MagickWand *, const MorphologyMethod, const ssize_t, const KernelInfo *) + * extern MagickBooleanType MagickSetImageBluePrimary(MagickWand *, const double, const double, const double) * } */ - public static FunctionDescriptor MagickMorphologyImage$descriptor() { - return MagickMorphologyImage.DESC; + public static FunctionDescriptor MagickSetImageBluePrimary$descriptor() { + return MagickSetImageBluePrimary.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickMorphologyImage(MagickWand *, const MorphologyMethod, const ssize_t, const KernelInfo *) + * extern MagickBooleanType MagickSetImageBluePrimary(MagickWand *, const double, const double, const double) * } */ - public static MethodHandle MagickMorphologyImage$handle() { - return MagickMorphologyImage.HANDLE; + public static MethodHandle MagickSetImageBluePrimary$handle() { + return MagickSetImageBluePrimary.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickMorphologyImage(MagickWand *, const MorphologyMethod, const ssize_t, const KernelInfo *) + * extern MagickBooleanType MagickSetImageBluePrimary(MagickWand *, const double, const double, const double) * } */ - public static MemorySegment MagickMorphologyImage$address() { - return MagickMorphologyImage.ADDR; + public static MemorySegment MagickSetImageBluePrimary$address() { + return MagickSetImageBluePrimary.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickMorphologyImage(MagickWand *, const MorphologyMethod, const ssize_t, const KernelInfo *) + * extern MagickBooleanType MagickSetImageBluePrimary(MagickWand *, const double, const double, const double) * } */ - public static int MagickMorphologyImage(MemorySegment x0, int x1, long x2, MemorySegment x3) { - var mh$ = MagickMorphologyImage.HANDLE; + public static int MagickSetImageBluePrimary(MemorySegment x0, double x1, double x2, double x3) { + var mh$ = MagickSetImageBluePrimary.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickMorphologyImage", x0, x1, x2, x3); + traceDowncall("MagickSetImageBluePrimary", x0, x1, x2, x3); } return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { @@ -12321,16 +26853,14 @@ public static int MagickMorphologyImage(MemorySegment x0, int x1, long x2, Memor } } - private static class MagickMotionBlurImage { + private static class MagickSetImageBorderColor { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMotionBlurImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageBorderColor"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12338,58 +26868,58 @@ private static class MagickMotionBlurImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickMotionBlurImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSetImageBorderColor(MagickWand *, const PixelWand *) * } */ - public static FunctionDescriptor MagickMotionBlurImage$descriptor() { - return MagickMotionBlurImage.DESC; + public static FunctionDescriptor MagickSetImageBorderColor$descriptor() { + return MagickSetImageBorderColor.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickMotionBlurImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSetImageBorderColor(MagickWand *, const PixelWand *) * } */ - public static MethodHandle MagickMotionBlurImage$handle() { - return MagickMotionBlurImage.HANDLE; + public static MethodHandle MagickSetImageBorderColor$handle() { + return MagickSetImageBorderColor.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickMotionBlurImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSetImageBorderColor(MagickWand *, const PixelWand *) * } */ - public static MemorySegment MagickMotionBlurImage$address() { - return MagickMotionBlurImage.ADDR; + public static MemorySegment MagickSetImageBorderColor$address() { + return MagickSetImageBorderColor.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickMotionBlurImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSetImageBorderColor(MagickWand *, const PixelWand *) * } */ - public static int MagickMotionBlurImage(MemorySegment x0, double x1, double x2, double x3) { - var mh$ = MagickMotionBlurImage.HANDLE; + public static int MagickSetImageBorderColor(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetImageBorderColor.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickMotionBlurImage", x0, x1, x2, x3); + traceDowncall("MagickSetImageBorderColor", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickNegateImage { + private static class MagickSetImageColor { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickNegateImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageColor"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12397,43 +26927,43 @@ private static class MagickNegateImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickNegateImage(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageColor(MagickWand *, const PixelWand *) * } */ - public static FunctionDescriptor MagickNegateImage$descriptor() { - return MagickNegateImage.DESC; + public static FunctionDescriptor MagickSetImageColor$descriptor() { + return MagickSetImageColor.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickNegateImage(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageColor(MagickWand *, const PixelWand *) * } */ - public static MethodHandle MagickNegateImage$handle() { - return MagickNegateImage.HANDLE; + public static MethodHandle MagickSetImageColor$handle() { + return MagickSetImageColor.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickNegateImage(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageColor(MagickWand *, const PixelWand *) * } */ - public static MemorySegment MagickNegateImage$address() { - return MagickNegateImage.ADDR; + public static MemorySegment MagickSetImageColor$address() { + return MagickSetImageColor.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickNegateImage(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageColor(MagickWand *, const PixelWand *) * } */ - public static int MagickNegateImage(MemorySegment x0, int x1) { - var mh$ = MagickNegateImage.HANDLE; + public static int MagickSetImageColor(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetImageColor.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickNegateImage", x0, x1); + traceDowncall("MagickSetImageColor", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -12441,16 +26971,15 @@ public static int MagickNegateImage(MemorySegment x0, int x1) { } } - private static class MagickNewImage { + private static class MagickSetImageColormapColor { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_LONG, - MagickWand_h.C_LONG, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickNewImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageColormapColor"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12458,57 +26987,58 @@ private static class MagickNewImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickNewImage(MagickWand *, const size_t, const size_t, const PixelWand *) + * extern MagickBooleanType MagickSetImageColormapColor(MagickWand *, const size_t, const PixelWand *) * } */ - public static FunctionDescriptor MagickNewImage$descriptor() { - return MagickNewImage.DESC; + public static FunctionDescriptor MagickSetImageColormapColor$descriptor() { + return MagickSetImageColormapColor.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickNewImage(MagickWand *, const size_t, const size_t, const PixelWand *) + * extern MagickBooleanType MagickSetImageColormapColor(MagickWand *, const size_t, const PixelWand *) * } */ - public static MethodHandle MagickNewImage$handle() { - return MagickNewImage.HANDLE; + public static MethodHandle MagickSetImageColormapColor$handle() { + return MagickSetImageColormapColor.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickNewImage(MagickWand *, const size_t, const size_t, const PixelWand *) + * extern MagickBooleanType MagickSetImageColormapColor(MagickWand *, const size_t, const PixelWand *) * } */ - public static MemorySegment MagickNewImage$address() { - return MagickNewImage.ADDR; + public static MemorySegment MagickSetImageColormapColor$address() { + return MagickSetImageColormapColor.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickNewImage(MagickWand *, const size_t, const size_t, const PixelWand *) + * extern MagickBooleanType MagickSetImageColormapColor(MagickWand *, const size_t, const PixelWand *) * } */ - public static int MagickNewImage(MemorySegment x0, long x1, long x2, MemorySegment x3) { - var mh$ = MagickNewImage.HANDLE; + public static int MagickSetImageColormapColor(MemorySegment x0, long x1, MemorySegment x2) { + var mh$ = MagickSetImageColormapColor.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickNewImage", x0, x1, x2, x3); + traceDowncall("MagickSetImageColormapColor", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickNextImage { + private static class MagickSetImageColorspace { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickNextImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageColorspace"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12516,57 +27046,58 @@ private static class MagickNextImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickNextImage(MagickWand *) + * extern MagickBooleanType MagickSetImageColorspace(MagickWand *, const ColorspaceType) * } */ - public static FunctionDescriptor MagickNextImage$descriptor() { - return MagickNextImage.DESC; + public static FunctionDescriptor MagickSetImageColorspace$descriptor() { + return MagickSetImageColorspace.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickNextImage(MagickWand *) + * extern MagickBooleanType MagickSetImageColorspace(MagickWand *, const ColorspaceType) * } */ - public static MethodHandle MagickNextImage$handle() { - return MagickNextImage.HANDLE; + public static MethodHandle MagickSetImageColorspace$handle() { + return MagickSetImageColorspace.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickNextImage(MagickWand *) + * extern MagickBooleanType MagickSetImageColorspace(MagickWand *, const ColorspaceType) * } */ - public static MemorySegment MagickNextImage$address() { - return MagickNextImage.ADDR; + public static MemorySegment MagickSetImageColorspace$address() { + return MagickSetImageColorspace.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickNextImage(MagickWand *) + * extern MagickBooleanType MagickSetImageColorspace(MagickWand *, const ColorspaceType) * } */ - public static int MagickNextImage(MemorySegment x0) { - var mh$ = MagickNextImage.HANDLE; + public static int MagickSetImageColorspace(MemorySegment x0, int x1) { + var mh$ = MagickSetImageColorspace.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickNextImage", x0); + traceDowncall("MagickSetImageColorspace", x0, x1); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickNormalizeImage { + private static class MagickSetImageCompose { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickNormalizeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageCompose"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12574,59 +27105,58 @@ private static class MagickNormalizeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickNormalizeImage(MagickWand *) + * extern MagickBooleanType MagickSetImageCompose(MagickWand *, const CompositeOperator) * } */ - public static FunctionDescriptor MagickNormalizeImage$descriptor() { - return MagickNormalizeImage.DESC; + public static FunctionDescriptor MagickSetImageCompose$descriptor() { + return MagickSetImageCompose.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickNormalizeImage(MagickWand *) + * extern MagickBooleanType MagickSetImageCompose(MagickWand *, const CompositeOperator) * } */ - public static MethodHandle MagickNormalizeImage$handle() { - return MagickNormalizeImage.HANDLE; + public static MethodHandle MagickSetImageCompose$handle() { + return MagickSetImageCompose.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickNormalizeImage(MagickWand *) + * extern MagickBooleanType MagickSetImageCompose(MagickWand *, const CompositeOperator) * } */ - public static MemorySegment MagickNormalizeImage$address() { - return MagickNormalizeImage.ADDR; + public static MemorySegment MagickSetImageCompose$address() { + return MagickSetImageCompose.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickNormalizeImage(MagickWand *) + * extern MagickBooleanType MagickSetImageCompose(MagickWand *, const CompositeOperator) * } */ - public static int MagickNormalizeImage(MemorySegment x0) { - var mh$ = MagickNormalizeImage.HANDLE; + public static int MagickSetImageCompose(MemorySegment x0, int x1) { + var mh$ = MagickSetImageCompose.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickNormalizeImage", x0); + traceDowncall("MagickSetImageCompose", x0, x1); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickOilPaintImage { + private static class MagickSetImageCompression { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickOilPaintImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageCompression"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12634,61 +27164,58 @@ private static class MagickOilPaintImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickOilPaintImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSetImageCompression(MagickWand *, const CompressionType) * } */ - public static FunctionDescriptor MagickOilPaintImage$descriptor() { - return MagickOilPaintImage.DESC; + public static FunctionDescriptor MagickSetImageCompression$descriptor() { + return MagickSetImageCompression.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickOilPaintImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSetImageCompression(MagickWand *, const CompressionType) * } */ - public static MethodHandle MagickOilPaintImage$handle() { - return MagickOilPaintImage.HANDLE; + public static MethodHandle MagickSetImageCompression$handle() { + return MagickSetImageCompression.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickOilPaintImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSetImageCompression(MagickWand *, const CompressionType) * } */ - public static MemorySegment MagickOilPaintImage$address() { - return MagickOilPaintImage.ADDR; + public static MemorySegment MagickSetImageCompression$address() { + return MagickSetImageCompression.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickOilPaintImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSetImageCompression(MagickWand *, const CompressionType) * } */ - public static int MagickOilPaintImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickOilPaintImage.HANDLE; + public static int MagickSetImageCompression(MemorySegment x0, int x1) { + var mh$ = MagickSetImageCompression.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickOilPaintImage", x0, x1, x2); + traceDowncall("MagickSetImageCompression", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickOpaquePaintImage { + private static class MagickSetImageDelay { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_INT + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickOpaquePaintImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageDelay"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12696,57 +27223,58 @@ private static class MagickOpaquePaintImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickOpaquePaintImage(MagickWand *, const PixelWand *, const PixelWand *, const double, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageDelay(MagickWand *, const size_t) * } */ - public static FunctionDescriptor MagickOpaquePaintImage$descriptor() { - return MagickOpaquePaintImage.DESC; + public static FunctionDescriptor MagickSetImageDelay$descriptor() { + return MagickSetImageDelay.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickOpaquePaintImage(MagickWand *, const PixelWand *, const PixelWand *, const double, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageDelay(MagickWand *, const size_t) * } */ - public static MethodHandle MagickOpaquePaintImage$handle() { - return MagickOpaquePaintImage.HANDLE; + public static MethodHandle MagickSetImageDelay$handle() { + return MagickSetImageDelay.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickOpaquePaintImage(MagickWand *, const PixelWand *, const PixelWand *, const double, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageDelay(MagickWand *, const size_t) * } */ - public static MemorySegment MagickOpaquePaintImage$address() { - return MagickOpaquePaintImage.ADDR; + public static MemorySegment MagickSetImageDelay$address() { + return MagickSetImageDelay.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickOpaquePaintImage(MagickWand *, const PixelWand *, const PixelWand *, const double, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageDelay(MagickWand *, const size_t) * } */ - public static int MagickOpaquePaintImage(MemorySegment x0, MemorySegment x1, MemorySegment x2, double x3, int x4) { - var mh$ = MagickOpaquePaintImage.HANDLE; + public static int MagickSetImageDelay(MemorySegment x0, long x1) { + var mh$ = MagickSetImageDelay.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickOpaquePaintImage", x0, x1, x2, x3, x4); + traceDowncall("MagickSetImageDelay", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickOptimizeImageTransparency { + private static class MagickSetImageDepth { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickOptimizeImageTransparency"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageDepth"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12754,58 +27282,58 @@ private static class MagickOptimizeImageTransparency { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickOptimizeImageTransparency(MagickWand *) + * extern MagickBooleanType MagickSetImageDepth(MagickWand *, const size_t) * } */ - public static FunctionDescriptor MagickOptimizeImageTransparency$descriptor() { - return MagickOptimizeImageTransparency.DESC; + public static FunctionDescriptor MagickSetImageDepth$descriptor() { + return MagickSetImageDepth.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickOptimizeImageTransparency(MagickWand *) + * extern MagickBooleanType MagickSetImageDepth(MagickWand *, const size_t) * } */ - public static MethodHandle MagickOptimizeImageTransparency$handle() { - return MagickOptimizeImageTransparency.HANDLE; + public static MethodHandle MagickSetImageDepth$handle() { + return MagickSetImageDepth.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickOptimizeImageTransparency(MagickWand *) + * extern MagickBooleanType MagickSetImageDepth(MagickWand *, const size_t) * } */ - public static MemorySegment MagickOptimizeImageTransparency$address() { - return MagickOptimizeImageTransparency.ADDR; + public static MemorySegment MagickSetImageDepth$address() { + return MagickSetImageDepth.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickOptimizeImageTransparency(MagickWand *) + * extern MagickBooleanType MagickSetImageDepth(MagickWand *, const size_t) * } */ - public static int MagickOptimizeImageTransparency(MemorySegment x0) { - var mh$ = MagickOptimizeImageTransparency.HANDLE; + public static int MagickSetImageDepth(MemorySegment x0, long x1) { + var mh$ = MagickSetImageDepth.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickOptimizeImageTransparency", x0); + traceDowncall("MagickSetImageDepth", x0, x1); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickOrderedDitherImage { + private static class MagickSetImageDispose { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickOrderedDitherImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageDispose"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12813,43 +27341,43 @@ private static class MagickOrderedDitherImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickOrderedDitherImage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageDispose(MagickWand *, const DisposeType) * } */ - public static FunctionDescriptor MagickOrderedDitherImage$descriptor() { - return MagickOrderedDitherImage.DESC; + public static FunctionDescriptor MagickSetImageDispose$descriptor() { + return MagickSetImageDispose.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickOrderedDitherImage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageDispose(MagickWand *, const DisposeType) * } */ - public static MethodHandle MagickOrderedDitherImage$handle() { - return MagickOrderedDitherImage.HANDLE; + public static MethodHandle MagickSetImageDispose$handle() { + return MagickSetImageDispose.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickOrderedDitherImage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageDispose(MagickWand *, const DisposeType) * } */ - public static MemorySegment MagickOrderedDitherImage$address() { - return MagickOrderedDitherImage.ADDR; + public static MemorySegment MagickSetImageDispose$address() { + return MagickSetImageDispose.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickOrderedDitherImage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageDispose(MagickWand *, const DisposeType) * } */ - public static int MagickOrderedDitherImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickOrderedDitherImage.HANDLE; + public static int MagickSetImageDispose(MemorySegment x0, int x1) { + var mh$ = MagickSetImageDispose.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickOrderedDitherImage", x0, x1); + traceDowncall("MagickSetImageDispose", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -12857,15 +27385,14 @@ public static int MagickOrderedDitherImage(MemorySegment x0, MemorySegment x1) { } } - private static class MagickPolynomialImage { + private static class MagickSetImageCompressionQuality { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPolynomialImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageCompressionQuality"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12873,61 +27400,58 @@ private static class MagickPolynomialImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickPolynomialImage(MagickWand *, const size_t, const double *) + * extern MagickBooleanType MagickSetImageCompressionQuality(MagickWand *, const size_t) * } */ - public static FunctionDescriptor MagickPolynomialImage$descriptor() { - return MagickPolynomialImage.DESC; + public static FunctionDescriptor MagickSetImageCompressionQuality$descriptor() { + return MagickSetImageCompressionQuality.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickPolynomialImage(MagickWand *, const size_t, const double *) + * extern MagickBooleanType MagickSetImageCompressionQuality(MagickWand *, const size_t) * } */ - public static MethodHandle MagickPolynomialImage$handle() { - return MagickPolynomialImage.HANDLE; + public static MethodHandle MagickSetImageCompressionQuality$handle() { + return MagickSetImageCompressionQuality.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickPolynomialImage(MagickWand *, const size_t, const double *) + * extern MagickBooleanType MagickSetImageCompressionQuality(MagickWand *, const size_t) * } */ - public static MemorySegment MagickPolynomialImage$address() { - return MagickPolynomialImage.ADDR; + public static MemorySegment MagickSetImageCompressionQuality$address() { + return MagickSetImageCompressionQuality.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickPolynomialImage(MagickWand *, const size_t, const double *) + * extern MagickBooleanType MagickSetImageCompressionQuality(MagickWand *, const size_t) * } */ - public static int MagickPolynomialImage(MemorySegment x0, long x1, MemorySegment x2) { - var mh$ = MagickPolynomialImage.HANDLE; + public static int MagickSetImageCompressionQuality(MemorySegment x0, long x1) { + var mh$ = MagickSetImageCompressionQuality.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickPolynomialImage", x0, x1, x2); + traceDowncall("MagickSetImageCompressionQuality", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickTransparentPaintImage { + private static class MagickSetImageEndian { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickTransparentPaintImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageEndian"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12935,58 +27459,59 @@ private static class MagickTransparentPaintImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickTransparentPaintImage(MagickWand *, const PixelWand *, const double, const double, const MagickBooleanType invert) + * extern MagickBooleanType MagickSetImageEndian(MagickWand *, const EndianType) * } */ - public static FunctionDescriptor MagickTransparentPaintImage$descriptor() { - return MagickTransparentPaintImage.DESC; + public static FunctionDescriptor MagickSetImageEndian$descriptor() { + return MagickSetImageEndian.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickTransparentPaintImage(MagickWand *, const PixelWand *, const double, const double, const MagickBooleanType invert) + * extern MagickBooleanType MagickSetImageEndian(MagickWand *, const EndianType) * } */ - public static MethodHandle MagickTransparentPaintImage$handle() { - return MagickTransparentPaintImage.HANDLE; + public static MethodHandle MagickSetImageEndian$handle() { + return MagickSetImageEndian.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickTransparentPaintImage(MagickWand *, const PixelWand *, const double, const double, const MagickBooleanType invert) + * extern MagickBooleanType MagickSetImageEndian(MagickWand *, const EndianType) * } */ - public static MemorySegment MagickTransparentPaintImage$address() { - return MagickTransparentPaintImage.ADDR; + public static MemorySegment MagickSetImageEndian$address() { + return MagickSetImageEndian.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickTransparentPaintImage(MagickWand *, const PixelWand *, const double, const double, const MagickBooleanType invert) + * extern MagickBooleanType MagickSetImageEndian(MagickWand *, const EndianType) * } */ - public static int MagickTransparentPaintImage(MemorySegment x0, MemorySegment x1, double x2, double x3, int invert) { - var mh$ = MagickTransparentPaintImage.HANDLE; + public static int MagickSetImageEndian(MemorySegment x0, int x1) { + var mh$ = MagickSetImageEndian.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickTransparentPaintImage", x0, x1, x2, x3, invert); + traceDowncall("MagickSetImageEndian", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3, invert); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickPingImage { + private static class MagickSetImageExtent { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPingImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageExtent"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -12994,59 +27519,58 @@ private static class MagickPingImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickPingImage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageExtent(MagickWand *, const size_t, const size_t) * } */ - public static FunctionDescriptor MagickPingImage$descriptor() { - return MagickPingImage.DESC; + public static FunctionDescriptor MagickSetImageExtent$descriptor() { + return MagickSetImageExtent.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickPingImage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageExtent(MagickWand *, const size_t, const size_t) * } */ - public static MethodHandle MagickPingImage$handle() { - return MagickPingImage.HANDLE; + public static MethodHandle MagickSetImageExtent$handle() { + return MagickSetImageExtent.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickPingImage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageExtent(MagickWand *, const size_t, const size_t) * } */ - public static MemorySegment MagickPingImage$address() { - return MagickPingImage.ADDR; + public static MemorySegment MagickSetImageExtent$address() { + return MagickSetImageExtent.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickPingImage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageExtent(MagickWand *, const size_t, const size_t) * } */ - public static int MagickPingImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickPingImage.HANDLE; + public static int MagickSetImageExtent(MemorySegment x0, long x1, long x2) { + var mh$ = MagickSetImageExtent.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickPingImage", x0, x1); + traceDowncall("MagickSetImageExtent", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickPingImageBlob { + private static class MagickSetImageFilename { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPingImageBlob"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageFilename"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13054,58 +27578,58 @@ private static class MagickPingImageBlob { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickPingImageBlob(MagickWand *, const void *, const size_t) + * extern MagickBooleanType MagickSetImageFilename(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickPingImageBlob$descriptor() { - return MagickPingImageBlob.DESC; + public static FunctionDescriptor MagickSetImageFilename$descriptor() { + return MagickSetImageFilename.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickPingImageBlob(MagickWand *, const void *, const size_t) + * extern MagickBooleanType MagickSetImageFilename(MagickWand *, const char *) * } */ - public static MethodHandle MagickPingImageBlob$handle() { - return MagickPingImageBlob.HANDLE; + public static MethodHandle MagickSetImageFilename$handle() { + return MagickSetImageFilename.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickPingImageBlob(MagickWand *, const void *, const size_t) + * extern MagickBooleanType MagickSetImageFilename(MagickWand *, const char *) * } */ - public static MemorySegment MagickPingImageBlob$address() { - return MagickPingImageBlob.ADDR; + public static MemorySegment MagickSetImageFilename$address() { + return MagickSetImageFilename.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickPingImageBlob(MagickWand *, const void *, const size_t) + * extern MagickBooleanType MagickSetImageFilename(MagickWand *, const char *) * } */ - public static int MagickPingImageBlob(MemorySegment x0, MemorySegment x1, long x2) { - var mh$ = MagickPingImageBlob.HANDLE; + public static int MagickSetImageFilename(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetImageFilename.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickPingImageBlob", x0, x1, x2); + traceDowncall("MagickSetImageFilename", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickPingImageFile { + private static class MagickSetImageFilter { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPingImageFile"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageFilter"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13113,43 +27637,43 @@ private static class MagickPingImageFile { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickPingImageFile(MagickWand *, FILE *) + * extern MagickBooleanType MagickSetImageFilter(MagickWand *, const FilterType) * } */ - public static FunctionDescriptor MagickPingImageFile$descriptor() { - return MagickPingImageFile.DESC; + public static FunctionDescriptor MagickSetImageFilter$descriptor() { + return MagickSetImageFilter.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickPingImageFile(MagickWand *, FILE *) + * extern MagickBooleanType MagickSetImageFilter(MagickWand *, const FilterType) * } */ - public static MethodHandle MagickPingImageFile$handle() { - return MagickPingImageFile.HANDLE; + public static MethodHandle MagickSetImageFilter$handle() { + return MagickSetImageFilter.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickPingImageFile(MagickWand *, FILE *) + * extern MagickBooleanType MagickSetImageFilter(MagickWand *, const FilterType) * } */ - public static MemorySegment MagickPingImageFile$address() { - return MagickPingImageFile.ADDR; + public static MemorySegment MagickSetImageFilter$address() { + return MagickSetImageFilter.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickPingImageFile(MagickWand *, FILE *) + * extern MagickBooleanType MagickSetImageFilter(MagickWand *, const FilterType) * } */ - public static int MagickPingImageFile(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickPingImageFile.HANDLE; + public static int MagickSetImageFilter(MemorySegment x0, int x1) { + var mh$ = MagickSetImageFilter.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickPingImageFile", x0, x1); + traceDowncall("MagickSetImageFilter", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -13157,17 +27681,14 @@ public static int MagickPingImageFile(MemorySegment x0, MemorySegment x1) { } } - private static class MagickPolaroidImage { + private static class MagickSetImageFormat { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPolaroidImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageFormat"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13175,59 +27696,58 @@ private static class MagickPolaroidImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickPolaroidImage(MagickWand *, const DrawingWand *, const char *, const double, const PixelInterpolateMethod) + * extern MagickBooleanType MagickSetImageFormat(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickPolaroidImage$descriptor() { - return MagickPolaroidImage.DESC; + public static FunctionDescriptor MagickSetImageFormat$descriptor() { + return MagickSetImageFormat.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickPolaroidImage(MagickWand *, const DrawingWand *, const char *, const double, const PixelInterpolateMethod) + * extern MagickBooleanType MagickSetImageFormat(MagickWand *, const char *) * } */ - public static MethodHandle MagickPolaroidImage$handle() { - return MagickPolaroidImage.HANDLE; + public static MethodHandle MagickSetImageFormat$handle() { + return MagickSetImageFormat.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickPolaroidImage(MagickWand *, const DrawingWand *, const char *, const double, const PixelInterpolateMethod) + * extern MagickBooleanType MagickSetImageFormat(MagickWand *, const char *) * } */ - public static MemorySegment MagickPolaroidImage$address() { - return MagickPolaroidImage.ADDR; + public static MemorySegment MagickSetImageFormat$address() { + return MagickSetImageFormat.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickPolaroidImage(MagickWand *, const DrawingWand *, const char *, const double, const PixelInterpolateMethod) + * extern MagickBooleanType MagickSetImageFormat(MagickWand *, const char *) * } */ - public static int MagickPolaroidImage(MemorySegment x0, MemorySegment x1, MemorySegment x2, double x3, int x4) { - var mh$ = MagickPolaroidImage.HANDLE; + public static int MagickSetImageFormat(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetImageFormat.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickPolaroidImage", x0, x1, x2, x3, x4); + traceDowncall("MagickSetImageFormat", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickPosterizeImage { + private static class MagickSetImageFuzz { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_INT + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPosterizeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageFuzz"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13235,57 +27755,58 @@ private static class MagickPosterizeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickPosterizeImage(MagickWand *, const size_t, const DitherMethod) + * extern MagickBooleanType MagickSetImageFuzz(MagickWand *, const double) * } */ - public static FunctionDescriptor MagickPosterizeImage$descriptor() { - return MagickPosterizeImage.DESC; + public static FunctionDescriptor MagickSetImageFuzz$descriptor() { + return MagickSetImageFuzz.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickPosterizeImage(MagickWand *, const size_t, const DitherMethod) + * extern MagickBooleanType MagickSetImageFuzz(MagickWand *, const double) * } */ - public static MethodHandle MagickPosterizeImage$handle() { - return MagickPosterizeImage.HANDLE; + public static MethodHandle MagickSetImageFuzz$handle() { + return MagickSetImageFuzz.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickPosterizeImage(MagickWand *, const size_t, const DitherMethod) + * extern MagickBooleanType MagickSetImageFuzz(MagickWand *, const double) * } */ - public static MemorySegment MagickPosterizeImage$address() { - return MagickPosterizeImage.ADDR; + public static MemorySegment MagickSetImageFuzz$address() { + return MagickSetImageFuzz.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickPosterizeImage(MagickWand *, const size_t, const DitherMethod) + * extern MagickBooleanType MagickSetImageFuzz(MagickWand *, const double) * } */ - public static int MagickPosterizeImage(MemorySegment x0, long x1, int x2) { - var mh$ = MagickPosterizeImage.HANDLE; + public static int MagickSetImageFuzz(MemorySegment x0, double x1) { + var mh$ = MagickSetImageFuzz.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickPosterizeImage", x0, x1, x2); + traceDowncall("MagickSetImageFuzz", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickPreviousImage { + private static class MagickSetImageGamma { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPreviousImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageGamma"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13293,62 +27814,58 @@ private static class MagickPreviousImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickPreviousImage(MagickWand *) + * extern MagickBooleanType MagickSetImageGamma(MagickWand *, const double) * } - */ - public static FunctionDescriptor MagickPreviousImage$descriptor() { - return MagickPreviousImage.DESC; + */ + public static FunctionDescriptor MagickSetImageGamma$descriptor() { + return MagickSetImageGamma.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickPreviousImage(MagickWand *) + * extern MagickBooleanType MagickSetImageGamma(MagickWand *, const double) * } */ - public static MethodHandle MagickPreviousImage$handle() { - return MagickPreviousImage.HANDLE; + public static MethodHandle MagickSetImageGamma$handle() { + return MagickSetImageGamma.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickPreviousImage(MagickWand *) + * extern MagickBooleanType MagickSetImageGamma(MagickWand *, const double) * } */ - public static MemorySegment MagickPreviousImage$address() { - return MagickPreviousImage.ADDR; + public static MemorySegment MagickSetImageGamma$address() { + return MagickSetImageGamma.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickPreviousImage(MagickWand *) + * extern MagickBooleanType MagickSetImageGamma(MagickWand *, const double) * } */ - public static int MagickPreviousImage(MemorySegment x0) { - var mh$ = MagickPreviousImage.HANDLE; + public static int MagickSetImageGamma(MemorySegment x0, double x1) { + var mh$ = MagickSetImageGamma.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickPreviousImage", x0); + traceDowncall("MagickSetImageGamma", x0, x1); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickQuantizeImage { + private static class MagickSetImageGravity { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_INT, - MagickWand_h.C_LONG, - MagickWand_h.C_INT, MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQuantizeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageGravity"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13356,62 +27873,60 @@ private static class MagickQuantizeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickQuantizeImage(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageGravity(MagickWand *, const GravityType) * } */ - public static FunctionDescriptor MagickQuantizeImage$descriptor() { - return MagickQuantizeImage.DESC; + public static FunctionDescriptor MagickSetImageGravity$descriptor() { + return MagickSetImageGravity.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickQuantizeImage(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageGravity(MagickWand *, const GravityType) * } */ - public static MethodHandle MagickQuantizeImage$handle() { - return MagickQuantizeImage.HANDLE; + public static MethodHandle MagickSetImageGravity$handle() { + return MagickSetImageGravity.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickQuantizeImage(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageGravity(MagickWand *, const GravityType) * } */ - public static MemorySegment MagickQuantizeImage$address() { - return MagickQuantizeImage.ADDR; + public static MemorySegment MagickSetImageGravity$address() { + return MagickSetImageGravity.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickQuantizeImage(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageGravity(MagickWand *, const GravityType) * } */ - public static int MagickQuantizeImage(MemorySegment x0, long x1, int x2, long x3, int x4, int x5) { - var mh$ = MagickQuantizeImage.HANDLE; + public static int MagickSetImageGravity(MemorySegment x0, int x1) { + var mh$ = MagickSetImageGravity.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickQuantizeImage", x0, x1, x2, x3, x4, x5); + traceDowncall("MagickSetImageGravity", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickQuantizeImages { + private static class MagickSetImageGreenPrimary { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_INT, - MagickWand_h.C_LONG, - MagickWand_h.C_INT, - MagickWand_h.C_INT + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickQuantizeImages"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageGreenPrimary"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13419,61 +27934,58 @@ private static class MagickQuantizeImages { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickQuantizeImages(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageGreenPrimary(MagickWand *, const double, const double, const double) * } */ - public static FunctionDescriptor MagickQuantizeImages$descriptor() { - return MagickQuantizeImages.DESC; + public static FunctionDescriptor MagickSetImageGreenPrimary$descriptor() { + return MagickSetImageGreenPrimary.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickQuantizeImages(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageGreenPrimary(MagickWand *, const double, const double, const double) * } */ - public static MethodHandle MagickQuantizeImages$handle() { - return MagickQuantizeImages.HANDLE; + public static MethodHandle MagickSetImageGreenPrimary$handle() { + return MagickSetImageGreenPrimary.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickQuantizeImages(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageGreenPrimary(MagickWand *, const double, const double, const double) * } */ - public static MemorySegment MagickQuantizeImages$address() { - return MagickQuantizeImages.ADDR; + public static MemorySegment MagickSetImageGreenPrimary$address() { + return MagickSetImageGreenPrimary.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickQuantizeImages(MagickWand *, const size_t, const ColorspaceType, const size_t, const DitherMethod, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageGreenPrimary(MagickWand *, const double, const double, const double) * } */ - public static int MagickQuantizeImages(MemorySegment x0, long x1, int x2, long x3, int x4, int x5) { - var mh$ = MagickQuantizeImages.HANDLE; + public static int MagickSetImageGreenPrimary(MemorySegment x0, double x1, double x2, double x3) { + var mh$ = MagickSetImageGreenPrimary.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickQuantizeImages", x0, x1, x2, x3, x4, x5); + traceDowncall("MagickSetImageGreenPrimary", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickRangeThresholdImage { + private static class MagickSetImageInterlaceScheme { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRangeThresholdImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageInterlaceScheme"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13481,58 +27993,58 @@ private static class MagickRangeThresholdImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickRangeThresholdImage(MagickWand *, const double, const double, const double, const double) + * extern MagickBooleanType MagickSetImageInterlaceScheme(MagickWand *, const InterlaceType) * } */ - public static FunctionDescriptor MagickRangeThresholdImage$descriptor() { - return MagickRangeThresholdImage.DESC; + public static FunctionDescriptor MagickSetImageInterlaceScheme$descriptor() { + return MagickSetImageInterlaceScheme.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickRangeThresholdImage(MagickWand *, const double, const double, const double, const double) + * extern MagickBooleanType MagickSetImageInterlaceScheme(MagickWand *, const InterlaceType) * } */ - public static MethodHandle MagickRangeThresholdImage$handle() { - return MagickRangeThresholdImage.HANDLE; + public static MethodHandle MagickSetImageInterlaceScheme$handle() { + return MagickSetImageInterlaceScheme.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickRangeThresholdImage(MagickWand *, const double, const double, const double, const double) + * extern MagickBooleanType MagickSetImageInterlaceScheme(MagickWand *, const InterlaceType) * } */ - public static MemorySegment MagickRangeThresholdImage$address() { - return MagickRangeThresholdImage.ADDR; + public static MemorySegment MagickSetImageInterlaceScheme$address() { + return MagickSetImageInterlaceScheme.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickRangeThresholdImage(MagickWand *, const double, const double, const double, const double) + * extern MagickBooleanType MagickSetImageInterlaceScheme(MagickWand *, const InterlaceType) * } */ - public static int MagickRangeThresholdImage(MemorySegment x0, double x1, double x2, double x3, double x4) { - var mh$ = MagickRangeThresholdImage.HANDLE; + public static int MagickSetImageInterlaceScheme(MemorySegment x0, int x1) { + var mh$ = MagickSetImageInterlaceScheme.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickRangeThresholdImage", x0, x1, x2, x3, x4); + traceDowncall("MagickSetImageInterlaceScheme", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickRotationalBlurImage { + private static class MagickSetImageInterpolateMethod { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRotationalBlurImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageInterpolateMethod"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13540,43 +28052,43 @@ private static class MagickRotationalBlurImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickRotationalBlurImage(MagickWand *, const double) + * extern MagickBooleanType MagickSetImageInterpolateMethod(MagickWand *, const PixelInterpolateMethod) * } */ - public static FunctionDescriptor MagickRotationalBlurImage$descriptor() { - return MagickRotationalBlurImage.DESC; + public static FunctionDescriptor MagickSetImageInterpolateMethod$descriptor() { + return MagickSetImageInterpolateMethod.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickRotationalBlurImage(MagickWand *, const double) + * extern MagickBooleanType MagickSetImageInterpolateMethod(MagickWand *, const PixelInterpolateMethod) * } */ - public static MethodHandle MagickRotationalBlurImage$handle() { - return MagickRotationalBlurImage.HANDLE; + public static MethodHandle MagickSetImageInterpolateMethod$handle() { + return MagickSetImageInterpolateMethod.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickRotationalBlurImage(MagickWand *, const double) + * extern MagickBooleanType MagickSetImageInterpolateMethod(MagickWand *, const PixelInterpolateMethod) * } */ - public static MemorySegment MagickRotationalBlurImage$address() { - return MagickRotationalBlurImage.ADDR; + public static MemorySegment MagickSetImageInterpolateMethod$address() { + return MagickSetImageInterpolateMethod.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickRotationalBlurImage(MagickWand *, const double) + * extern MagickBooleanType MagickSetImageInterpolateMethod(MagickWand *, const PixelInterpolateMethod) * } */ - public static int MagickRotationalBlurImage(MemorySegment x0, double x1) { - var mh$ = MagickRotationalBlurImage.HANDLE; + public static int MagickSetImageInterpolateMethod(MemorySegment x0, int x1) { + var mh$ = MagickSetImageInterpolateMethod.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickRotationalBlurImage", x0, x1); + traceDowncall("MagickSetImageInterpolateMethod", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -13584,18 +28096,14 @@ public static int MagickRotationalBlurImage(MemorySegment x0, double x1) { } } - private static class MagickRaiseImage { + private static class MagickSetImageIterations { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_INT + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRaiseImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageIterations"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13603,59 +28111,59 @@ private static class MagickRaiseImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickRaiseImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageIterations(MagickWand *, const size_t) * } */ - public static FunctionDescriptor MagickRaiseImage$descriptor() { - return MagickRaiseImage.DESC; + public static FunctionDescriptor MagickSetImageIterations$descriptor() { + return MagickSetImageIterations.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickRaiseImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageIterations(MagickWand *, const size_t) * } */ - public static MethodHandle MagickRaiseImage$handle() { - return MagickRaiseImage.HANDLE; + public static MethodHandle MagickSetImageIterations$handle() { + return MagickSetImageIterations.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickRaiseImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageIterations(MagickWand *, const size_t) * } */ - public static MemorySegment MagickRaiseImage$address() { - return MagickRaiseImage.ADDR; + public static MemorySegment MagickSetImageIterations$address() { + return MagickSetImageIterations.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickRaiseImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t, const MagickBooleanType) + * extern MagickBooleanType MagickSetImageIterations(MagickWand *, const size_t) * } */ - public static int MagickRaiseImage(MemorySegment x0, long x1, long x2, long x3, long x4, int x5) { - var mh$ = MagickRaiseImage.HANDLE; + public static int MagickSetImageIterations(MemorySegment x0, long x1) { + var mh$ = MagickSetImageIterations.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickRaiseImage", x0, x1, x2, x3, x4, x5); + traceDowncall("MagickSetImageIterations", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickRandomThresholdImage { + private static class MagickSetImageMask { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_INT, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRandomThresholdImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageMask"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13663,43 +28171,43 @@ private static class MagickRandomThresholdImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickRandomThresholdImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSetImageMask(MagickWand *, const PixelMask, const MagickWand *) * } */ - public static FunctionDescriptor MagickRandomThresholdImage$descriptor() { - return MagickRandomThresholdImage.DESC; + public static FunctionDescriptor MagickSetImageMask$descriptor() { + return MagickSetImageMask.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickRandomThresholdImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSetImageMask(MagickWand *, const PixelMask, const MagickWand *) * } */ - public static MethodHandle MagickRandomThresholdImage$handle() { - return MagickRandomThresholdImage.HANDLE; + public static MethodHandle MagickSetImageMask$handle() { + return MagickSetImageMask.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickRandomThresholdImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSetImageMask(MagickWand *, const PixelMask, const MagickWand *) * } */ - public static MemorySegment MagickRandomThresholdImage$address() { - return MagickRandomThresholdImage.ADDR; + public static MemorySegment MagickSetImageMask$address() { + return MagickSetImageMask.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickRandomThresholdImage(MagickWand *, const double, const double) + * extern MagickBooleanType MagickSetImageMask(MagickWand *, const PixelMask, const MagickWand *) * } */ - public static int MagickRandomThresholdImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickRandomThresholdImage.HANDLE; + public static int MagickSetImageMask(MemorySegment x0, int x1, MemorySegment x2) { + var mh$ = MagickSetImageMask.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickRandomThresholdImage", x0, x1, x2); + traceDowncall("MagickSetImageMask", x0, x1, x2); } return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { @@ -13707,14 +28215,14 @@ public static int MagickRandomThresholdImage(MemorySegment x0, double x1, double } } - private static class MagickReadImage { + private static class MagickSetImageMatte { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickReadImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageMatte"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13722,43 +28230,43 @@ private static class MagickReadImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickReadImage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageMatte(MagickWand *, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickReadImage$descriptor() { - return MagickReadImage.DESC; + public static FunctionDescriptor MagickSetImageMatte$descriptor() { + return MagickSetImageMatte.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickReadImage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageMatte(MagickWand *, const MagickBooleanType) * } */ - public static MethodHandle MagickReadImage$handle() { - return MagickReadImage.HANDLE; + public static MethodHandle MagickSetImageMatte$handle() { + return MagickSetImageMatte.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickReadImage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageMatte(MagickWand *, const MagickBooleanType) * } */ - public static MemorySegment MagickReadImage$address() { - return MagickReadImage.ADDR; + public static MemorySegment MagickSetImageMatte$address() { + return MagickSetImageMatte.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickReadImage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageMatte(MagickWand *, const MagickBooleanType) * } */ - public static int MagickReadImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickReadImage.HANDLE; + public static int MagickSetImageMatte(MemorySegment x0, int x1) { + var mh$ = MagickSetImageMatte.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickReadImage", x0, x1); + traceDowncall("MagickSetImageMatte", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -13766,15 +28274,14 @@ public static int MagickReadImage(MemorySegment x0, MemorySegment x1) { } } - private static class MagickReadImageBlob { + private static class MagickSetImageMatteColor { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickReadImageBlob"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageMatteColor"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13782,58 +28289,58 @@ private static class MagickReadImageBlob { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickReadImageBlob(MagickWand *, const void *, const size_t) + * extern MagickBooleanType MagickSetImageMatteColor(MagickWand *, const PixelWand *) * } */ - public static FunctionDescriptor MagickReadImageBlob$descriptor() { - return MagickReadImageBlob.DESC; + public static FunctionDescriptor MagickSetImageMatteColor$descriptor() { + return MagickSetImageMatteColor.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickReadImageBlob(MagickWand *, const void *, const size_t) + * extern MagickBooleanType MagickSetImageMatteColor(MagickWand *, const PixelWand *) * } */ - public static MethodHandle MagickReadImageBlob$handle() { - return MagickReadImageBlob.HANDLE; + public static MethodHandle MagickSetImageMatteColor$handle() { + return MagickSetImageMatteColor.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickReadImageBlob(MagickWand *, const void *, const size_t) + * extern MagickBooleanType MagickSetImageMatteColor(MagickWand *, const PixelWand *) * } */ - public static MemorySegment MagickReadImageBlob$address() { - return MagickReadImageBlob.ADDR; + public static MemorySegment MagickSetImageMatteColor$address() { + return MagickSetImageMatteColor.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickReadImageBlob(MagickWand *, const void *, const size_t) + * extern MagickBooleanType MagickSetImageMatteColor(MagickWand *, const PixelWand *) * } */ - public static int MagickReadImageBlob(MemorySegment x0, MemorySegment x1, long x2) { - var mh$ = MagickReadImageBlob.HANDLE; + public static int MagickSetImageMatteColor(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickSetImageMatteColor.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickReadImageBlob", x0, x1, x2); + traceDowncall("MagickSetImageMatteColor", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickReadImageFile { + private static class MagickSetImageOrientation { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickReadImageFile"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageOrientation"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13841,43 +28348,43 @@ private static class MagickReadImageFile { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickReadImageFile(MagickWand *, FILE *) + * extern MagickBooleanType MagickSetImageOrientation(MagickWand *, const OrientationType) * } */ - public static FunctionDescriptor MagickReadImageFile$descriptor() { - return MagickReadImageFile.DESC; + public static FunctionDescriptor MagickSetImageOrientation$descriptor() { + return MagickSetImageOrientation.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickReadImageFile(MagickWand *, FILE *) + * extern MagickBooleanType MagickSetImageOrientation(MagickWand *, const OrientationType) * } */ - public static MethodHandle MagickReadImageFile$handle() { - return MagickReadImageFile.HANDLE; + public static MethodHandle MagickSetImageOrientation$handle() { + return MagickSetImageOrientation.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickReadImageFile(MagickWand *, FILE *) + * extern MagickBooleanType MagickSetImageOrientation(MagickWand *, const OrientationType) * } */ - public static MemorySegment MagickReadImageFile$address() { - return MagickReadImageFile.ADDR; + public static MemorySegment MagickSetImageOrientation$address() { + return MagickSetImageOrientation.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickReadImageFile(MagickWand *, FILE *) + * extern MagickBooleanType MagickSetImageOrientation(MagickWand *, const OrientationType) * } */ - public static int MagickReadImageFile(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickReadImageFile.HANDLE; + public static int MagickSetImageOrientation(MemorySegment x0, int x1) { + var mh$ = MagickSetImageOrientation.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickReadImageFile", x0, x1); + traceDowncall("MagickSetImageOrientation", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -13885,15 +28392,17 @@ public static int MagickReadImageFile(MemorySegment x0, MemorySegment x1) { } } - private static class MagickRemapImage { + private static class MagickSetImagePage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRemapImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImagePage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13901,57 +28410,60 @@ private static class MagickRemapImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickRemapImage(MagickWand *, const MagickWand *, const DitherMethod) + * extern MagickBooleanType MagickSetImagePage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static FunctionDescriptor MagickRemapImage$descriptor() { - return MagickRemapImage.DESC; + public static FunctionDescriptor MagickSetImagePage$descriptor() { + return MagickSetImagePage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickRemapImage(MagickWand *, const MagickWand *, const DitherMethod) + * extern MagickBooleanType MagickSetImagePage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static MethodHandle MagickRemapImage$handle() { - return MagickRemapImage.HANDLE; + public static MethodHandle MagickSetImagePage$handle() { + return MagickSetImagePage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickRemapImage(MagickWand *, const MagickWand *, const DitherMethod) + * extern MagickBooleanType MagickSetImagePage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static MemorySegment MagickRemapImage$address() { - return MagickRemapImage.ADDR; + public static MemorySegment MagickSetImagePage$address() { + return MagickSetImagePage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickRemapImage(MagickWand *, const MagickWand *, const DitherMethod) + * extern MagickBooleanType MagickSetImagePage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static int MagickRemapImage(MemorySegment x0, MemorySegment x1, int x2) { - var mh$ = MagickRemapImage.HANDLE; + public static int MagickSetImagePage(MemorySegment x0, long x1, long x2, long x3, long x4) { + var mh$ = MagickSetImagePage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickRemapImage", x0, x1, x2); + traceDowncall("MagickSetImagePage", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickRemoveImage { + private static class MagickSetImagePixelColor { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRemoveImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImagePixelColor"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -13959,60 +28471,60 @@ private static class MagickRemoveImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickRemoveImage(MagickWand *) + * extern MagickBooleanType MagickSetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, const PixelWand *) * } */ - public static FunctionDescriptor MagickRemoveImage$descriptor() { - return MagickRemoveImage.DESC; + public static FunctionDescriptor MagickSetImagePixelColor$descriptor() { + return MagickSetImagePixelColor.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickRemoveImage(MagickWand *) + * extern MagickBooleanType MagickSetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, const PixelWand *) * } */ - public static MethodHandle MagickRemoveImage$handle() { - return MagickRemoveImage.HANDLE; + public static MethodHandle MagickSetImagePixelColor$handle() { + return MagickSetImagePixelColor.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickRemoveImage(MagickWand *) + * extern MagickBooleanType MagickSetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, const PixelWand *) * } */ - public static MemorySegment MagickRemoveImage$address() { - return MagickRemoveImage.ADDR; + public static MemorySegment MagickSetImagePixelColor$address() { + return MagickSetImagePixelColor.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickRemoveImage(MagickWand *) + * extern MagickBooleanType MagickSetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, const PixelWand *) * } */ - public static int MagickRemoveImage(MemorySegment x0) { - var mh$ = MagickRemoveImage.HANDLE; + public static int MagickSetImagePixelColor(MemorySegment x0, long x1, long x2, MemorySegment x3) { + var mh$ = MagickSetImagePixelColor.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickRemoveImage", x0); + traceDowncall("MagickSetImagePixelColor", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickResampleImage { + private static class MagickSetImageRedPrimary { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_DOUBLE, MagickWand_h.C_DOUBLE, - MagickWand_h.C_INT + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickResampleImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageRedPrimary"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14020,43 +28532,43 @@ private static class MagickResampleImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickResampleImage(MagickWand *, const double, const double, const FilterType) + * extern MagickBooleanType MagickSetImageRedPrimary(MagickWand *, const double, const double, const double) * } */ - public static FunctionDescriptor MagickResampleImage$descriptor() { - return MagickResampleImage.DESC; + public static FunctionDescriptor MagickSetImageRedPrimary$descriptor() { + return MagickSetImageRedPrimary.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickResampleImage(MagickWand *, const double, const double, const FilterType) + * extern MagickBooleanType MagickSetImageRedPrimary(MagickWand *, const double, const double, const double) * } */ - public static MethodHandle MagickResampleImage$handle() { - return MagickResampleImage.HANDLE; + public static MethodHandle MagickSetImageRedPrimary$handle() { + return MagickSetImageRedPrimary.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickResampleImage(MagickWand *, const double, const double, const FilterType) + * extern MagickBooleanType MagickSetImageRedPrimary(MagickWand *, const double, const double, const double) * } */ - public static MemorySegment MagickResampleImage$address() { - return MagickResampleImage.ADDR; + public static MemorySegment MagickSetImageRedPrimary$address() { + return MagickSetImageRedPrimary.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickResampleImage(MagickWand *, const double, const double, const FilterType) + * extern MagickBooleanType MagickSetImageRedPrimary(MagickWand *, const double, const double, const double) * } */ - public static int MagickResampleImage(MemorySegment x0, double x1, double x2, int x3) { - var mh$ = MagickResampleImage.HANDLE; + public static int MagickSetImageRedPrimary(MemorySegment x0, double x1, double x2, double x3) { + var mh$ = MagickSetImageRedPrimary.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickResampleImage", x0, x1, x2, x3); + traceDowncall("MagickSetImageRedPrimary", x0, x1, x2, x3); } return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { @@ -14064,14 +28576,14 @@ public static int MagickResampleImage(MemorySegment x0, double x1, double x2, in } } - private static class MagickResetImagePage { + private static class MagickSetImageRenderingIntent { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickResetImagePage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageRenderingIntent"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14079,43 +28591,43 @@ private static class MagickResetImagePage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickResetImagePage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageRenderingIntent(MagickWand *, const RenderingIntent) * } */ - public static FunctionDescriptor MagickResetImagePage$descriptor() { - return MagickResetImagePage.DESC; + public static FunctionDescriptor MagickSetImageRenderingIntent$descriptor() { + return MagickSetImageRenderingIntent.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickResetImagePage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageRenderingIntent(MagickWand *, const RenderingIntent) * } */ - public static MethodHandle MagickResetImagePage$handle() { - return MagickResetImagePage.HANDLE; + public static MethodHandle MagickSetImageRenderingIntent$handle() { + return MagickSetImageRenderingIntent.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickResetImagePage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageRenderingIntent(MagickWand *, const RenderingIntent) * } */ - public static MemorySegment MagickResetImagePage$address() { - return MagickResetImagePage.ADDR; + public static MemorySegment MagickSetImageRenderingIntent$address() { + return MagickSetImageRenderingIntent.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickResetImagePage(MagickWand *, const char *) + * extern MagickBooleanType MagickSetImageRenderingIntent(MagickWand *, const RenderingIntent) * } */ - public static int MagickResetImagePage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickResetImagePage.HANDLE; + public static int MagickSetImageRenderingIntent(MemorySegment x0, int x1) { + var mh$ = MagickSetImageRenderingIntent.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickResetImagePage", x0, x1); + traceDowncall("MagickSetImageRenderingIntent", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -14123,16 +28635,15 @@ public static int MagickResetImagePage(MemorySegment x0, MemorySegment x1) { } } - private static class MagickResizeImage { + private static class MagickSetImageResolution { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_INT + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickResizeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageResolution"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14140,59 +28651,58 @@ private static class MagickResizeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickResizeImage(MagickWand *, const size_t, const size_t, const FilterType) + * extern MagickBooleanType MagickSetImageResolution(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickResizeImage$descriptor() { - return MagickResizeImage.DESC; + public static FunctionDescriptor MagickSetImageResolution$descriptor() { + return MagickSetImageResolution.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickResizeImage(MagickWand *, const size_t, const size_t, const FilterType) + * extern MagickBooleanType MagickSetImageResolution(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickResizeImage$handle() { - return MagickResizeImage.HANDLE; + public static MethodHandle MagickSetImageResolution$handle() { + return MagickSetImageResolution.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickResizeImage(MagickWand *, const size_t, const size_t, const FilterType) + * extern MagickBooleanType MagickSetImageResolution(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickResizeImage$address() { - return MagickResizeImage.ADDR; + public static MemorySegment MagickSetImageResolution$address() { + return MagickSetImageResolution.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickResizeImage(MagickWand *, const size_t, const size_t, const FilterType) + * extern MagickBooleanType MagickSetImageResolution(MagickWand *, const double, const double) * } */ - public static int MagickResizeImage(MemorySegment x0, long x1, long x2, int x3) { - var mh$ = MagickResizeImage.HANDLE; + public static int MagickSetImageResolution(MemorySegment x0, double x1, double x2) { + var mh$ = MagickSetImageResolution.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickResizeImage", x0, x1, x2, x3); + traceDowncall("MagickSetImageResolution", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickRollImage { + private static class MagickSetImageScene { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRollImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageScene"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14200,59 +28710,58 @@ private static class MagickRollImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickRollImage(MagickWand *, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickSetImageScene(MagickWand *, const size_t) * } */ - public static FunctionDescriptor MagickRollImage$descriptor() { - return MagickRollImage.DESC; + public static FunctionDescriptor MagickSetImageScene$descriptor() { + return MagickSetImageScene.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickRollImage(MagickWand *, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickSetImageScene(MagickWand *, const size_t) * } */ - public static MethodHandle MagickRollImage$handle() { - return MagickRollImage.HANDLE; + public static MethodHandle MagickSetImageScene$handle() { + return MagickSetImageScene.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickRollImage(MagickWand *, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickSetImageScene(MagickWand *, const size_t) * } */ - public static MemorySegment MagickRollImage$address() { - return MagickRollImage.ADDR; + public static MemorySegment MagickSetImageScene$address() { + return MagickSetImageScene.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickRollImage(MagickWand *, const ssize_t, const ssize_t) + * extern MagickBooleanType MagickSetImageScene(MagickWand *, const size_t) * } */ - public static int MagickRollImage(MemorySegment x0, long x1, long x2) { - var mh$ = MagickRollImage.HANDLE; + public static int MagickSetImageScene(MemorySegment x0, long x1) { + var mh$ = MagickSetImageScene.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickRollImage", x0, x1, x2); + traceDowncall("MagickSetImageScene", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickRotateImage { + private static class MagickSetImageTicksPerSecond { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickRotateImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageTicksPerSecond"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14260,59 +28769,58 @@ private static class MagickRotateImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickRotateImage(MagickWand *, const PixelWand *, const double) + * extern MagickBooleanType MagickSetImageTicksPerSecond(MagickWand *, const ssize_t) * } */ - public static FunctionDescriptor MagickRotateImage$descriptor() { - return MagickRotateImage.DESC; + public static FunctionDescriptor MagickSetImageTicksPerSecond$descriptor() { + return MagickSetImageTicksPerSecond.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickRotateImage(MagickWand *, const PixelWand *, const double) + * extern MagickBooleanType MagickSetImageTicksPerSecond(MagickWand *, const ssize_t) * } */ - public static MethodHandle MagickRotateImage$handle() { - return MagickRotateImage.HANDLE; + public static MethodHandle MagickSetImageTicksPerSecond$handle() { + return MagickSetImageTicksPerSecond.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickRotateImage(MagickWand *, const PixelWand *, const double) + * extern MagickBooleanType MagickSetImageTicksPerSecond(MagickWand *, const ssize_t) * } */ - public static MemorySegment MagickRotateImage$address() { - return MagickRotateImage.ADDR; + public static MemorySegment MagickSetImageTicksPerSecond$address() { + return MagickSetImageTicksPerSecond.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickRotateImage(MagickWand *, const PixelWand *, const double) + * extern MagickBooleanType MagickSetImageTicksPerSecond(MagickWand *, const ssize_t) * } */ - public static int MagickRotateImage(MemorySegment x0, MemorySegment x1, double x2) { - var mh$ = MagickRotateImage.HANDLE; + public static int MagickSetImageTicksPerSecond(MemorySegment x0, long x1) { + var mh$ = MagickSetImageTicksPerSecond.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickRotateImage", x0, x1, x2); + traceDowncall("MagickSetImageTicksPerSecond", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSampleImage { + private static class MagickSetImageType { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSampleImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageType"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14320,59 +28828,58 @@ private static class MagickSampleImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSampleImage(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickSetImageType(MagickWand *, const ImageType) * } */ - public static FunctionDescriptor MagickSampleImage$descriptor() { - return MagickSampleImage.DESC; + public static FunctionDescriptor MagickSetImageType$descriptor() { + return MagickSetImageType.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSampleImage(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickSetImageType(MagickWand *, const ImageType) * } */ - public static MethodHandle MagickSampleImage$handle() { - return MagickSampleImage.HANDLE; + public static MethodHandle MagickSetImageType$handle() { + return MagickSetImageType.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSampleImage(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickSetImageType(MagickWand *, const ImageType) * } */ - public static MemorySegment MagickSampleImage$address() { - return MagickSampleImage.ADDR; + public static MemorySegment MagickSetImageType$address() { + return MagickSetImageType.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSampleImage(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickSetImageType(MagickWand *, const ImageType) * } */ - public static int MagickSampleImage(MemorySegment x0, long x1, long x2) { - var mh$ = MagickSampleImage.HANDLE; + public static int MagickSetImageType(MemorySegment x0, int x1) { + var mh$ = MagickSetImageType.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSampleImage", x0, x1, x2); + traceDowncall("MagickSetImageType", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickScaleImage { + private static class MagickSetImageUnits { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickScaleImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageUnits"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14380,61 +28887,60 @@ private static class MagickScaleImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickScaleImage(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickSetImageUnits(MagickWand *, const ResolutionType) * } */ - public static FunctionDescriptor MagickScaleImage$descriptor() { - return MagickScaleImage.DESC; + public static FunctionDescriptor MagickSetImageUnits$descriptor() { + return MagickSetImageUnits.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickScaleImage(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickSetImageUnits(MagickWand *, const ResolutionType) * } */ - public static MethodHandle MagickScaleImage$handle() { - return MagickScaleImage.HANDLE; + public static MethodHandle MagickSetImageUnits$handle() { + return MagickSetImageUnits.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickScaleImage(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickSetImageUnits(MagickWand *, const ResolutionType) * } */ - public static MemorySegment MagickScaleImage$address() { - return MagickScaleImage.ADDR; + public static MemorySegment MagickSetImageUnits$address() { + return MagickSetImageUnits.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickScaleImage(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickSetImageUnits(MagickWand *, const ResolutionType) * } */ - public static int MagickScaleImage(MemorySegment x0, long x1, long x2) { - var mh$ = MagickScaleImage.HANDLE; + public static int MagickSetImageUnits(MemorySegment x0, int x1) { + var mh$ = MagickSetImageUnits.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickScaleImage", x0, x1, x2); + traceDowncall("MagickSetImageUnits", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSegmentImage { + private static class MagickSetImageWhitePoint { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_INT, + MagickWand_h.C_DOUBLE, MagickWand_h.C_DOUBLE, MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSegmentImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageWhitePoint"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14442,60 +28948,60 @@ private static class MagickSegmentImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSegmentImage(MagickWand *, const ColorspaceType, const MagickBooleanType, const double, const double) + * extern MagickBooleanType MagickSetImageWhitePoint(MagickWand *, const double, const double, const double) * } */ - public static FunctionDescriptor MagickSegmentImage$descriptor() { - return MagickSegmentImage.DESC; + public static FunctionDescriptor MagickSetImageWhitePoint$descriptor() { + return MagickSetImageWhitePoint.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSegmentImage(MagickWand *, const ColorspaceType, const MagickBooleanType, const double, const double) + * extern MagickBooleanType MagickSetImageWhitePoint(MagickWand *, const double, const double, const double) * } */ - public static MethodHandle MagickSegmentImage$handle() { - return MagickSegmentImage.HANDLE; + public static MethodHandle MagickSetImageWhitePoint$handle() { + return MagickSetImageWhitePoint.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSegmentImage(MagickWand *, const ColorspaceType, const MagickBooleanType, const double, const double) + * extern MagickBooleanType MagickSetImageWhitePoint(MagickWand *, const double, const double, const double) * } */ - public static MemorySegment MagickSegmentImage$address() { - return MagickSegmentImage.ADDR; + public static MemorySegment MagickSetImageWhitePoint$address() { + return MagickSetImageWhitePoint.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSegmentImage(MagickWand *, const ColorspaceType, const MagickBooleanType, const double, const double) + * extern MagickBooleanType MagickSetImageWhitePoint(MagickWand *, const double, const double, const double) * } */ - public static int MagickSegmentImage(MemorySegment x0, int x1, int x2, double x3, double x4) { - var mh$ = MagickSegmentImage.HANDLE; + public static int MagickSetImageWhitePoint(MemorySegment x0, double x1, double x2, double x3) { + var mh$ = MagickSetImageWhitePoint.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSegmentImage", x0, x1, x2, x3, x4); + traceDowncall("MagickSetImageWhitePoint", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSelectiveBlurImage { + private static class MagickShadeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, + MagickWand_h.C_INT, MagickWand_h.C_DOUBLE, MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSelectiveBlurImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickShadeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14503,43 +29009,43 @@ private static class MagickSelectiveBlurImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSelectiveBlurImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickShadeImage(MagickWand *, const MagickBooleanType, const double, const double) * } */ - public static FunctionDescriptor MagickSelectiveBlurImage$descriptor() { - return MagickSelectiveBlurImage.DESC; + public static FunctionDescriptor MagickShadeImage$descriptor() { + return MagickShadeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSelectiveBlurImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickShadeImage(MagickWand *, const MagickBooleanType, const double, const double) * } */ - public static MethodHandle MagickSelectiveBlurImage$handle() { - return MagickSelectiveBlurImage.HANDLE; + public static MethodHandle MagickShadeImage$handle() { + return MagickShadeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSelectiveBlurImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickShadeImage(MagickWand *, const MagickBooleanType, const double, const double) * } */ - public static MemorySegment MagickSelectiveBlurImage$address() { - return MagickSelectiveBlurImage.ADDR; + public static MemorySegment MagickShadeImage$address() { + return MagickShadeImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSelectiveBlurImage(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickShadeImage(MagickWand *, const MagickBooleanType, const double, const double) * } */ - public static int MagickSelectiveBlurImage(MemorySegment x0, double x1, double x2, double x3) { - var mh$ = MagickSelectiveBlurImage.HANDLE; + public static int MagickShadeImage(MemorySegment x0, int x1, double x2, double x3) { + var mh$ = MagickShadeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSelectiveBlurImage", x0, x1, x2, x3); + traceDowncall("MagickShadeImage", x0, x1, x2, x3); } return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { @@ -14547,14 +29053,17 @@ public static int MagickSelectiveBlurImage(MemorySegment x0, double x1, double x } } - private static class MagickSeparateImage { + private static class MagickShadowImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSeparateImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickShadowImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14562,58 +29071,59 @@ private static class MagickSeparateImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSeparateImage(MagickWand *, const ChannelType) + * extern MagickBooleanType MagickShadowImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) * } */ - public static FunctionDescriptor MagickSeparateImage$descriptor() { - return MagickSeparateImage.DESC; + public static FunctionDescriptor MagickShadowImage$descriptor() { + return MagickShadowImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSeparateImage(MagickWand *, const ChannelType) + * extern MagickBooleanType MagickShadowImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) * } */ - public static MethodHandle MagickSeparateImage$handle() { - return MagickSeparateImage.HANDLE; + public static MethodHandle MagickShadowImage$handle() { + return MagickShadowImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSeparateImage(MagickWand *, const ChannelType) + * extern MagickBooleanType MagickShadowImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) * } */ - public static MemorySegment MagickSeparateImage$address() { - return MagickSeparateImage.ADDR; + public static MemorySegment MagickShadowImage$address() { + return MagickShadowImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSeparateImage(MagickWand *, const ChannelType) + * extern MagickBooleanType MagickShadowImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) * } */ - public static int MagickSeparateImage(MemorySegment x0, int x1) { - var mh$ = MagickSeparateImage.HANDLE; + public static int MagickShadowImage(MemorySegment x0, double x1, double x2, long x3, long x4) { + var mh$ = MagickShadowImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSeparateImage", x0, x1); + traceDowncall("MagickShadowImage", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSepiaToneImage { + private static class MagickSharpenImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSepiaToneImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSharpenImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14621,58 +29131,59 @@ private static class MagickSepiaToneImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSepiaToneImage(MagickWand *, const double) + * extern MagickBooleanType MagickSharpenImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickSepiaToneImage$descriptor() { - return MagickSepiaToneImage.DESC; + public static FunctionDescriptor MagickSharpenImage$descriptor() { + return MagickSharpenImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSepiaToneImage(MagickWand *, const double) + * extern MagickBooleanType MagickSharpenImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickSepiaToneImage$handle() { - return MagickSepiaToneImage.HANDLE; + public static MethodHandle MagickSharpenImage$handle() { + return MagickSharpenImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSepiaToneImage(MagickWand *, const double) + * extern MagickBooleanType MagickSharpenImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickSepiaToneImage$address() { - return MagickSepiaToneImage.ADDR; + public static MemorySegment MagickSharpenImage$address() { + return MagickSharpenImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSepiaToneImage(MagickWand *, const double) + * extern MagickBooleanType MagickSharpenImage(MagickWand *, const double, const double) * } */ - public static int MagickSepiaToneImage(MemorySegment x0, double x1) { - var mh$ = MagickSepiaToneImage.HANDLE; + public static int MagickSharpenImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickSharpenImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSepiaToneImage", x0, x1); + traceDowncall("MagickSharpenImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImage { + private static class MagickShaveImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickShaveImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14680,58 +29191,60 @@ private static class MagickSetImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImage(MagickWand *, const MagickWand *) + * extern MagickBooleanType MagickShaveImage(MagickWand *, const size_t, const size_t) * } */ - public static FunctionDescriptor MagickSetImage$descriptor() { - return MagickSetImage.DESC; + public static FunctionDescriptor MagickShaveImage$descriptor() { + return MagickShaveImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImage(MagickWand *, const MagickWand *) + * extern MagickBooleanType MagickShaveImage(MagickWand *, const size_t, const size_t) * } */ - public static MethodHandle MagickSetImage$handle() { - return MagickSetImage.HANDLE; + public static MethodHandle MagickShaveImage$handle() { + return MagickShaveImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImage(MagickWand *, const MagickWand *) + * extern MagickBooleanType MagickShaveImage(MagickWand *, const size_t, const size_t) * } */ - public static MemorySegment MagickSetImage$address() { - return MagickSetImage.ADDR; + public static MemorySegment MagickShaveImage$address() { + return MagickShaveImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImage(MagickWand *, const MagickWand *) + * extern MagickBooleanType MagickShaveImage(MagickWand *, const size_t, const size_t) * } */ - public static int MagickSetImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickSetImage.HANDLE; + public static int MagickShaveImage(MemorySegment x0, long x1, long x2) { + var mh$ = MagickShaveImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImage", x0, x1); + traceDowncall("MagickShaveImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageAlpha { + private static class MagickShearImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageAlpha"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickShearImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14739,58 +29252,60 @@ private static class MagickSetImageAlpha { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageAlpha(MagickWand *, const double) + * extern MagickBooleanType MagickShearImage(MagickWand *, const PixelWand *, const double, const double) * } */ - public static FunctionDescriptor MagickSetImageAlpha$descriptor() { - return MagickSetImageAlpha.DESC; + public static FunctionDescriptor MagickShearImage$descriptor() { + return MagickShearImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageAlpha(MagickWand *, const double) + * extern MagickBooleanType MagickShearImage(MagickWand *, const PixelWand *, const double, const double) * } */ - public static MethodHandle MagickSetImageAlpha$handle() { - return MagickSetImageAlpha.HANDLE; + public static MethodHandle MagickShearImage$handle() { + return MagickShearImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageAlpha(MagickWand *, const double) + * extern MagickBooleanType MagickShearImage(MagickWand *, const PixelWand *, const double, const double) * } */ - public static MemorySegment MagickSetImageAlpha$address() { - return MagickSetImageAlpha.ADDR; + public static MemorySegment MagickShearImage$address() { + return MagickShearImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageAlpha(MagickWand *, const double) + * extern MagickBooleanType MagickShearImage(MagickWand *, const PixelWand *, const double, const double) * } */ - public static int MagickSetImageAlpha(MemorySegment x0, double x1) { - var mh$ = MagickSetImageAlpha.HANDLE; + public static int MagickShearImage(MemorySegment x0, MemorySegment x1, double x2, double x3) { + var mh$ = MagickShearImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageAlpha", x0, x1); + traceDowncall("MagickShearImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageAlphaChannel { + private static class MagickSigmoidalContrastImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_INT, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageAlphaChannel"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSigmoidalContrastImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14798,58 +29313,60 @@ private static class MagickSetImageAlphaChannel { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageAlphaChannel(MagickWand *, const AlphaChannelOption) + * extern MagickBooleanType MagickSigmoidalContrastImage(MagickWand *, const MagickBooleanType, const double, const double) * } */ - public static FunctionDescriptor MagickSetImageAlphaChannel$descriptor() { - return MagickSetImageAlphaChannel.DESC; + public static FunctionDescriptor MagickSigmoidalContrastImage$descriptor() { + return MagickSigmoidalContrastImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageAlphaChannel(MagickWand *, const AlphaChannelOption) + * extern MagickBooleanType MagickSigmoidalContrastImage(MagickWand *, const MagickBooleanType, const double, const double) * } */ - public static MethodHandle MagickSetImageAlphaChannel$handle() { - return MagickSetImageAlphaChannel.HANDLE; + public static MethodHandle MagickSigmoidalContrastImage$handle() { + return MagickSigmoidalContrastImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageAlphaChannel(MagickWand *, const AlphaChannelOption) + * extern MagickBooleanType MagickSigmoidalContrastImage(MagickWand *, const MagickBooleanType, const double, const double) * } */ - public static MemorySegment MagickSetImageAlphaChannel$address() { - return MagickSetImageAlphaChannel.ADDR; + public static MemorySegment MagickSigmoidalContrastImage$address() { + return MagickSigmoidalContrastImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageAlphaChannel(MagickWand *, const AlphaChannelOption) + * extern MagickBooleanType MagickSigmoidalContrastImage(MagickWand *, const MagickBooleanType, const double, const double) * } */ - public static int MagickSetImageAlphaChannel(MemorySegment x0, int x1) { - var mh$ = MagickSetImageAlphaChannel.HANDLE; + public static int MagickSigmoidalContrastImage(MemorySegment x0, int x1, double x2, double x3) { + var mh$ = MagickSigmoidalContrastImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageAlphaChannel", x0, x1); + traceDowncall("MagickSigmoidalContrastImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageBackgroundColor { + private static class MagickSketchImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageBackgroundColor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSketchImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14857,60 +29374,58 @@ private static class MagickSetImageBackgroundColor { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageBackgroundColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickSketchImage(MagickWand *, const double, const double, const double) * } */ - public static FunctionDescriptor MagickSetImageBackgroundColor$descriptor() { - return MagickSetImageBackgroundColor.DESC; + public static FunctionDescriptor MagickSketchImage$descriptor() { + return MagickSketchImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageBackgroundColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickSketchImage(MagickWand *, const double, const double, const double) * } */ - public static MethodHandle MagickSetImageBackgroundColor$handle() { - return MagickSetImageBackgroundColor.HANDLE; + public static MethodHandle MagickSketchImage$handle() { + return MagickSketchImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageBackgroundColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickSketchImage(MagickWand *, const double, const double, const double) * } */ - public static MemorySegment MagickSetImageBackgroundColor$address() { - return MagickSetImageBackgroundColor.ADDR; + public static MemorySegment MagickSketchImage$address() { + return MagickSketchImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageBackgroundColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickSketchImage(MagickWand *, const double, const double, const double) * } */ - public static int MagickSetImageBackgroundColor(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickSetImageBackgroundColor.HANDLE; + public static int MagickSketchImage(MemorySegment x0, double x1, double x2, double x3) { + var mh$ = MagickSketchImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageBackgroundColor", x0, x1); + traceDowncall("MagickSketchImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageBluePrimary { + private static class MagickSolarizeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageBluePrimary"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSolarizeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14918,58 +29433,60 @@ private static class MagickSetImageBluePrimary { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageBluePrimary(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSolarizeImage(MagickWand *, const double) * } */ - public static FunctionDescriptor MagickSetImageBluePrimary$descriptor() { - return MagickSetImageBluePrimary.DESC; + public static FunctionDescriptor MagickSolarizeImage$descriptor() { + return MagickSolarizeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageBluePrimary(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSolarizeImage(MagickWand *, const double) * } */ - public static MethodHandle MagickSetImageBluePrimary$handle() { - return MagickSetImageBluePrimary.HANDLE; + public static MethodHandle MagickSolarizeImage$handle() { + return MagickSolarizeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageBluePrimary(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSolarizeImage(MagickWand *, const double) * } */ - public static MemorySegment MagickSetImageBluePrimary$address() { - return MagickSetImageBluePrimary.ADDR; + public static MemorySegment MagickSolarizeImage$address() { + return MagickSolarizeImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageBluePrimary(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickSolarizeImage(MagickWand *, const double) * } */ - public static int MagickSetImageBluePrimary(MemorySegment x0, double x1, double x2, double x3) { - var mh$ = MagickSetImageBluePrimary.HANDLE; + public static int MagickSolarizeImage(MemorySegment x0, double x1) { + var mh$ = MagickSolarizeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageBluePrimary", x0, x1, x2, x3); + traceDowncall("MagickSolarizeImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageBorderColor { + private static class MagickSparseColorImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_LONG, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageBorderColor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSparseColorImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -14977,58 +29494,61 @@ private static class MagickSetImageBorderColor { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageBorderColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickSparseColorImage(MagickWand *, const SparseColorMethod, const size_t, const double *) * } */ - public static FunctionDescriptor MagickSetImageBorderColor$descriptor() { - return MagickSetImageBorderColor.DESC; + public static FunctionDescriptor MagickSparseColorImage$descriptor() { + return MagickSparseColorImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageBorderColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickSparseColorImage(MagickWand *, const SparseColorMethod, const size_t, const double *) * } */ - public static MethodHandle MagickSetImageBorderColor$handle() { - return MagickSetImageBorderColor.HANDLE; + public static MethodHandle MagickSparseColorImage$handle() { + return MagickSparseColorImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageBorderColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickSparseColorImage(MagickWand *, const SparseColorMethod, const size_t, const double *) * } */ - public static MemorySegment MagickSetImageBorderColor$address() { - return MagickSetImageBorderColor.ADDR; + public static MemorySegment MagickSparseColorImage$address() { + return MagickSparseColorImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageBorderColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickSparseColorImage(MagickWand *, const SparseColorMethod, const size_t, const double *) * } */ - public static int MagickSetImageBorderColor(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickSetImageBorderColor.HANDLE; + public static int MagickSparseColorImage(MemorySegment x0, int x1, long x2, MemorySegment x3) { + var mh$ = MagickSparseColorImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageBorderColor", x0, x1); + traceDowncall("MagickSparseColorImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageColor { + private static class MagickSpliceImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageColor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSpliceImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15036,59 +29556,59 @@ private static class MagickSetImageColor { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickSpliceImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static FunctionDescriptor MagickSetImageColor$descriptor() { - return MagickSetImageColor.DESC; + public static FunctionDescriptor MagickSpliceImage$descriptor() { + return MagickSpliceImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickSpliceImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static MethodHandle MagickSetImageColor$handle() { - return MagickSetImageColor.HANDLE; + public static MethodHandle MagickSpliceImage$handle() { + return MagickSpliceImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickSpliceImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static MemorySegment MagickSetImageColor$address() { - return MagickSetImageColor.ADDR; + public static MemorySegment MagickSpliceImage$address() { + return MagickSpliceImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickSpliceImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static int MagickSetImageColor(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickSetImageColor.HANDLE; + public static int MagickSpliceImage(MemorySegment x0, long x1, long x2, long x3, long x4) { + var mh$ = MagickSpliceImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageColor", x0, x1); + traceDowncall("MagickSpliceImage", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageColormapColor { + private static class MagickSpreadImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_POINTER + MagickWand_h.C_INT, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageColormapColor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSpreadImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15096,43 +29616,43 @@ private static class MagickSetImageColormapColor { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageColormapColor(MagickWand *, const size_t, const PixelWand *) + * extern MagickBooleanType MagickSpreadImage(MagickWand *, const PixelInterpolateMethod, const double) * } */ - public static FunctionDescriptor MagickSetImageColormapColor$descriptor() { - return MagickSetImageColormapColor.DESC; + public static FunctionDescriptor MagickSpreadImage$descriptor() { + return MagickSpreadImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageColormapColor(MagickWand *, const size_t, const PixelWand *) + * extern MagickBooleanType MagickSpreadImage(MagickWand *, const PixelInterpolateMethod, const double) * } */ - public static MethodHandle MagickSetImageColormapColor$handle() { - return MagickSetImageColormapColor.HANDLE; + public static MethodHandle MagickSpreadImage$handle() { + return MagickSpreadImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageColormapColor(MagickWand *, const size_t, const PixelWand *) + * extern MagickBooleanType MagickSpreadImage(MagickWand *, const PixelInterpolateMethod, const double) * } */ - public static MemorySegment MagickSetImageColormapColor$address() { - return MagickSetImageColormapColor.ADDR; + public static MemorySegment MagickSpreadImage$address() { + return MagickSpreadImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageColormapColor(MagickWand *, const size_t, const PixelWand *) + * extern MagickBooleanType MagickSpreadImage(MagickWand *, const PixelInterpolateMethod, const double) * } */ - public static int MagickSetImageColormapColor(MemorySegment x0, long x1, MemorySegment x2) { - var mh$ = MagickSetImageColormapColor.HANDLE; + public static int MagickSpreadImage(MemorySegment x0, int x1, double x2) { + var mh$ = MagickSpreadImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageColormapColor", x0, x1, x2); + traceDowncall("MagickSpreadImage", x0, x1, x2); } return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { @@ -15140,14 +29660,16 @@ public static int MagickSetImageColormapColor(MemorySegment x0, long x1, MemoryS } } - private static class MagickSetImageColorspace { + private static class MagickStatisticImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_INT, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageColorspace"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickStatisticImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15155,58 +29677,57 @@ private static class MagickSetImageColorspace { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageColorspace(MagickWand *, const ColorspaceType) + * extern MagickBooleanType MagickStatisticImage(MagickWand *, const StatisticType, const size_t, const size_t) * } */ - public static FunctionDescriptor MagickSetImageColorspace$descriptor() { - return MagickSetImageColorspace.DESC; + public static FunctionDescriptor MagickStatisticImage$descriptor() { + return MagickStatisticImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageColorspace(MagickWand *, const ColorspaceType) + * extern MagickBooleanType MagickStatisticImage(MagickWand *, const StatisticType, const size_t, const size_t) * } */ - public static MethodHandle MagickSetImageColorspace$handle() { - return MagickSetImageColorspace.HANDLE; + public static MethodHandle MagickStatisticImage$handle() { + return MagickStatisticImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageColorspace(MagickWand *, const ColorspaceType) + * extern MagickBooleanType MagickStatisticImage(MagickWand *, const StatisticType, const size_t, const size_t) * } */ - public static MemorySegment MagickSetImageColorspace$address() { - return MagickSetImageColorspace.ADDR; + public static MemorySegment MagickStatisticImage$address() { + return MagickStatisticImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageColorspace(MagickWand *, const ColorspaceType) + * extern MagickBooleanType MagickStatisticImage(MagickWand *, const StatisticType, const size_t, const size_t) * } */ - public static int MagickSetImageColorspace(MemorySegment x0, int x1) { - var mh$ = MagickSetImageColorspace.HANDLE; + public static int MagickStatisticImage(MemorySegment x0, int x1, long x2, long x3) { + var mh$ = MagickStatisticImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageColorspace", x0, x1); + traceDowncall("MagickStatisticImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageCompose { + private static class MagickStripImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageCompose"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickStripImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15214,58 +29735,59 @@ private static class MagickSetImageCompose { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageCompose(MagickWand *, const CompositeOperator) + * extern MagickBooleanType MagickStripImage(MagickWand *) * } */ - public static FunctionDescriptor MagickSetImageCompose$descriptor() { - return MagickSetImageCompose.DESC; + public static FunctionDescriptor MagickStripImage$descriptor() { + return MagickStripImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageCompose(MagickWand *, const CompositeOperator) + * extern MagickBooleanType MagickStripImage(MagickWand *) * } */ - public static MethodHandle MagickSetImageCompose$handle() { - return MagickSetImageCompose.HANDLE; + public static MethodHandle MagickStripImage$handle() { + return MagickStripImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageCompose(MagickWand *, const CompositeOperator) + * extern MagickBooleanType MagickStripImage(MagickWand *) * } */ - public static MemorySegment MagickSetImageCompose$address() { - return MagickSetImageCompose.ADDR; + public static MemorySegment MagickStripImage$address() { + return MagickStripImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageCompose(MagickWand *, const CompositeOperator) + * extern MagickBooleanType MagickStripImage(MagickWand *) * } */ - public static int MagickSetImageCompose(MemorySegment x0, int x1) { - var mh$ = MagickSetImageCompose.HANDLE; + public static int MagickStripImage(MemorySegment x0) { + var mh$ = MagickStripImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageCompose", x0, x1); + traceDowncall("MagickStripImage", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageCompression { + private static class MagickSwirlImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageCompression"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSwirlImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15273,58 +29795,59 @@ private static class MagickSetImageCompression { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageCompression(MagickWand *, const CompressionType) + * extern MagickBooleanType MagickSwirlImage(MagickWand *, const double, const PixelInterpolateMethod) * } */ - public static FunctionDescriptor MagickSetImageCompression$descriptor() { - return MagickSetImageCompression.DESC; + public static FunctionDescriptor MagickSwirlImage$descriptor() { + return MagickSwirlImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageCompression(MagickWand *, const CompressionType) + * extern MagickBooleanType MagickSwirlImage(MagickWand *, const double, const PixelInterpolateMethod) * } */ - public static MethodHandle MagickSetImageCompression$handle() { - return MagickSetImageCompression.HANDLE; + public static MethodHandle MagickSwirlImage$handle() { + return MagickSwirlImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageCompression(MagickWand *, const CompressionType) + * extern MagickBooleanType MagickSwirlImage(MagickWand *, const double, const PixelInterpolateMethod) * } */ - public static MemorySegment MagickSetImageCompression$address() { - return MagickSetImageCompression.ADDR; + public static MemorySegment MagickSwirlImage$address() { + return MagickSwirlImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageCompression(MagickWand *, const CompressionType) + * extern MagickBooleanType MagickSwirlImage(MagickWand *, const double, const PixelInterpolateMethod) * } */ - public static int MagickSetImageCompression(MemorySegment x0, int x1) { - var mh$ = MagickSetImageCompression.HANDLE; + public static int MagickSwirlImage(MemorySegment x0, double x1, int x2) { + var mh$ = MagickSwirlImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageCompression", x0, x1); + traceDowncall("MagickSwirlImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageDelay { + private static class MagickTintImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageDelay"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickTintImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15332,58 +29855,58 @@ private static class MagickSetImageDelay { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageDelay(MagickWand *, const size_t) + * extern MagickBooleanType MagickTintImage(MagickWand *, const PixelWand *, const PixelWand *) * } */ - public static FunctionDescriptor MagickSetImageDelay$descriptor() { - return MagickSetImageDelay.DESC; + public static FunctionDescriptor MagickTintImage$descriptor() { + return MagickTintImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageDelay(MagickWand *, const size_t) + * extern MagickBooleanType MagickTintImage(MagickWand *, const PixelWand *, const PixelWand *) * } */ - public static MethodHandle MagickSetImageDelay$handle() { - return MagickSetImageDelay.HANDLE; + public static MethodHandle MagickTintImage$handle() { + return MagickTintImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageDelay(MagickWand *, const size_t) + * extern MagickBooleanType MagickTintImage(MagickWand *, const PixelWand *, const PixelWand *) * } */ - public static MemorySegment MagickSetImageDelay$address() { - return MagickSetImageDelay.ADDR; + public static MemorySegment MagickTintImage$address() { + return MagickTintImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageDelay(MagickWand *, const size_t) + * extern MagickBooleanType MagickTintImage(MagickWand *, const PixelWand *, const PixelWand *) * } */ - public static int MagickSetImageDelay(MemorySegment x0, long x1) { - var mh$ = MagickSetImageDelay.HANDLE; + public static int MagickTintImage(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickTintImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageDelay", x0, x1); + traceDowncall("MagickTintImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageDepth { + private static class MagickTransformImageColorspace { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageDepth"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickTransformImageColorspace"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15391,43 +29914,43 @@ private static class MagickSetImageDepth { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageDepth(MagickWand *, const size_t) + * extern MagickBooleanType MagickTransformImageColorspace(MagickWand *, const ColorspaceType) * } */ - public static FunctionDescriptor MagickSetImageDepth$descriptor() { - return MagickSetImageDepth.DESC; + public static FunctionDescriptor MagickTransformImageColorspace$descriptor() { + return MagickTransformImageColorspace.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageDepth(MagickWand *, const size_t) + * extern MagickBooleanType MagickTransformImageColorspace(MagickWand *, const ColorspaceType) * } */ - public static MethodHandle MagickSetImageDepth$handle() { - return MagickSetImageDepth.HANDLE; + public static MethodHandle MagickTransformImageColorspace$handle() { + return MagickTransformImageColorspace.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageDepth(MagickWand *, const size_t) + * extern MagickBooleanType MagickTransformImageColorspace(MagickWand *, const ColorspaceType) * } */ - public static MemorySegment MagickSetImageDepth$address() { - return MagickSetImageDepth.ADDR; + public static MemorySegment MagickTransformImageColorspace$address() { + return MagickTransformImageColorspace.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageDepth(MagickWand *, const size_t) + * extern MagickBooleanType MagickTransformImageColorspace(MagickWand *, const ColorspaceType) * } */ - public static int MagickSetImageDepth(MemorySegment x0, long x1) { - var mh$ = MagickSetImageDepth.HANDLE; + public static int MagickTransformImageColorspace(MemorySegment x0, int x1) { + var mh$ = MagickTransformImageColorspace.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageDepth", x0, x1); + traceDowncall("MagickTransformImageColorspace", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -15435,14 +29958,13 @@ public static int MagickSetImageDepth(MemorySegment x0, long x1) { } } - private static class MagickSetImageDispose { + private static class MagickTransposeImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageDispose"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickTransposeImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15450,58 +29972,57 @@ private static class MagickSetImageDispose { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageDispose(MagickWand *, const DisposeType) + * extern MagickBooleanType MagickTransposeImage(MagickWand *) * } */ - public static FunctionDescriptor MagickSetImageDispose$descriptor() { - return MagickSetImageDispose.DESC; + public static FunctionDescriptor MagickTransposeImage$descriptor() { + return MagickTransposeImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageDispose(MagickWand *, const DisposeType) + * extern MagickBooleanType MagickTransposeImage(MagickWand *) * } */ - public static MethodHandle MagickSetImageDispose$handle() { - return MagickSetImageDispose.HANDLE; + public static MethodHandle MagickTransposeImage$handle() { + return MagickTransposeImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageDispose(MagickWand *, const DisposeType) + * extern MagickBooleanType MagickTransposeImage(MagickWand *) * } */ - public static MemorySegment MagickSetImageDispose$address() { - return MagickSetImageDispose.ADDR; + public static MemorySegment MagickTransposeImage$address() { + return MagickTransposeImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageDispose(MagickWand *, const DisposeType) + * extern MagickBooleanType MagickTransposeImage(MagickWand *) * } */ - public static int MagickSetImageDispose(MemorySegment x0, int x1) { - var mh$ = MagickSetImageDispose.HANDLE; + public static int MagickTransposeImage(MemorySegment x0) { + var mh$ = MagickTransposeImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageDispose", x0, x1); + traceDowncall("MagickTransposeImage", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageCompressionQuality { + private static class MagickTransverseImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageCompressionQuality"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickTransverseImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15509,58 +30030,58 @@ private static class MagickSetImageCompressionQuality { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageCompressionQuality(MagickWand *, const size_t) + * extern MagickBooleanType MagickTransverseImage(MagickWand *) * } */ - public static FunctionDescriptor MagickSetImageCompressionQuality$descriptor() { - return MagickSetImageCompressionQuality.DESC; + public static FunctionDescriptor MagickTransverseImage$descriptor() { + return MagickTransverseImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageCompressionQuality(MagickWand *, const size_t) + * extern MagickBooleanType MagickTransverseImage(MagickWand *) * } */ - public static MethodHandle MagickSetImageCompressionQuality$handle() { - return MagickSetImageCompressionQuality.HANDLE; + public static MethodHandle MagickTransverseImage$handle() { + return MagickTransverseImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageCompressionQuality(MagickWand *, const size_t) + * extern MagickBooleanType MagickTransverseImage(MagickWand *) * } */ - public static MemorySegment MagickSetImageCompressionQuality$address() { - return MagickSetImageCompressionQuality.ADDR; + public static MemorySegment MagickTransverseImage$address() { + return MagickTransverseImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageCompressionQuality(MagickWand *, const size_t) + * extern MagickBooleanType MagickTransverseImage(MagickWand *) * } */ - public static int MagickSetImageCompressionQuality(MemorySegment x0, long x1) { - var mh$ = MagickSetImageCompressionQuality.HANDLE; + public static int MagickTransverseImage(MemorySegment x0) { + var mh$ = MagickTransverseImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageCompressionQuality", x0, x1); + traceDowncall("MagickTransverseImage", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageEndian { + private static class MagickThresholdImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageEndian"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickThresholdImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15568,43 +30089,43 @@ private static class MagickSetImageEndian { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageEndian(MagickWand *, const EndianType) + * extern MagickBooleanType MagickThresholdImage(MagickWand *, const double) * } */ - public static FunctionDescriptor MagickSetImageEndian$descriptor() { - return MagickSetImageEndian.DESC; + public static FunctionDescriptor MagickThresholdImage$descriptor() { + return MagickThresholdImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageEndian(MagickWand *, const EndianType) + * extern MagickBooleanType MagickThresholdImage(MagickWand *, const double) * } */ - public static MethodHandle MagickSetImageEndian$handle() { - return MagickSetImageEndian.HANDLE; + public static MethodHandle MagickThresholdImage$handle() { + return MagickThresholdImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageEndian(MagickWand *, const EndianType) + * extern MagickBooleanType MagickThresholdImage(MagickWand *, const double) * } */ - public static MemorySegment MagickSetImageEndian$address() { - return MagickSetImageEndian.ADDR; + public static MemorySegment MagickThresholdImage$address() { + return MagickThresholdImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageEndian(MagickWand *, const EndianType) + * extern MagickBooleanType MagickThresholdImage(MagickWand *, const double) * } */ - public static int MagickSetImageEndian(MemorySegment x0, int x1) { - var mh$ = MagickSetImageEndian.HANDLE; + public static int MagickThresholdImage(MemorySegment x0, double x1) { + var mh$ = MagickThresholdImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageEndian", x0, x1); + traceDowncall("MagickThresholdImage", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -15612,15 +30133,15 @@ public static int MagickSetImageEndian(MemorySegment x0, int x1) { } } - private static class MagickSetImageExtent { + private static class MagickThresholdImageChannel { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_INT, + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageExtent"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickThresholdImageChannel"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15628,43 +30149,43 @@ private static class MagickSetImageExtent { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageExtent(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickThresholdImageChannel(MagickWand *, const ChannelType, const double) * } */ - public static FunctionDescriptor MagickSetImageExtent$descriptor() { - return MagickSetImageExtent.DESC; + public static FunctionDescriptor MagickThresholdImageChannel$descriptor() { + return MagickThresholdImageChannel.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageExtent(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickThresholdImageChannel(MagickWand *, const ChannelType, const double) * } */ - public static MethodHandle MagickSetImageExtent$handle() { - return MagickSetImageExtent.HANDLE; + public static MethodHandle MagickThresholdImageChannel$handle() { + return MagickThresholdImageChannel.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageExtent(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickThresholdImageChannel(MagickWand *, const ChannelType, const double) * } */ - public static MemorySegment MagickSetImageExtent$address() { - return MagickSetImageExtent.ADDR; + public static MemorySegment MagickThresholdImageChannel$address() { + return MagickThresholdImageChannel.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageExtent(MagickWand *, const size_t, const size_t) + * extern MagickBooleanType MagickThresholdImageChannel(MagickWand *, const ChannelType, const double) * } */ - public static int MagickSetImageExtent(MemorySegment x0, long x1, long x2) { - var mh$ = MagickSetImageExtent.HANDLE; + public static int MagickThresholdImageChannel(MemorySegment x0, int x1, double x2) { + var mh$ = MagickThresholdImageChannel.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageExtent", x0, x1, x2); + traceDowncall("MagickThresholdImageChannel", x0, x1, x2); } return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { @@ -15672,14 +30193,15 @@ public static int MagickSetImageExtent(MemorySegment x0, long x1, long x2) { } } - private static class MagickSetImageFilename { + private static class MagickThumbnailImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageFilename"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickThumbnailImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15687,58 +30209,58 @@ private static class MagickSetImageFilename { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFilename(MagickWand *, const char *) + * extern MagickBooleanType MagickThumbnailImage(MagickWand *, const size_t, const size_t) * } */ - public static FunctionDescriptor MagickSetImageFilename$descriptor() { - return MagickSetImageFilename.DESC; + public static FunctionDescriptor MagickThumbnailImage$descriptor() { + return MagickThumbnailImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFilename(MagickWand *, const char *) + * extern MagickBooleanType MagickThumbnailImage(MagickWand *, const size_t, const size_t) * } */ - public static MethodHandle MagickSetImageFilename$handle() { - return MagickSetImageFilename.HANDLE; + public static MethodHandle MagickThumbnailImage$handle() { + return MagickThumbnailImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFilename(MagickWand *, const char *) + * extern MagickBooleanType MagickThumbnailImage(MagickWand *, const size_t, const size_t) * } */ - public static MemorySegment MagickSetImageFilename$address() { - return MagickSetImageFilename.ADDR; + public static MemorySegment MagickThumbnailImage$address() { + return MagickThumbnailImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFilename(MagickWand *, const char *) + * extern MagickBooleanType MagickThumbnailImage(MagickWand *, const size_t, const size_t) * } */ - public static int MagickSetImageFilename(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickSetImageFilename.HANDLE; + public static int MagickThumbnailImage(MemorySegment x0, long x1, long x2) { + var mh$ = MagickThumbnailImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageFilename", x0, x1); + traceDowncall("MagickThumbnailImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageFilter { + private static class MagickTrimImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageFilter"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickTrimImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15746,43 +30268,43 @@ private static class MagickSetImageFilter { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFilter(MagickWand *, const FilterType) + * extern MagickBooleanType MagickTrimImage(MagickWand *, const double) * } */ - public static FunctionDescriptor MagickSetImageFilter$descriptor() { - return MagickSetImageFilter.DESC; + public static FunctionDescriptor MagickTrimImage$descriptor() { + return MagickTrimImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFilter(MagickWand *, const FilterType) + * extern MagickBooleanType MagickTrimImage(MagickWand *, const double) * } */ - public static MethodHandle MagickSetImageFilter$handle() { - return MagickSetImageFilter.HANDLE; + public static MethodHandle MagickTrimImage$handle() { + return MagickTrimImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFilter(MagickWand *, const FilterType) + * extern MagickBooleanType MagickTrimImage(MagickWand *, const double) * } */ - public static MemorySegment MagickSetImageFilter$address() { - return MagickSetImageFilter.ADDR; + public static MemorySegment MagickTrimImage$address() { + return MagickTrimImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFilter(MagickWand *, const FilterType) + * extern MagickBooleanType MagickTrimImage(MagickWand *, const double) * } */ - public static int MagickSetImageFilter(MemorySegment x0, int x1) { - var mh$ = MagickSetImageFilter.HANDLE; + public static int MagickTrimImage(MemorySegment x0, double x1) { + var mh$ = MagickTrimImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageFilter", x0, x1); + traceDowncall("MagickTrimImage", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -15790,14 +30312,13 @@ public static int MagickSetImageFilter(MemorySegment x0, int x1) { } } - private static class MagickSetImageFormat { + private static class MagickUniqueImageColors { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageFormat"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickUniqueImageColors"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15805,58 +30326,61 @@ private static class MagickSetImageFormat { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFormat(MagickWand *, const char *) + * extern MagickBooleanType MagickUniqueImageColors(MagickWand *) * } */ - public static FunctionDescriptor MagickSetImageFormat$descriptor() { - return MagickSetImageFormat.DESC; + public static FunctionDescriptor MagickUniqueImageColors$descriptor() { + return MagickUniqueImageColors.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFormat(MagickWand *, const char *) + * extern MagickBooleanType MagickUniqueImageColors(MagickWand *) * } */ - public static MethodHandle MagickSetImageFormat$handle() { - return MagickSetImageFormat.HANDLE; + public static MethodHandle MagickUniqueImageColors$handle() { + return MagickUniqueImageColors.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFormat(MagickWand *, const char *) + * extern MagickBooleanType MagickUniqueImageColors(MagickWand *) * } */ - public static MemorySegment MagickSetImageFormat$address() { - return MagickSetImageFormat.ADDR; + public static MemorySegment MagickUniqueImageColors$address() { + return MagickUniqueImageColors.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFormat(MagickWand *, const char *) + * extern MagickBooleanType MagickUniqueImageColors(MagickWand *) * } */ - public static int MagickSetImageFormat(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickSetImageFormat.HANDLE; + public static int MagickUniqueImageColors(MemorySegment x0) { + var mh$ = MagickUniqueImageColors.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageFormat", x0, x1); + traceDowncall("MagickUniqueImageColors", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageFuzz { + private static class MagickUnsharpMaskImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageFuzz"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickUnsharpMaskImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15864,58 +30388,61 @@ private static class MagickSetImageFuzz { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFuzz(MagickWand *, const double) + * extern MagickBooleanType MagickUnsharpMaskImage(MagickWand *, const double, const double, const double, const double) * } */ - public static FunctionDescriptor MagickSetImageFuzz$descriptor() { - return MagickSetImageFuzz.DESC; + public static FunctionDescriptor MagickUnsharpMaskImage$descriptor() { + return MagickUnsharpMaskImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFuzz(MagickWand *, const double) + * extern MagickBooleanType MagickUnsharpMaskImage(MagickWand *, const double, const double, const double, const double) * } */ - public static MethodHandle MagickSetImageFuzz$handle() { - return MagickSetImageFuzz.HANDLE; + public static MethodHandle MagickUnsharpMaskImage$handle() { + return MagickUnsharpMaskImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFuzz(MagickWand *, const double) + * extern MagickBooleanType MagickUnsharpMaskImage(MagickWand *, const double, const double, const double, const double) * } */ - public static MemorySegment MagickSetImageFuzz$address() { - return MagickSetImageFuzz.ADDR; + public static MemorySegment MagickUnsharpMaskImage$address() { + return MagickUnsharpMaskImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageFuzz(MagickWand *, const double) + * extern MagickBooleanType MagickUnsharpMaskImage(MagickWand *, const double, const double, const double, const double) * } */ - public static int MagickSetImageFuzz(MemorySegment x0, double x1) { - var mh$ = MagickSetImageFuzz.HANDLE; + public static int MagickUnsharpMaskImage(MemorySegment x0, double x1, double x2, double x3, double x4) { + var mh$ = MagickUnsharpMaskImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageFuzz", x0, x1); + traceDowncall("MagickUnsharpMaskImage", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageGamma { + private static class MagickVignetteImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageGamma"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickVignetteImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15923,58 +30450,60 @@ private static class MagickSetImageGamma { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageGamma(MagickWand *, const double) + * extern MagickBooleanType MagickVignetteImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) * } */ - public static FunctionDescriptor MagickSetImageGamma$descriptor() { - return MagickSetImageGamma.DESC; + public static FunctionDescriptor MagickVignetteImage$descriptor() { + return MagickVignetteImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageGamma(MagickWand *, const double) + * extern MagickBooleanType MagickVignetteImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) * } */ - public static MethodHandle MagickSetImageGamma$handle() { - return MagickSetImageGamma.HANDLE; + public static MethodHandle MagickVignetteImage$handle() { + return MagickVignetteImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageGamma(MagickWand *, const double) + * extern MagickBooleanType MagickVignetteImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) * } */ - public static MemorySegment MagickSetImageGamma$address() { - return MagickSetImageGamma.ADDR; + public static MemorySegment MagickVignetteImage$address() { + return MagickVignetteImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageGamma(MagickWand *, const double) + * extern MagickBooleanType MagickVignetteImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) * } */ - public static int MagickSetImageGamma(MemorySegment x0, double x1) { - var mh$ = MagickSetImageGamma.HANDLE; + public static int MagickVignetteImage(MemorySegment x0, double x1, double x2, long x3, long x4) { + var mh$ = MagickVignetteImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageGamma", x0, x1); + traceDowncall("MagickVignetteImage", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageGravity { + private static class MagickWaveImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_DOUBLE, MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageGravity"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWaveImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -15982,60 +30511,59 @@ private static class MagickSetImageGravity { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageGravity(MagickWand *, const GravityType) + * extern MagickBooleanType MagickWaveImage(MagickWand *, const double, const double, const PixelInterpolateMethod) * } */ - public static FunctionDescriptor MagickSetImageGravity$descriptor() { - return MagickSetImageGravity.DESC; + public static FunctionDescriptor MagickWaveImage$descriptor() { + return MagickWaveImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageGravity(MagickWand *, const GravityType) + * extern MagickBooleanType MagickWaveImage(MagickWand *, const double, const double, const PixelInterpolateMethod) * } */ - public static MethodHandle MagickSetImageGravity$handle() { - return MagickSetImageGravity.HANDLE; + public static MethodHandle MagickWaveImage$handle() { + return MagickWaveImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageGravity(MagickWand *, const GravityType) + * extern MagickBooleanType MagickWaveImage(MagickWand *, const double, const double, const PixelInterpolateMethod) * } */ - public static MemorySegment MagickSetImageGravity$address() { - return MagickSetImageGravity.ADDR; + public static MemorySegment MagickWaveImage$address() { + return MagickWaveImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageGravity(MagickWand *, const GravityType) + * extern MagickBooleanType MagickWaveImage(MagickWand *, const double, const double, const PixelInterpolateMethod) * } */ - public static int MagickSetImageGravity(MemorySegment x0, int x1) { - var mh$ = MagickSetImageGravity.HANDLE; + public static int MagickWaveImage(MemorySegment x0, double x1, double x2, int x3) { + var mh$ = MagickWaveImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageGravity", x0, x1); + traceDowncall("MagickWaveImage", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageGreenPrimary { + private static class MagickWaveletDenoiseImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, MagickWand_h.C_DOUBLE ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageGreenPrimary"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWaveletDenoiseImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16043,58 +30571,57 @@ private static class MagickSetImageGreenPrimary { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageGreenPrimary(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickWaveletDenoiseImage(MagickWand *, const double, const double) * } */ - public static FunctionDescriptor MagickSetImageGreenPrimary$descriptor() { - return MagickSetImageGreenPrimary.DESC; + public static FunctionDescriptor MagickWaveletDenoiseImage$descriptor() { + return MagickWaveletDenoiseImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageGreenPrimary(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickWaveletDenoiseImage(MagickWand *, const double, const double) * } */ - public static MethodHandle MagickSetImageGreenPrimary$handle() { - return MagickSetImageGreenPrimary.HANDLE; + public static MethodHandle MagickWaveletDenoiseImage$handle() { + return MagickWaveletDenoiseImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageGreenPrimary(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickWaveletDenoiseImage(MagickWand *, const double, const double) * } */ - public static MemorySegment MagickSetImageGreenPrimary$address() { - return MagickSetImageGreenPrimary.ADDR; + public static MemorySegment MagickWaveletDenoiseImage$address() { + return MagickWaveletDenoiseImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageGreenPrimary(MagickWand *, const double, const double, const double) + * extern MagickBooleanType MagickWaveletDenoiseImage(MagickWand *, const double, const double) * } */ - public static int MagickSetImageGreenPrimary(MemorySegment x0, double x1, double x2, double x3) { - var mh$ = MagickSetImageGreenPrimary.HANDLE; + public static int MagickWaveletDenoiseImage(MemorySegment x0, double x1, double x2) { + var mh$ = MagickWaveletDenoiseImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageGreenPrimary", x0, x1, x2, x3); + traceDowncall("MagickWaveletDenoiseImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageInterlaceScheme { + private static class MagickWhiteBalanceImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageInterlaceScheme"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWhiteBalanceImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16102,58 +30629,58 @@ private static class MagickSetImageInterlaceScheme { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageInterlaceScheme(MagickWand *, const InterlaceType) + * extern MagickBooleanType MagickWhiteBalanceImage(MagickWand *) * } */ - public static FunctionDescriptor MagickSetImageInterlaceScheme$descriptor() { - return MagickSetImageInterlaceScheme.DESC; + public static FunctionDescriptor MagickWhiteBalanceImage$descriptor() { + return MagickWhiteBalanceImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageInterlaceScheme(MagickWand *, const InterlaceType) + * extern MagickBooleanType MagickWhiteBalanceImage(MagickWand *) * } */ - public static MethodHandle MagickSetImageInterlaceScheme$handle() { - return MagickSetImageInterlaceScheme.HANDLE; + public static MethodHandle MagickWhiteBalanceImage$handle() { + return MagickWhiteBalanceImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageInterlaceScheme(MagickWand *, const InterlaceType) + * extern MagickBooleanType MagickWhiteBalanceImage(MagickWand *) * } */ - public static MemorySegment MagickSetImageInterlaceScheme$address() { - return MagickSetImageInterlaceScheme.ADDR; + public static MemorySegment MagickWhiteBalanceImage$address() { + return MagickWhiteBalanceImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageInterlaceScheme(MagickWand *, const InterlaceType) + * extern MagickBooleanType MagickWhiteBalanceImage(MagickWand *) * } */ - public static int MagickSetImageInterlaceScheme(MemorySegment x0, int x1) { - var mh$ = MagickSetImageInterlaceScheme.HANDLE; + public static int MagickWhiteBalanceImage(MemorySegment x0) { + var mh$ = MagickWhiteBalanceImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageInterlaceScheme", x0, x1); + traceDowncall("MagickWhiteBalanceImage", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageInterpolateMethod { + private static class MagickWhiteThresholdImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageInterpolateMethod"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWhiteThresholdImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16161,43 +30688,43 @@ private static class MagickSetImageInterpolateMethod { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageInterpolateMethod(MagickWand *, const PixelInterpolateMethod) + * extern MagickBooleanType MagickWhiteThresholdImage(MagickWand *, const PixelWand *) * } */ - public static FunctionDescriptor MagickSetImageInterpolateMethod$descriptor() { - return MagickSetImageInterpolateMethod.DESC; + public static FunctionDescriptor MagickWhiteThresholdImage$descriptor() { + return MagickWhiteThresholdImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageInterpolateMethod(MagickWand *, const PixelInterpolateMethod) + * extern MagickBooleanType MagickWhiteThresholdImage(MagickWand *, const PixelWand *) * } */ - public static MethodHandle MagickSetImageInterpolateMethod$handle() { - return MagickSetImageInterpolateMethod.HANDLE; + public static MethodHandle MagickWhiteThresholdImage$handle() { + return MagickWhiteThresholdImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageInterpolateMethod(MagickWand *, const PixelInterpolateMethod) + * extern MagickBooleanType MagickWhiteThresholdImage(MagickWand *, const PixelWand *) * } */ - public static MemorySegment MagickSetImageInterpolateMethod$address() { - return MagickSetImageInterpolateMethod.ADDR; + public static MemorySegment MagickWhiteThresholdImage$address() { + return MagickWhiteThresholdImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageInterpolateMethod(MagickWand *, const PixelInterpolateMethod) + * extern MagickBooleanType MagickWhiteThresholdImage(MagickWand *, const PixelWand *) * } */ - public static int MagickSetImageInterpolateMethod(MemorySegment x0, int x1) { - var mh$ = MagickSetImageInterpolateMethod.HANDLE; + public static int MagickWhiteThresholdImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickWhiteThresholdImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageInterpolateMethod", x0, x1); + traceDowncall("MagickWhiteThresholdImage", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -16205,14 +30732,14 @@ public static int MagickSetImageInterpolateMethod(MemorySegment x0, int x1) { } } - private static class MagickSetImageIterations { + private static class MagickWriteImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageIterations"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWriteImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16220,43 +30747,43 @@ private static class MagickSetImageIterations { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageIterations(MagickWand *, const size_t) + * extern MagickBooleanType MagickWriteImage(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickSetImageIterations$descriptor() { - return MagickSetImageIterations.DESC; + public static FunctionDescriptor MagickWriteImage$descriptor() { + return MagickWriteImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageIterations(MagickWand *, const size_t) + * extern MagickBooleanType MagickWriteImage(MagickWand *, const char *) * } */ - public static MethodHandle MagickSetImageIterations$handle() { - return MagickSetImageIterations.HANDLE; + public static MethodHandle MagickWriteImage$handle() { + return MagickWriteImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageIterations(MagickWand *, const size_t) + * extern MagickBooleanType MagickWriteImage(MagickWand *, const char *) * } */ - public static MemorySegment MagickSetImageIterations$address() { - return MagickSetImageIterations.ADDR; + public static MemorySegment MagickWriteImage$address() { + return MagickWriteImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageIterations(MagickWand *, const size_t) + * extern MagickBooleanType MagickWriteImage(MagickWand *, const char *) * } */ - public static int MagickSetImageIterations(MemorySegment x0, long x1) { - var mh$ = MagickSetImageIterations.HANDLE; + public static int MagickWriteImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickWriteImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageIterations", x0, x1); + traceDowncall("MagickWriteImage", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -16264,15 +30791,14 @@ public static int MagickSetImageIterations(MemorySegment x0, long x1) { } } - private static class MagickSetImageMask { + private static class MagickWriteImageFile { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageMask"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWriteImageFile"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16280,58 +30806,59 @@ private static class MagickSetImageMask { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageMask(MagickWand *, const PixelMask, const MagickWand *) + * extern MagickBooleanType MagickWriteImageFile(MagickWand *, FILE *) * } */ - public static FunctionDescriptor MagickSetImageMask$descriptor() { - return MagickSetImageMask.DESC; + public static FunctionDescriptor MagickWriteImageFile$descriptor() { + return MagickWriteImageFile.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageMask(MagickWand *, const PixelMask, const MagickWand *) + * extern MagickBooleanType MagickWriteImageFile(MagickWand *, FILE *) * } */ - public static MethodHandle MagickSetImageMask$handle() { - return MagickSetImageMask.HANDLE; + public static MethodHandle MagickWriteImageFile$handle() { + return MagickWriteImageFile.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageMask(MagickWand *, const PixelMask, const MagickWand *) + * extern MagickBooleanType MagickWriteImageFile(MagickWand *, FILE *) * } */ - public static MemorySegment MagickSetImageMask$address() { - return MagickSetImageMask.ADDR; + public static MemorySegment MagickWriteImageFile$address() { + return MagickWriteImageFile.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageMask(MagickWand *, const PixelMask, const MagickWand *) + * extern MagickBooleanType MagickWriteImageFile(MagickWand *, FILE *) * } */ - public static int MagickSetImageMask(MemorySegment x0, int x1, MemorySegment x2) { - var mh$ = MagickSetImageMask.HANDLE; + public static int MagickWriteImageFile(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickWriteImageFile.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageMask", x0, x1, x2); + traceDowncall("MagickWriteImageFile", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageMatte { + private static class MagickWriteImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageMatte"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWriteImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16339,58 +30866,58 @@ private static class MagickSetImageMatte { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageMatte(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickWriteImages(MagickWand *, const char *, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickSetImageMatte$descriptor() { - return MagickSetImageMatte.DESC; + public static FunctionDescriptor MagickWriteImages$descriptor() { + return MagickWriteImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageMatte(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickWriteImages(MagickWand *, const char *, const MagickBooleanType) * } */ - public static MethodHandle MagickSetImageMatte$handle() { - return MagickSetImageMatte.HANDLE; + public static MethodHandle MagickWriteImages$handle() { + return MagickWriteImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageMatte(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickWriteImages(MagickWand *, const char *, const MagickBooleanType) * } */ - public static MemorySegment MagickSetImageMatte$address() { - return MagickSetImageMatte.ADDR; + public static MemorySegment MagickWriteImages$address() { + return MagickWriteImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageMatte(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MagickWriteImages(MagickWand *, const char *, const MagickBooleanType) * } */ - public static int MagickSetImageMatte(MemorySegment x0, int x1) { - var mh$ = MagickSetImageMatte.HANDLE; + public static int MagickWriteImages(MemorySegment x0, MemorySegment x1, int x2) { + var mh$ = MagickWriteImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageMatte", x0, x1); + traceDowncall("MagickWriteImages", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageMatteColor { + private static class MagickWriteImagesFile { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageMatteColor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWriteImagesFile"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16398,43 +30925,43 @@ private static class MagickSetImageMatteColor { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageMatteColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickWriteImagesFile(MagickWand *, FILE *) * } */ - public static FunctionDescriptor MagickSetImageMatteColor$descriptor() { - return MagickSetImageMatteColor.DESC; + public static FunctionDescriptor MagickWriteImagesFile$descriptor() { + return MagickWriteImagesFile.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageMatteColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickWriteImagesFile(MagickWand *, FILE *) * } */ - public static MethodHandle MagickSetImageMatteColor$handle() { - return MagickSetImageMatteColor.HANDLE; + public static MethodHandle MagickWriteImagesFile$handle() { + return MagickWriteImagesFile.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageMatteColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickWriteImagesFile(MagickWand *, FILE *) * } */ - public static MemorySegment MagickSetImageMatteColor$address() { - return MagickSetImageMatteColor.ADDR; + public static MemorySegment MagickWriteImagesFile$address() { + return MagickWriteImagesFile.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageMatteColor(MagickWand *, const PixelWand *) + * extern MagickBooleanType MagickWriteImagesFile(MagickWand *, FILE *) * } */ - public static int MagickSetImageMatteColor(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickSetImageMatteColor.HANDLE; + public static int MagickWriteImagesFile(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickWriteImagesFile.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageMatteColor", x0, x1); + traceDowncall("MagickWriteImagesFile", x0, x1); } return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -16442,14 +30969,15 @@ public static int MagickSetImageMatteColor(MemorySegment x0, MemorySegment x1) { } } - private static class MagickSetImageOrientation { + private static class MagickSetImageProgressMonitor { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageOrientation"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageProgressMonitor"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16457,61 +30985,58 @@ private static class MagickSetImageOrientation { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageOrientation(MagickWand *, const OrientationType) + * extern MagickProgressMonitor MagickSetImageProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) * } */ - public static FunctionDescriptor MagickSetImageOrientation$descriptor() { - return MagickSetImageOrientation.DESC; + public static FunctionDescriptor MagickSetImageProgressMonitor$descriptor() { + return MagickSetImageProgressMonitor.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageOrientation(MagickWand *, const OrientationType) + * extern MagickProgressMonitor MagickSetImageProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) * } */ - public static MethodHandle MagickSetImageOrientation$handle() { - return MagickSetImageOrientation.HANDLE; + public static MethodHandle MagickSetImageProgressMonitor$handle() { + return MagickSetImageProgressMonitor.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageOrientation(MagickWand *, const OrientationType) + * extern MagickProgressMonitor MagickSetImageProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) * } */ - public static MemorySegment MagickSetImageOrientation$address() { - return MagickSetImageOrientation.ADDR; + public static MemorySegment MagickSetImageProgressMonitor$address() { + return MagickSetImageProgressMonitor.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageOrientation(MagickWand *, const OrientationType) + * extern MagickProgressMonitor MagickSetImageProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) * } */ - public static int MagickSetImageOrientation(MemorySegment x0, int x1) { - var mh$ = MagickSetImageOrientation.HANDLE; + public static MemorySegment MagickSetImageProgressMonitor(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = MagickSetImageProgressMonitor.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageOrientation", x0, x1); + traceDowncall("MagickSetImageProgressMonitor", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImagePage { + private static class MagickAppendImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImagePage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAppendImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16519,60 +31044,58 @@ private static class MagickSetImagePage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImagePage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickWand *MagickAppendImages(MagickWand *, const MagickBooleanType) * } */ - public static FunctionDescriptor MagickSetImagePage$descriptor() { - return MagickSetImagePage.DESC; + public static FunctionDescriptor MagickAppendImages$descriptor() { + return MagickAppendImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImagePage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickWand *MagickAppendImages(MagickWand *, const MagickBooleanType) * } */ - public static MethodHandle MagickSetImagePage$handle() { - return MagickSetImagePage.HANDLE; + public static MethodHandle MagickAppendImages$handle() { + return MagickAppendImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImagePage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickWand *MagickAppendImages(MagickWand *, const MagickBooleanType) * } */ - public static MemorySegment MagickSetImagePage$address() { - return MagickSetImagePage.ADDR; + public static MemorySegment MagickAppendImages$address() { + return MagickAppendImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImagePage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickWand *MagickAppendImages(MagickWand *, const MagickBooleanType) * } */ - public static int MagickSetImagePage(MemorySegment x0, long x1, long x2, long x3, long x4) { - var mh$ = MagickSetImagePage.HANDLE; + public static MemorySegment MagickAppendImages(MemorySegment x0, int x1) { + var mh$ = MagickAppendImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImagePage", x0, x1, x2, x3, x4); + traceDowncall("MagickAppendImages", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImagePixelColor { + private static class MagickChannelFxImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImagePixelColor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickChannelFxImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16580,60 +31103,57 @@ private static class MagickSetImagePixelColor { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, const PixelWand *) + * extern MagickWand *MagickChannelFxImage(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickSetImagePixelColor$descriptor() { - return MagickSetImagePixelColor.DESC; + public static FunctionDescriptor MagickChannelFxImage$descriptor() { + return MagickChannelFxImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, const PixelWand *) + * extern MagickWand *MagickChannelFxImage(MagickWand *, const char *) * } */ - public static MethodHandle MagickSetImagePixelColor$handle() { - return MagickSetImagePixelColor.HANDLE; + public static MethodHandle MagickChannelFxImage$handle() { + return MagickChannelFxImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, const PixelWand *) + * extern MagickWand *MagickChannelFxImage(MagickWand *, const char *) * } */ - public static MemorySegment MagickSetImagePixelColor$address() { - return MagickSetImagePixelColor.ADDR; + public static MemorySegment MagickChannelFxImage$address() { + return MagickChannelFxImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImagePixelColor(MagickWand *, const ssize_t, const ssize_t, const PixelWand *) + * extern MagickWand *MagickChannelFxImage(MagickWand *, const char *) * } */ - public static int MagickSetImagePixelColor(MemorySegment x0, long x1, long x2, MemorySegment x3) { - var mh$ = MagickSetImagePixelColor.HANDLE; + public static MemorySegment MagickChannelFxImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickChannelFxImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImagePixelColor", x0, x1, x2, x3); + traceDowncall("MagickChannelFxImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageRedPrimary { + private static class MagickCoalesceImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageRedPrimary"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCoalesceImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16641,58 +31161,58 @@ private static class MagickSetImageRedPrimary { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageRedPrimary(MagickWand *, const double, const double, const double) + * extern MagickWand *MagickCoalesceImages(MagickWand *) * } */ - public static FunctionDescriptor MagickSetImageRedPrimary$descriptor() { - return MagickSetImageRedPrimary.DESC; + public static FunctionDescriptor MagickCoalesceImages$descriptor() { + return MagickCoalesceImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageRedPrimary(MagickWand *, const double, const double, const double) + * extern MagickWand *MagickCoalesceImages(MagickWand *) * } */ - public static MethodHandle MagickSetImageRedPrimary$handle() { - return MagickSetImageRedPrimary.HANDLE; + public static MethodHandle MagickCoalesceImages$handle() { + return MagickCoalesceImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageRedPrimary(MagickWand *, const double, const double, const double) + * extern MagickWand *MagickCoalesceImages(MagickWand *) * } */ - public static MemorySegment MagickSetImageRedPrimary$address() { - return MagickSetImageRedPrimary.ADDR; + public static MemorySegment MagickCoalesceImages$address() { + return MagickCoalesceImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageRedPrimary(MagickWand *, const double, const double, const double) + * extern MagickWand *MagickCoalesceImages(MagickWand *) * } */ - public static int MagickSetImageRedPrimary(MemorySegment x0, double x1, double x2, double x3) { - var mh$ = MagickSetImageRedPrimary.HANDLE; + public static MemorySegment MagickCoalesceImages(MemorySegment x0) { + var mh$ = MagickCoalesceImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageRedPrimary", x0, x1, x2, x3); + traceDowncall("MagickCoalesceImages", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageRenderingIntent { + private static class MagickCombineImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageRenderingIntent"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCombineImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16700,59 +31220,60 @@ private static class MagickSetImageRenderingIntent { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageRenderingIntent(MagickWand *, const RenderingIntent) + * extern MagickWand *MagickCombineImages(MagickWand *, const ColorspaceType) * } */ - public static FunctionDescriptor MagickSetImageRenderingIntent$descriptor() { - return MagickSetImageRenderingIntent.DESC; + public static FunctionDescriptor MagickCombineImages$descriptor() { + return MagickCombineImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageRenderingIntent(MagickWand *, const RenderingIntent) + * extern MagickWand *MagickCombineImages(MagickWand *, const ColorspaceType) * } */ - public static MethodHandle MagickSetImageRenderingIntent$handle() { - return MagickSetImageRenderingIntent.HANDLE; + public static MethodHandle MagickCombineImages$handle() { + return MagickCombineImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageRenderingIntent(MagickWand *, const RenderingIntent) + * extern MagickWand *MagickCombineImages(MagickWand *, const ColorspaceType) * } */ - public static MemorySegment MagickSetImageRenderingIntent$address() { - return MagickSetImageRenderingIntent.ADDR; + public static MemorySegment MagickCombineImages$address() { + return MagickCombineImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageRenderingIntent(MagickWand *, const RenderingIntent) + * extern MagickWand *MagickCombineImages(MagickWand *, const ColorspaceType) * } */ - public static int MagickSetImageRenderingIntent(MemorySegment x0, int x1) { - var mh$ = MagickSetImageRenderingIntent.HANDLE; + public static MemorySegment MagickCombineImages(MemorySegment x0, int x1) { + var mh$ = MagickCombineImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageRenderingIntent", x0, x1); + traceDowncall("MagickCombineImages", x0, x1); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageResolution { + private static class MagickCompareImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageResolution"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCompareImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16760,58 +31281,58 @@ private static class MagickSetImageResolution { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageResolution(MagickWand *, const double, const double) + * extern MagickWand *MagickCompareImages(MagickWand *, const MagickWand *, const MetricType, double *) * } */ - public static FunctionDescriptor MagickSetImageResolution$descriptor() { - return MagickSetImageResolution.DESC; + public static FunctionDescriptor MagickCompareImages$descriptor() { + return MagickCompareImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageResolution(MagickWand *, const double, const double) + * extern MagickWand *MagickCompareImages(MagickWand *, const MagickWand *, const MetricType, double *) * } */ - public static MethodHandle MagickSetImageResolution$handle() { - return MagickSetImageResolution.HANDLE; + public static MethodHandle MagickCompareImages$handle() { + return MagickCompareImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageResolution(MagickWand *, const double, const double) + * extern MagickWand *MagickCompareImages(MagickWand *, const MagickWand *, const MetricType, double *) * } */ - public static MemorySegment MagickSetImageResolution$address() { - return MagickSetImageResolution.ADDR; + public static MemorySegment MagickCompareImages$address() { + return MagickCompareImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageResolution(MagickWand *, const double, const double) + * extern MagickWand *MagickCompareImages(MagickWand *, const MagickWand *, const MetricType, double *) * } */ - public static int MagickSetImageResolution(MemorySegment x0, double x1, double x2) { - var mh$ = MagickSetImageResolution.HANDLE; + public static MemorySegment MagickCompareImages(MemorySegment x0, MemorySegment x1, int x2, MemorySegment x3) { + var mh$ = MagickCompareImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageResolution", x0, x1, x2); + traceDowncall("MagickCompareImages", x0, x1, x2, x3); } - return (int)mh$.invokeExact(x0, x1, x2); + return (MemorySegment)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageScene { + private static class MagickCompareImagesLayers { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageScene"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCompareImagesLayers"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16819,58 +31340,58 @@ private static class MagickSetImageScene { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageScene(MagickWand *, const size_t) + * extern MagickWand *MagickCompareImagesLayers(MagickWand *, const LayerMethod) * } */ - public static FunctionDescriptor MagickSetImageScene$descriptor() { - return MagickSetImageScene.DESC; + public static FunctionDescriptor MagickCompareImagesLayers$descriptor() { + return MagickCompareImagesLayers.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageScene(MagickWand *, const size_t) + * extern MagickWand *MagickCompareImagesLayers(MagickWand *, const LayerMethod) * } */ - public static MethodHandle MagickSetImageScene$handle() { - return MagickSetImageScene.HANDLE; + public static MethodHandle MagickCompareImagesLayers$handle() { + return MagickCompareImagesLayers.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageScene(MagickWand *, const size_t) + * extern MagickWand *MagickCompareImagesLayers(MagickWand *, const LayerMethod) * } */ - public static MemorySegment MagickSetImageScene$address() { - return MagickSetImageScene.ADDR; + public static MemorySegment MagickCompareImagesLayers$address() { + return MagickCompareImagesLayers.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageScene(MagickWand *, const size_t) + * extern MagickWand *MagickCompareImagesLayers(MagickWand *, const LayerMethod) * } */ - public static int MagickSetImageScene(MemorySegment x0, long x1) { - var mh$ = MagickSetImageScene.HANDLE; + public static MemorySegment MagickCompareImagesLayers(MemorySegment x0, int x1) { + var mh$ = MagickCompareImagesLayers.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageScene", x0, x1); + traceDowncall("MagickCompareImagesLayers", x0, x1); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageTicksPerSecond { + private static class MagickComplexImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageTicksPerSecond"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickComplexImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16878,58 +31399,57 @@ private static class MagickSetImageTicksPerSecond { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageTicksPerSecond(MagickWand *, const ssize_t) + * extern MagickWand *MagickComplexImages(MagickWand *, const ComplexOperator) * } */ - public static FunctionDescriptor MagickSetImageTicksPerSecond$descriptor() { - return MagickSetImageTicksPerSecond.DESC; + public static FunctionDescriptor MagickComplexImages$descriptor() { + return MagickComplexImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageTicksPerSecond(MagickWand *, const ssize_t) + * extern MagickWand *MagickComplexImages(MagickWand *, const ComplexOperator) * } */ - public static MethodHandle MagickSetImageTicksPerSecond$handle() { - return MagickSetImageTicksPerSecond.HANDLE; + public static MethodHandle MagickComplexImages$handle() { + return MagickComplexImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageTicksPerSecond(MagickWand *, const ssize_t) + * extern MagickWand *MagickComplexImages(MagickWand *, const ComplexOperator) * } */ - public static MemorySegment MagickSetImageTicksPerSecond$address() { - return MagickSetImageTicksPerSecond.ADDR; + public static MemorySegment MagickComplexImages$address() { + return MagickComplexImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageTicksPerSecond(MagickWand *, const ssize_t) + * extern MagickWand *MagickComplexImages(MagickWand *, const ComplexOperator) * } */ - public static int MagickSetImageTicksPerSecond(MemorySegment x0, long x1) { - var mh$ = MagickSetImageTicksPerSecond.HANDLE; + public static MemorySegment MagickComplexImages(MemorySegment x0, int x1) { + var mh$ = MagickComplexImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageTicksPerSecond", x0, x1); + traceDowncall("MagickComplexImages", x0, x1); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageType { + private static class MagickDeconstructImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageType"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDeconstructImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16937,58 +31457,58 @@ private static class MagickSetImageType { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageType(MagickWand *, const ImageType) + * extern MagickWand *MagickDeconstructImages(MagickWand *) * } */ - public static FunctionDescriptor MagickSetImageType$descriptor() { - return MagickSetImageType.DESC; + public static FunctionDescriptor MagickDeconstructImages$descriptor() { + return MagickDeconstructImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageType(MagickWand *, const ImageType) + * extern MagickWand *MagickDeconstructImages(MagickWand *) * } */ - public static MethodHandle MagickSetImageType$handle() { - return MagickSetImageType.HANDLE; + public static MethodHandle MagickDeconstructImages$handle() { + return MagickDeconstructImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageType(MagickWand *, const ImageType) + * extern MagickWand *MagickDeconstructImages(MagickWand *) * } */ - public static MemorySegment MagickSetImageType$address() { - return MagickSetImageType.ADDR; + public static MemorySegment MagickDeconstructImages$address() { + return MagickDeconstructImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageType(MagickWand *, const ImageType) + * extern MagickWand *MagickDeconstructImages(MagickWand *) * } */ - public static int MagickSetImageType(MemorySegment x0, int x1) { - var mh$ = MagickSetImageType.HANDLE; + public static MemorySegment MagickDeconstructImages(MemorySegment x0) { + var mh$ = MagickDeconstructImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageType", x0, x1); + traceDowncall("MagickDeconstructImages", x0); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageUnits { + private static class MagickEvaluateImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageUnits"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickEvaluateImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -16996,60 +31516,58 @@ private static class MagickSetImageUnits { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageUnits(MagickWand *, const ResolutionType) + * extern MagickWand *MagickEvaluateImages(MagickWand *, const MagickEvaluateOperator) * } */ - public static FunctionDescriptor MagickSetImageUnits$descriptor() { - return MagickSetImageUnits.DESC; + public static FunctionDescriptor MagickEvaluateImages$descriptor() { + return MagickEvaluateImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageUnits(MagickWand *, const ResolutionType) + * extern MagickWand *MagickEvaluateImages(MagickWand *, const MagickEvaluateOperator) * } */ - public static MethodHandle MagickSetImageUnits$handle() { - return MagickSetImageUnits.HANDLE; + public static MethodHandle MagickEvaluateImages$handle() { + return MagickEvaluateImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageUnits(MagickWand *, const ResolutionType) + * extern MagickWand *MagickEvaluateImages(MagickWand *, const MagickEvaluateOperator) * } */ - public static MemorySegment MagickSetImageUnits$address() { - return MagickSetImageUnits.ADDR; + public static MemorySegment MagickEvaluateImages$address() { + return MagickEvaluateImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageUnits(MagickWand *, const ResolutionType) + * extern MagickWand *MagickEvaluateImages(MagickWand *, const MagickEvaluateOperator) * } */ - public static int MagickSetImageUnits(MemorySegment x0, int x1) { - var mh$ = MagickSetImageUnits.HANDLE; + public static MemorySegment MagickEvaluateImages(MemorySegment x0, int x1) { + var mh$ = MagickEvaluateImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageUnits", x0, x1); + traceDowncall("MagickEvaluateImages", x0, x1); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageWhitePoint { + private static class MagickFxImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageWhitePoint"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickFxImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17057,60 +31575,57 @@ private static class MagickSetImageWhitePoint { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageWhitePoint(MagickWand *, const double, const double, const double) + * extern MagickWand *MagickFxImage(MagickWand *, const char *) * } */ - public static FunctionDescriptor MagickSetImageWhitePoint$descriptor() { - return MagickSetImageWhitePoint.DESC; + public static FunctionDescriptor MagickFxImage$descriptor() { + return MagickFxImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageWhitePoint(MagickWand *, const double, const double, const double) + * extern MagickWand *MagickFxImage(MagickWand *, const char *) * } */ - public static MethodHandle MagickSetImageWhitePoint$handle() { - return MagickSetImageWhitePoint.HANDLE; + public static MethodHandle MagickFxImage$handle() { + return MagickFxImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageWhitePoint(MagickWand *, const double, const double, const double) + * extern MagickWand *MagickFxImage(MagickWand *, const char *) * } */ - public static MemorySegment MagickSetImageWhitePoint$address() { - return MagickSetImageWhitePoint.ADDR; + public static MemorySegment MagickFxImage$address() { + return MagickFxImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSetImageWhitePoint(MagickWand *, const double, const double, const double) + * extern MagickWand *MagickFxImage(MagickWand *, const char *) * } */ - public static int MagickSetImageWhitePoint(MemorySegment x0, double x1, double x2, double x3) { - var mh$ = MagickSetImageWhitePoint.HANDLE; + public static MemorySegment MagickFxImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickFxImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageWhitePoint", x0, x1, x2, x3); + traceDowncall("MagickFxImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickShadeImage { + private static class MagickGetImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickShadeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17118,61 +31633,58 @@ private static class MagickShadeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickShadeImage(MagickWand *, const MagickBooleanType, const double, const double) + * extern MagickWand *MagickGetImage(MagickWand *) * } */ - public static FunctionDescriptor MagickShadeImage$descriptor() { - return MagickShadeImage.DESC; + public static FunctionDescriptor MagickGetImage$descriptor() { + return MagickGetImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickShadeImage(MagickWand *, const MagickBooleanType, const double, const double) + * extern MagickWand *MagickGetImage(MagickWand *) * } */ - public static MethodHandle MagickShadeImage$handle() { - return MagickShadeImage.HANDLE; + public static MethodHandle MagickGetImage$handle() { + return MagickGetImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickShadeImage(MagickWand *, const MagickBooleanType, const double, const double) + * extern MagickWand *MagickGetImage(MagickWand *) * } */ - public static MemorySegment MagickShadeImage$address() { - return MagickShadeImage.ADDR; + public static MemorySegment MagickGetImage$address() { + return MagickGetImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickShadeImage(MagickWand *, const MagickBooleanType, const double, const double) + * extern MagickWand *MagickGetImage(MagickWand *) * } */ - public static int MagickShadeImage(MemorySegment x0, int x1, double x2, double x3) { - var mh$ = MagickShadeImage.HANDLE; + public static MemorySegment MagickGetImage(MemorySegment x0) { + var mh$ = MagickGetImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickShadeImage", x0, x1, x2, x3); + traceDowncall("MagickGetImage", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickShadowImage { + private static class MagickGetImageMask { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickShadowImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageMask"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17180,59 +31692,61 @@ private static class MagickShadowImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickShadowImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) + * extern MagickWand *MagickGetImageMask(MagickWand *, const PixelMask) * } */ - public static FunctionDescriptor MagickShadowImage$descriptor() { - return MagickShadowImage.DESC; + public static FunctionDescriptor MagickGetImageMask$descriptor() { + return MagickGetImageMask.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickShadowImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) + * extern MagickWand *MagickGetImageMask(MagickWand *, const PixelMask) * } */ - public static MethodHandle MagickShadowImage$handle() { - return MagickShadowImage.HANDLE; + public static MethodHandle MagickGetImageMask$handle() { + return MagickGetImageMask.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickShadowImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) + * extern MagickWand *MagickGetImageMask(MagickWand *, const PixelMask) * } */ - public static MemorySegment MagickShadowImage$address() { - return MagickShadowImage.ADDR; + public static MemorySegment MagickGetImageMask$address() { + return MagickGetImageMask.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickShadowImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) + * extern MagickWand *MagickGetImageMask(MagickWand *, const PixelMask) * } */ - public static int MagickShadowImage(MemorySegment x0, double x1, double x2, long x3, long x4) { - var mh$ = MagickShadowImage.HANDLE; + public static MemorySegment MagickGetImageMask(MemorySegment x0, int x1) { + var mh$ = MagickGetImageMask.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickShadowImage", x0, x1, x2, x3, x4); + traceDowncall("MagickGetImageMask", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSharpenImage { + private static class MagickGetImageRegion { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSharpenImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageRegion"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17240,59 +31754,58 @@ private static class MagickSharpenImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSharpenImage(MagickWand *, const double, const double) + * extern MagickWand *MagickGetImageRegion(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static FunctionDescriptor MagickSharpenImage$descriptor() { - return MagickSharpenImage.DESC; + public static FunctionDescriptor MagickGetImageRegion$descriptor() { + return MagickGetImageRegion.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSharpenImage(MagickWand *, const double, const double) + * extern MagickWand *MagickGetImageRegion(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static MethodHandle MagickSharpenImage$handle() { - return MagickSharpenImage.HANDLE; + public static MethodHandle MagickGetImageRegion$handle() { + return MagickGetImageRegion.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSharpenImage(MagickWand *, const double, const double) + * extern MagickWand *MagickGetImageRegion(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static MemorySegment MagickSharpenImage$address() { - return MagickSharpenImage.ADDR; + public static MemorySegment MagickGetImageRegion$address() { + return MagickGetImageRegion.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSharpenImage(MagickWand *, const double, const double) + * extern MagickWand *MagickGetImageRegion(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) * } */ - public static int MagickSharpenImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickSharpenImage.HANDLE; + public static MemorySegment MagickGetImageRegion(MemorySegment x0, long x1, long x2, long x3, long x4) { + var mh$ = MagickGetImageRegion.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSharpenImage", x0, x1, x2); + traceDowncall("MagickGetImageRegion", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0, x1, x2); + return (MemorySegment)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickShaveImage { + private static class MagickMergeImageLayers { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickShaveImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMergeImageLayers"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17300,60 +31813,58 @@ private static class MagickShaveImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickShaveImage(MagickWand *, const size_t, const size_t) + * extern MagickWand *MagickMergeImageLayers(MagickWand *, const LayerMethod) * } */ - public static FunctionDescriptor MagickShaveImage$descriptor() { - return MagickShaveImage.DESC; + public static FunctionDescriptor MagickMergeImageLayers$descriptor() { + return MagickMergeImageLayers.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickShaveImage(MagickWand *, const size_t, const size_t) + * extern MagickWand *MagickMergeImageLayers(MagickWand *, const LayerMethod) * } */ - public static MethodHandle MagickShaveImage$handle() { - return MagickShaveImage.HANDLE; + public static MethodHandle MagickMergeImageLayers$handle() { + return MagickMergeImageLayers.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickShaveImage(MagickWand *, const size_t, const size_t) + * extern MagickWand *MagickMergeImageLayers(MagickWand *, const LayerMethod) * } */ - public static MemorySegment MagickShaveImage$address() { - return MagickShaveImage.ADDR; + public static MemorySegment MagickMergeImageLayers$address() { + return MagickMergeImageLayers.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickShaveImage(MagickWand *, const size_t, const size_t) + * extern MagickWand *MagickMergeImageLayers(MagickWand *, const LayerMethod) * } */ - public static int MagickShaveImage(MemorySegment x0, long x1, long x2) { - var mh$ = MagickShaveImage.HANDLE; + public static MemorySegment MagickMergeImageLayers(MemorySegment x0, int x1) { + var mh$ = MagickMergeImageLayers.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickShaveImage", x0, x1, x2); + traceDowncall("MagickMergeImageLayers", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickShearImage { + private static class MagickMorphImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickShearImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMorphImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17361,60 +31872,62 @@ private static class MagickShearImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickShearImage(MagickWand *, const PixelWand *, const double, const double) + * extern MagickWand *MagickMorphImages(MagickWand *, const size_t) * } */ - public static FunctionDescriptor MagickShearImage$descriptor() { - return MagickShearImage.DESC; + public static FunctionDescriptor MagickMorphImages$descriptor() { + return MagickMorphImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickShearImage(MagickWand *, const PixelWand *, const double, const double) + * extern MagickWand *MagickMorphImages(MagickWand *, const size_t) * } */ - public static MethodHandle MagickShearImage$handle() { - return MagickShearImage.HANDLE; + public static MethodHandle MagickMorphImages$handle() { + return MagickMorphImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickShearImage(MagickWand *, const PixelWand *, const double, const double) + * extern MagickWand *MagickMorphImages(MagickWand *, const size_t) * } */ - public static MemorySegment MagickShearImage$address() { - return MagickShearImage.ADDR; + public static MemorySegment MagickMorphImages$address() { + return MagickMorphImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickShearImage(MagickWand *, const PixelWand *, const double, const double) + * extern MagickWand *MagickMorphImages(MagickWand *, const size_t) * } */ - public static int MagickShearImage(MemorySegment x0, MemorySegment x1, double x2, double x3) { - var mh$ = MagickShearImage.HANDLE; + public static MemorySegment MagickMorphImages(MemorySegment x0, long x1) { + var mh$ = MagickMorphImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickShearImage", x0, x1, x2, x3); + traceDowncall("MagickMorphImages", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSigmoidalContrastImage { + private static class MagickMontageImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_INT, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSigmoidalContrastImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMontageImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17422,60 +31935,57 @@ private static class MagickSigmoidalContrastImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSigmoidalContrastImage(MagickWand *, const MagickBooleanType, const double, const double) + * extern MagickWand *MagickMontageImage(MagickWand *, const DrawingWand *, const char *, const char *, const MontageMode, const char *) * } */ - public static FunctionDescriptor MagickSigmoidalContrastImage$descriptor() { - return MagickSigmoidalContrastImage.DESC; + public static FunctionDescriptor MagickMontageImage$descriptor() { + return MagickMontageImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSigmoidalContrastImage(MagickWand *, const MagickBooleanType, const double, const double) + * extern MagickWand *MagickMontageImage(MagickWand *, const DrawingWand *, const char *, const char *, const MontageMode, const char *) * } */ - public static MethodHandle MagickSigmoidalContrastImage$handle() { - return MagickSigmoidalContrastImage.HANDLE; + public static MethodHandle MagickMontageImage$handle() { + return MagickMontageImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSigmoidalContrastImage(MagickWand *, const MagickBooleanType, const double, const double) + * extern MagickWand *MagickMontageImage(MagickWand *, const DrawingWand *, const char *, const char *, const MontageMode, const char *) * } */ - public static MemorySegment MagickSigmoidalContrastImage$address() { - return MagickSigmoidalContrastImage.ADDR; + public static MemorySegment MagickMontageImage$address() { + return MagickMontageImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSigmoidalContrastImage(MagickWand *, const MagickBooleanType, const double, const double) + * extern MagickWand *MagickMontageImage(MagickWand *, const DrawingWand *, const char *, const char *, const MontageMode, const char *) * } */ - public static int MagickSigmoidalContrastImage(MemorySegment x0, int x1, double x2, double x3) { - var mh$ = MagickSigmoidalContrastImage.HANDLE; + public static MemorySegment MagickMontageImage(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3, int x4, MemorySegment x5) { + var mh$ = MagickMontageImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSigmoidalContrastImage", x0, x1, x2, x3); + traceDowncall("MagickMontageImage", x0, x1, x2, x3, x4, x5); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (MemorySegment)mh$.invokeExact(x0, x1, x2, x3, x4, x5); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSketchImage { + private static class MagickOptimizeImageLayers { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSketchImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickOptimizeImageLayers"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17483,58 +31993,58 @@ private static class MagickSketchImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSketchImage(MagickWand *, const double, const double, const double) + * extern MagickWand *MagickOptimizeImageLayers(MagickWand *) * } */ - public static FunctionDescriptor MagickSketchImage$descriptor() { - return MagickSketchImage.DESC; + public static FunctionDescriptor MagickOptimizeImageLayers$descriptor() { + return MagickOptimizeImageLayers.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSketchImage(MagickWand *, const double, const double, const double) + * extern MagickWand *MagickOptimizeImageLayers(MagickWand *) * } */ - public static MethodHandle MagickSketchImage$handle() { - return MagickSketchImage.HANDLE; + public static MethodHandle MagickOptimizeImageLayers$handle() { + return MagickOptimizeImageLayers.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSketchImage(MagickWand *, const double, const double, const double) + * extern MagickWand *MagickOptimizeImageLayers(MagickWand *) * } */ - public static MemorySegment MagickSketchImage$address() { - return MagickSketchImage.ADDR; + public static MemorySegment MagickOptimizeImageLayers$address() { + return MagickOptimizeImageLayers.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSketchImage(MagickWand *, const double, const double, const double) + * extern MagickWand *MagickOptimizeImageLayers(MagickWand *) * } */ - public static int MagickSketchImage(MemorySegment x0, double x1, double x2, double x3) { - var mh$ = MagickSketchImage.HANDLE; + public static MemorySegment MagickOptimizeImageLayers(MemorySegment x0) { + var mh$ = MagickOptimizeImageLayers.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSketchImage", x0, x1, x2, x3); + traceDowncall("MagickOptimizeImageLayers", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSolarizeImage { + private static class MagickPreviewImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER, + MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSolarizeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPreviewImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17542,60 +32052,62 @@ private static class MagickSolarizeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSolarizeImage(MagickWand *, const double) + * extern MagickWand *MagickPreviewImages(MagickWand *wand, const PreviewType) * } */ - public static FunctionDescriptor MagickSolarizeImage$descriptor() { - return MagickSolarizeImage.DESC; + public static FunctionDescriptor MagickPreviewImages$descriptor() { + return MagickPreviewImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSolarizeImage(MagickWand *, const double) + * extern MagickWand *MagickPreviewImages(MagickWand *wand, const PreviewType) * } */ - public static MethodHandle MagickSolarizeImage$handle() { - return MagickSolarizeImage.HANDLE; + public static MethodHandle MagickPreviewImages$handle() { + return MagickPreviewImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSolarizeImage(MagickWand *, const double) + * extern MagickWand *MagickPreviewImages(MagickWand *wand, const PreviewType) * } */ - public static MemorySegment MagickSolarizeImage$address() { - return MagickSolarizeImage.ADDR; + public static MemorySegment MagickPreviewImages$address() { + return MagickPreviewImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSolarizeImage(MagickWand *, const double) + * extern MagickWand *MagickPreviewImages(MagickWand *wand, const PreviewType) * } */ - public static int MagickSolarizeImage(MemorySegment x0, double x1) { - var mh$ = MagickSolarizeImage.HANDLE; + public static MemorySegment MagickPreviewImages(MemorySegment wand, int x1) { + var mh$ = MagickPreviewImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSolarizeImage", x0, x1); + traceDowncall("MagickPreviewImages", wand, x1); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(wand, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSparseColorImage { + private static class MagickSimilarityImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_INT, - MagickWand_h.C_LONG, + MagickWand_h.C_DOUBLE, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSparseColorImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSimilarityImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17603,61 +32115,59 @@ private static class MagickSparseColorImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSparseColorImage(MagickWand *, const SparseColorMethod, const size_t, const double *) + * extern MagickWand *MagickSimilarityImage(MagickWand *, const MagickWand *, const MetricType, const double, RectangleInfo *, double *) * } */ - public static FunctionDescriptor MagickSparseColorImage$descriptor() { - return MagickSparseColorImage.DESC; + public static FunctionDescriptor MagickSimilarityImage$descriptor() { + return MagickSimilarityImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSparseColorImage(MagickWand *, const SparseColorMethod, const size_t, const double *) + * extern MagickWand *MagickSimilarityImage(MagickWand *, const MagickWand *, const MetricType, const double, RectangleInfo *, double *) * } */ - public static MethodHandle MagickSparseColorImage$handle() { - return MagickSparseColorImage.HANDLE; + public static MethodHandle MagickSimilarityImage$handle() { + return MagickSimilarityImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSparseColorImage(MagickWand *, const SparseColorMethod, const size_t, const double *) + * extern MagickWand *MagickSimilarityImage(MagickWand *, const MagickWand *, const MetricType, const double, RectangleInfo *, double *) * } */ - public static MemorySegment MagickSparseColorImage$address() { - return MagickSparseColorImage.ADDR; + public static MemorySegment MagickSimilarityImage$address() { + return MagickSimilarityImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSparseColorImage(MagickWand *, const SparseColorMethod, const size_t, const double *) + * extern MagickWand *MagickSimilarityImage(MagickWand *, const MagickWand *, const MetricType, const double, RectangleInfo *, double *) * } */ - public static int MagickSparseColorImage(MemorySegment x0, int x1, long x2, MemorySegment x3) { - var mh$ = MagickSparseColorImage.HANDLE; + public static MemorySegment MagickSimilarityImage(MemorySegment x0, MemorySegment x1, int x2, double x3, MemorySegment x4, MemorySegment x5) { + var mh$ = MagickSimilarityImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSparseColorImage", x0, x1, x2, x3); + traceDowncall("MagickSimilarityImage", x0, x1, x2, x3, x4, x5); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (MemorySegment)mh$.invokeExact(x0, x1, x2, x3, x4, x5); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSpliceImage { + private static class MagickSmushImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSpliceImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSmushImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17665,59 +32175,59 @@ private static class MagickSpliceImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSpliceImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickWand *MagickSmushImages(MagickWand *, const MagickBooleanType, const ssize_t) * } */ - public static FunctionDescriptor MagickSpliceImage$descriptor() { - return MagickSpliceImage.DESC; + public static FunctionDescriptor MagickSmushImages$descriptor() { + return MagickSmushImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSpliceImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickWand *MagickSmushImages(MagickWand *, const MagickBooleanType, const ssize_t) * } */ - public static MethodHandle MagickSpliceImage$handle() { - return MagickSpliceImage.HANDLE; + public static MethodHandle MagickSmushImages$handle() { + return MagickSmushImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSpliceImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickWand *MagickSmushImages(MagickWand *, const MagickBooleanType, const ssize_t) * } */ - public static MemorySegment MagickSpliceImage$address() { - return MagickSpliceImage.ADDR; + public static MemorySegment MagickSmushImages$address() { + return MagickSmushImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSpliceImage(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern MagickWand *MagickSmushImages(MagickWand *, const MagickBooleanType, const ssize_t) * } */ - public static int MagickSpliceImage(MemorySegment x0, long x1, long x2, long x3, long x4) { - var mh$ = MagickSpliceImage.HANDLE; + public static MemorySegment MagickSmushImages(MemorySegment x0, int x1, long x2) { + var mh$ = MagickSmushImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSpliceImage", x0, x1, x2, x3, x4); + traceDowncall("MagickSmushImages", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (MemorySegment)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSpreadImage { + private static class MagickSteganoImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_DOUBLE + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSpreadImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSteganoImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17725,60 +32235,58 @@ private static class MagickSpreadImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSpreadImage(MagickWand *, const PixelInterpolateMethod, const double) + * extern MagickWand *MagickSteganoImage(MagickWand *, const MagickWand *, const ssize_t) * } - */ - public static FunctionDescriptor MagickSpreadImage$descriptor() { - return MagickSpreadImage.DESC; + */ + public static FunctionDescriptor MagickSteganoImage$descriptor() { + return MagickSteganoImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSpreadImage(MagickWand *, const PixelInterpolateMethod, const double) + * extern MagickWand *MagickSteganoImage(MagickWand *, const MagickWand *, const ssize_t) * } */ - public static MethodHandle MagickSpreadImage$handle() { - return MagickSpreadImage.HANDLE; + public static MethodHandle MagickSteganoImage$handle() { + return MagickSteganoImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSpreadImage(MagickWand *, const PixelInterpolateMethod, const double) + * extern MagickWand *MagickSteganoImage(MagickWand *, const MagickWand *, const ssize_t) * } */ - public static MemorySegment MagickSpreadImage$address() { - return MagickSpreadImage.ADDR; + public static MemorySegment MagickSteganoImage$address() { + return MagickSteganoImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSpreadImage(MagickWand *, const PixelInterpolateMethod, const double) + * extern MagickWand *MagickSteganoImage(MagickWand *, const MagickWand *, const ssize_t) * } */ - public static int MagickSpreadImage(MemorySegment x0, int x1, double x2) { - var mh$ = MagickSpreadImage.HANDLE; + public static MemorySegment MagickSteganoImage(MemorySegment x0, MemorySegment x1, long x2) { + var mh$ = MagickSteganoImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSpreadImage", x0, x1, x2); + traceDowncall("MagickSteganoImage", x0, x1, x2); } - return (int)mh$.invokeExact(x0, x1, x2); + return (MemorySegment)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickStatisticImage { + private static class MagickStereoImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickStatisticImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickStereoImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17786,57 +32294,58 @@ private static class MagickStatisticImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickStatisticImage(MagickWand *, const StatisticType, const size_t, const size_t) + * extern MagickWand *MagickStereoImage(MagickWand *, const MagickWand *) * } */ - public static FunctionDescriptor MagickStatisticImage$descriptor() { - return MagickStatisticImage.DESC; + public static FunctionDescriptor MagickStereoImage$descriptor() { + return MagickStereoImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickStatisticImage(MagickWand *, const StatisticType, const size_t, const size_t) + * extern MagickWand *MagickStereoImage(MagickWand *, const MagickWand *) * } */ - public static MethodHandle MagickStatisticImage$handle() { - return MagickStatisticImage.HANDLE; + public static MethodHandle MagickStereoImage$handle() { + return MagickStereoImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickStatisticImage(MagickWand *, const StatisticType, const size_t, const size_t) + * extern MagickWand *MagickStereoImage(MagickWand *, const MagickWand *) * } */ - public static MemorySegment MagickStatisticImage$address() { - return MagickStatisticImage.ADDR; + public static MemorySegment MagickStereoImage$address() { + return MagickStereoImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickStatisticImage(MagickWand *, const StatisticType, const size_t, const size_t) + * extern MagickWand *MagickStereoImage(MagickWand *, const MagickWand *) * } */ - public static int MagickStatisticImage(MemorySegment x0, int x1, long x2, long x3) { - var mh$ = MagickStatisticImage.HANDLE; + public static MemorySegment MagickStereoImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickStereoImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickStatisticImage", x0, x1, x2, x3); + traceDowncall("MagickStereoImage", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickStripImage { + private static class MagickTextureImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickStripImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickTextureImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17844,59 +32353,57 @@ private static class MagickStripImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickStripImage(MagickWand *) + * extern MagickWand *MagickTextureImage(MagickWand *, const MagickWand *) * } */ - public static FunctionDescriptor MagickStripImage$descriptor() { - return MagickStripImage.DESC; + public static FunctionDescriptor MagickTextureImage$descriptor() { + return MagickTextureImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickStripImage(MagickWand *) + * extern MagickWand *MagickTextureImage(MagickWand *, const MagickWand *) * } */ - public static MethodHandle MagickStripImage$handle() { - return MagickStripImage.HANDLE; + public static MethodHandle MagickTextureImage$handle() { + return MagickTextureImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickStripImage(MagickWand *) + * extern MagickWand *MagickTextureImage(MagickWand *, const MagickWand *) * } */ - public static MemorySegment MagickStripImage$address() { - return MagickStripImage.ADDR; + public static MemorySegment MagickTextureImage$address() { + return MagickTextureImage.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickStripImage(MagickWand *) + * extern MagickWand *MagickTextureImage(MagickWand *, const MagickWand *) * } */ - public static int MagickStripImage(MemorySegment x0) { - var mh$ = MagickStripImage.HANDLE; + public static MemorySegment MagickTextureImage(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickTextureImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickStripImage", x0); + traceDowncall("MagickTextureImage", x0, x1); } - return (int)mh$.invokeExact(x0); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSwirlImage { + private static class MagickGetImageOrientation { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSwirlImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageOrientation"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17904,59 +32411,58 @@ private static class MagickSwirlImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickSwirlImage(MagickWand *, const double, const PixelInterpolateMethod) + * extern OrientationType MagickGetImageOrientation(MagickWand *) * } */ - public static FunctionDescriptor MagickSwirlImage$descriptor() { - return MagickSwirlImage.DESC; + public static FunctionDescriptor MagickGetImageOrientation$descriptor() { + return MagickGetImageOrientation.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickSwirlImage(MagickWand *, const double, const PixelInterpolateMethod) + * extern OrientationType MagickGetImageOrientation(MagickWand *) * } */ - public static MethodHandle MagickSwirlImage$handle() { - return MagickSwirlImage.HANDLE; + public static MethodHandle MagickGetImageOrientation$handle() { + return MagickGetImageOrientation.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickSwirlImage(MagickWand *, const double, const PixelInterpolateMethod) + * extern OrientationType MagickGetImageOrientation(MagickWand *) * } */ - public static MemorySegment MagickSwirlImage$address() { - return MagickSwirlImage.ADDR; + public static MemorySegment MagickGetImageOrientation$address() { + return MagickGetImageOrientation.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickSwirlImage(MagickWand *, const double, const PixelInterpolateMethod) + * extern OrientationType MagickGetImageOrientation(MagickWand *) * } */ - public static int MagickSwirlImage(MemorySegment x0, double x1, int x2) { - var mh$ = MagickSwirlImage.HANDLE; + public static int MagickGetImageOrientation(MemorySegment x0) { + var mh$ = MagickGetImageOrientation.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSwirlImage", x0, x1, x2); + traceDowncall("MagickGetImageOrientation", x0); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickTintImage { + private static class MagickGetImageHistogram { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickTintImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageHistogram"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -17964,58 +32470,57 @@ private static class MagickTintImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickTintImage(MagickWand *, const PixelWand *, const PixelWand *) + * extern PixelWand **MagickGetImageHistogram(MagickWand *, size_t *) * } */ - public static FunctionDescriptor MagickTintImage$descriptor() { - return MagickTintImage.DESC; + public static FunctionDescriptor MagickGetImageHistogram$descriptor() { + return MagickGetImageHistogram.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickTintImage(MagickWand *, const PixelWand *, const PixelWand *) + * extern PixelWand **MagickGetImageHistogram(MagickWand *, size_t *) * } */ - public static MethodHandle MagickTintImage$handle() { - return MagickTintImage.HANDLE; + public static MethodHandle MagickGetImageHistogram$handle() { + return MagickGetImageHistogram.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickTintImage(MagickWand *, const PixelWand *, const PixelWand *) + * extern PixelWand **MagickGetImageHistogram(MagickWand *, size_t *) * } */ - public static MemorySegment MagickTintImage$address() { - return MagickTintImage.ADDR; + public static MemorySegment MagickGetImageHistogram$address() { + return MagickGetImageHistogram.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickTintImage(MagickWand *, const PixelWand *, const PixelWand *) + * extern PixelWand **MagickGetImageHistogram(MagickWand *, size_t *) * } */ - public static int MagickTintImage(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickTintImage.HANDLE; + public static MemorySegment MagickGetImageHistogram(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickGetImageHistogram.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickTintImage", x0, x1, x2); + traceDowncall("MagickGetImageHistogram", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickTransformImageColorspace { + private static class MagickGetImageRenderingIntent { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickTransformImageColorspace"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageRenderingIntent"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18023,57 +32528,57 @@ private static class MagickTransformImageColorspace { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickTransformImageColorspace(MagickWand *, const ColorspaceType) + * extern RenderingIntent MagickGetImageRenderingIntent(MagickWand *) * } */ - public static FunctionDescriptor MagickTransformImageColorspace$descriptor() { - return MagickTransformImageColorspace.DESC; + public static FunctionDescriptor MagickGetImageRenderingIntent$descriptor() { + return MagickGetImageRenderingIntent.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickTransformImageColorspace(MagickWand *, const ColorspaceType) + * extern RenderingIntent MagickGetImageRenderingIntent(MagickWand *) * } */ - public static MethodHandle MagickTransformImageColorspace$handle() { - return MagickTransformImageColorspace.HANDLE; + public static MethodHandle MagickGetImageRenderingIntent$handle() { + return MagickGetImageRenderingIntent.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickTransformImageColorspace(MagickWand *, const ColorspaceType) + * extern RenderingIntent MagickGetImageRenderingIntent(MagickWand *) * } */ - public static MemorySegment MagickTransformImageColorspace$address() { - return MagickTransformImageColorspace.ADDR; + public static MemorySegment MagickGetImageRenderingIntent$address() { + return MagickGetImageRenderingIntent.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickTransformImageColorspace(MagickWand *, const ColorspaceType) + * extern RenderingIntent MagickGetImageRenderingIntent(MagickWand *) * } */ - public static int MagickTransformImageColorspace(MemorySegment x0, int x1) { - var mh$ = MagickTransformImageColorspace.HANDLE; + public static int MagickGetImageRenderingIntent(MemorySegment x0) { + var mh$ = MagickGetImageRenderingIntent.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickTransformImageColorspace", x0, x1); + traceDowncall("MagickGetImageRenderingIntent", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickTransposeImage { + private static class MagickGetImageUnits { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickTransposeImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageUnits"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18081,43 +32586,43 @@ private static class MagickTransposeImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickTransposeImage(MagickWand *) + * extern ResolutionType MagickGetImageUnits(MagickWand *) * } */ - public static FunctionDescriptor MagickTransposeImage$descriptor() { - return MagickTransposeImage.DESC; + public static FunctionDescriptor MagickGetImageUnits$descriptor() { + return MagickGetImageUnits.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickTransposeImage(MagickWand *) + * extern ResolutionType MagickGetImageUnits(MagickWand *) * } */ - public static MethodHandle MagickTransposeImage$handle() { - return MagickTransposeImage.HANDLE; + public static MethodHandle MagickGetImageUnits$handle() { + return MagickGetImageUnits.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickTransposeImage(MagickWand *) + * extern ResolutionType MagickGetImageUnits(MagickWand *) * } */ - public static MemorySegment MagickTransposeImage$address() { - return MagickTransposeImage.ADDR; + public static MemorySegment MagickGetImageUnits$address() { + return MagickGetImageUnits.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickTransposeImage(MagickWand *) + * extern ResolutionType MagickGetImageUnits(MagickWand *) * } */ - public static int MagickTransposeImage(MemorySegment x0) { - var mh$ = MagickTransposeImage.HANDLE; + public static int MagickGetImageUnits(MemorySegment x0) { + var mh$ = MagickGetImageUnits.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickTransposeImage", x0); + traceDowncall("MagickGetImageUnits", x0); } return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { @@ -18125,13 +32630,13 @@ public static int MagickTransposeImage(MemorySegment x0) { } } - private static class MagickTransverseImage { + private static class MagickGetImageColors { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_LONG, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickTransverseImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageColors"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18139,58 +32644,57 @@ private static class MagickTransverseImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickTransverseImage(MagickWand *) + * extern size_t MagickGetImageColors(MagickWand *) * } */ - public static FunctionDescriptor MagickTransverseImage$descriptor() { - return MagickTransverseImage.DESC; + public static FunctionDescriptor MagickGetImageColors$descriptor() { + return MagickGetImageColors.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickTransverseImage(MagickWand *) + * extern size_t MagickGetImageColors(MagickWand *) * } */ - public static MethodHandle MagickTransverseImage$handle() { - return MagickTransverseImage.HANDLE; + public static MethodHandle MagickGetImageColors$handle() { + return MagickGetImageColors.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickTransverseImage(MagickWand *) + * extern size_t MagickGetImageColors(MagickWand *) * } */ - public static MemorySegment MagickTransverseImage$address() { - return MagickTransverseImage.ADDR; + public static MemorySegment MagickGetImageColors$address() { + return MagickGetImageColors.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickTransverseImage(MagickWand *) + * extern size_t MagickGetImageColors(MagickWand *) * } */ - public static int MagickTransverseImage(MemorySegment x0) { - var mh$ = MagickTransverseImage.HANDLE; + public static long MagickGetImageColors(MemorySegment x0) { + var mh$ = MagickGetImageColors.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickTransverseImage", x0); + traceDowncall("MagickGetImageColors", x0); } - return (int)mh$.invokeExact(x0); + return (long)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickThresholdImage { + private static class MagickGetImageCompressionQuality { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickThresholdImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageCompressionQuality"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18198,59 +32702,57 @@ private static class MagickThresholdImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickThresholdImage(MagickWand *, const double) + * extern size_t MagickGetImageCompressionQuality(MagickWand *) * } */ - public static FunctionDescriptor MagickThresholdImage$descriptor() { - return MagickThresholdImage.DESC; + public static FunctionDescriptor MagickGetImageCompressionQuality$descriptor() { + return MagickGetImageCompressionQuality.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickThresholdImage(MagickWand *, const double) + * extern size_t MagickGetImageCompressionQuality(MagickWand *) * } */ - public static MethodHandle MagickThresholdImage$handle() { - return MagickThresholdImage.HANDLE; + public static MethodHandle MagickGetImageCompressionQuality$handle() { + return MagickGetImageCompressionQuality.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickThresholdImage(MagickWand *, const double) + * extern size_t MagickGetImageCompressionQuality(MagickWand *) * } */ - public static MemorySegment MagickThresholdImage$address() { - return MagickThresholdImage.ADDR; + public static MemorySegment MagickGetImageCompressionQuality$address() { + return MagickGetImageCompressionQuality.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickThresholdImage(MagickWand *, const double) + * extern size_t MagickGetImageCompressionQuality(MagickWand *) * } */ - public static int MagickThresholdImage(MemorySegment x0, double x1) { - var mh$ = MagickThresholdImage.HANDLE; + public static long MagickGetImageCompressionQuality(MemorySegment x0) { + var mh$ = MagickGetImageCompressionQuality.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickThresholdImage", x0, x1); + traceDowncall("MagickGetImageCompressionQuality", x0); } - return (int)mh$.invokeExact(x0, x1); + return (long)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickThumbnailImage { + private static class MagickGetImageDelay { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER, MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickThumbnailImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageDelay"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18258,58 +32760,57 @@ private static class MagickThumbnailImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickThumbnailImage(MagickWand *, const size_t, const size_t) + * extern size_t MagickGetImageDelay(MagickWand *) * } */ - public static FunctionDescriptor MagickThumbnailImage$descriptor() { - return MagickThumbnailImage.DESC; + public static FunctionDescriptor MagickGetImageDelay$descriptor() { + return MagickGetImageDelay.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickThumbnailImage(MagickWand *, const size_t, const size_t) + * extern size_t MagickGetImageDelay(MagickWand *) * } */ - public static MethodHandle MagickThumbnailImage$handle() { - return MagickThumbnailImage.HANDLE; + public static MethodHandle MagickGetImageDelay$handle() { + return MagickGetImageDelay.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickThumbnailImage(MagickWand *, const size_t, const size_t) + * extern size_t MagickGetImageDelay(MagickWand *) * } */ - public static MemorySegment MagickThumbnailImage$address() { - return MagickThumbnailImage.ADDR; + public static MemorySegment MagickGetImageDelay$address() { + return MagickGetImageDelay.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickThumbnailImage(MagickWand *, const size_t, const size_t) + * extern size_t MagickGetImageDelay(MagickWand *) * } */ - public static int MagickThumbnailImage(MemorySegment x0, long x1, long x2) { - var mh$ = MagickThumbnailImage.HANDLE; + public static long MagickGetImageDelay(MemorySegment x0) { + var mh$ = MagickGetImageDelay.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickThumbnailImage", x0, x1, x2); + traceDowncall("MagickGetImageDelay", x0); } - return (int)mh$.invokeExact(x0, x1, x2); + return (long)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickTrimImage { + private static class MagickGetImageDepth { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickTrimImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageDepth"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18317,57 +32818,57 @@ private static class MagickTrimImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickTrimImage(MagickWand *, const double) + * extern size_t MagickGetImageDepth(MagickWand *) * } */ - public static FunctionDescriptor MagickTrimImage$descriptor() { - return MagickTrimImage.DESC; + public static FunctionDescriptor MagickGetImageDepth$descriptor() { + return MagickGetImageDepth.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickTrimImage(MagickWand *, const double) + * extern size_t MagickGetImageDepth(MagickWand *) * } */ - public static MethodHandle MagickTrimImage$handle() { - return MagickTrimImage.HANDLE; + public static MethodHandle MagickGetImageDepth$handle() { + return MagickGetImageDepth.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickTrimImage(MagickWand *, const double) + * extern size_t MagickGetImageDepth(MagickWand *) * } */ - public static MemorySegment MagickTrimImage$address() { - return MagickTrimImage.ADDR; + public static MemorySegment MagickGetImageDepth$address() { + return MagickGetImageDepth.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickTrimImage(MagickWand *, const double) + * extern size_t MagickGetImageDepth(MagickWand *) * } */ - public static int MagickTrimImage(MemorySegment x0, double x1) { - var mh$ = MagickTrimImage.HANDLE; + public static long MagickGetImageDepth(MemorySegment x0) { + var mh$ = MagickGetImageDepth.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickTrimImage", x0, x1); + traceDowncall("MagickGetImageDepth", x0); } - return (int)mh$.invokeExact(x0, x1); + return (long)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickUniqueImageColors { + private static class MagickGetImageHeight { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_LONG, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickUniqueImageColors"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageHeight"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18375,61 +32876,57 @@ private static class MagickUniqueImageColors { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickUniqueImageColors(MagickWand *) + * extern size_t MagickGetImageHeight(MagickWand *) * } */ - public static FunctionDescriptor MagickUniqueImageColors$descriptor() { - return MagickUniqueImageColors.DESC; + public static FunctionDescriptor MagickGetImageHeight$descriptor() { + return MagickGetImageHeight.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickUniqueImageColors(MagickWand *) + * extern size_t MagickGetImageHeight(MagickWand *) * } */ - public static MethodHandle MagickUniqueImageColors$handle() { - return MagickUniqueImageColors.HANDLE; + public static MethodHandle MagickGetImageHeight$handle() { + return MagickGetImageHeight.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickUniqueImageColors(MagickWand *) + * extern size_t MagickGetImageHeight(MagickWand *) * } */ - public static MemorySegment MagickUniqueImageColors$address() { - return MagickUniqueImageColors.ADDR; + public static MemorySegment MagickGetImageHeight$address() { + return MagickGetImageHeight.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickUniqueImageColors(MagickWand *) + * extern size_t MagickGetImageHeight(MagickWand *) * } */ - public static int MagickUniqueImageColors(MemorySegment x0) { - var mh$ = MagickUniqueImageColors.HANDLE; + public static long MagickGetImageHeight(MemorySegment x0) { + var mh$ = MagickGetImageHeight.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickUniqueImageColors", x0); + traceDowncall("MagickGetImageHeight", x0); } - return (int)mh$.invokeExact(x0); + return (long)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickUnsharpMaskImage { + private static class MagickGetImageIterations { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickUnsharpMaskImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageIterations"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18437,61 +32934,57 @@ private static class MagickUnsharpMaskImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickUnsharpMaskImage(MagickWand *, const double, const double, const double, const double) + * extern size_t MagickGetImageIterations(MagickWand *) * } */ - public static FunctionDescriptor MagickUnsharpMaskImage$descriptor() { - return MagickUnsharpMaskImage.DESC; + public static FunctionDescriptor MagickGetImageIterations$descriptor() { + return MagickGetImageIterations.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickUnsharpMaskImage(MagickWand *, const double, const double, const double, const double) + * extern size_t MagickGetImageIterations(MagickWand *) * } */ - public static MethodHandle MagickUnsharpMaskImage$handle() { - return MagickUnsharpMaskImage.HANDLE; + public static MethodHandle MagickGetImageIterations$handle() { + return MagickGetImageIterations.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickUnsharpMaskImage(MagickWand *, const double, const double, const double, const double) + * extern size_t MagickGetImageIterations(MagickWand *) * } */ - public static MemorySegment MagickUnsharpMaskImage$address() { - return MagickUnsharpMaskImage.ADDR; + public static MemorySegment MagickGetImageIterations$address() { + return MagickGetImageIterations.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickUnsharpMaskImage(MagickWand *, const double, const double, const double, const double) + * extern size_t MagickGetImageIterations(MagickWand *) * } */ - public static int MagickUnsharpMaskImage(MemorySegment x0, double x1, double x2, double x3, double x4) { - var mh$ = MagickUnsharpMaskImage.HANDLE; + public static long MagickGetImageIterations(MemorySegment x0) { + var mh$ = MagickGetImageIterations.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickUnsharpMaskImage", x0, x1, x2, x3, x4); + traceDowncall("MagickGetImageIterations", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (long)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickVignetteImage { + private static class MagickGetImageScene { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickVignetteImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageScene"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18499,60 +32992,57 @@ private static class MagickVignetteImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickVignetteImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) + * extern size_t MagickGetImageScene(MagickWand *) * } */ - public static FunctionDescriptor MagickVignetteImage$descriptor() { - return MagickVignetteImage.DESC; + public static FunctionDescriptor MagickGetImageScene$descriptor() { + return MagickGetImageScene.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickVignetteImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) + * extern size_t MagickGetImageScene(MagickWand *) * } */ - public static MethodHandle MagickVignetteImage$handle() { - return MagickVignetteImage.HANDLE; + public static MethodHandle MagickGetImageScene$handle() { + return MagickGetImageScene.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickVignetteImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) + * extern size_t MagickGetImageScene(MagickWand *) * } */ - public static MemorySegment MagickVignetteImage$address() { - return MagickVignetteImage.ADDR; + public static MemorySegment MagickGetImageScene$address() { + return MagickGetImageScene.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickVignetteImage(MagickWand *, const double, const double, const ssize_t, const ssize_t) + * extern size_t MagickGetImageScene(MagickWand *) * } */ - public static int MagickVignetteImage(MemorySegment x0, double x1, double x2, long x3, long x4) { - var mh$ = MagickVignetteImage.HANDLE; + public static long MagickGetImageScene(MemorySegment x0) { + var mh$ = MagickGetImageScene.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickVignetteImage", x0, x1, x2, x3, x4); + traceDowncall("MagickGetImageScene", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3, x4); + return (long)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickWaveImage { + private static class MagickGetImageTicksPerSecond { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_INT + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWaveImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageTicksPerSecond"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18560,59 +33050,57 @@ private static class MagickWaveImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickWaveImage(MagickWand *, const double, const double, const PixelInterpolateMethod) + * extern size_t MagickGetImageTicksPerSecond(MagickWand *) * } */ - public static FunctionDescriptor MagickWaveImage$descriptor() { - return MagickWaveImage.DESC; + public static FunctionDescriptor MagickGetImageTicksPerSecond$descriptor() { + return MagickGetImageTicksPerSecond.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickWaveImage(MagickWand *, const double, const double, const PixelInterpolateMethod) + * extern size_t MagickGetImageTicksPerSecond(MagickWand *) * } */ - public static MethodHandle MagickWaveImage$handle() { - return MagickWaveImage.HANDLE; + public static MethodHandle MagickGetImageTicksPerSecond$handle() { + return MagickGetImageTicksPerSecond.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickWaveImage(MagickWand *, const double, const double, const PixelInterpolateMethod) + * extern size_t MagickGetImageTicksPerSecond(MagickWand *) * } */ - public static MemorySegment MagickWaveImage$address() { - return MagickWaveImage.ADDR; + public static MemorySegment MagickGetImageTicksPerSecond$address() { + return MagickGetImageTicksPerSecond.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickWaveImage(MagickWand *, const double, const double, const PixelInterpolateMethod) + * extern size_t MagickGetImageTicksPerSecond(MagickWand *) * } */ - public static int MagickWaveImage(MemorySegment x0, double x1, double x2, int x3) { - var mh$ = MagickWaveImage.HANDLE; + public static long MagickGetImageTicksPerSecond(MemorySegment x0) { + var mh$ = MagickGetImageTicksPerSecond.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickWaveImage", x0, x1, x2, x3); + traceDowncall("MagickGetImageTicksPerSecond", x0); } - return (int)mh$.invokeExact(x0, x1, x2, x3); + return (long)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickWaveletDenoiseImage { + private static class MagickGetImageWidth { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, - MagickWand_h.C_POINTER, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_DOUBLE + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWaveletDenoiseImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageWidth"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18620,57 +33108,57 @@ private static class MagickWaveletDenoiseImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickWaveletDenoiseImage(MagickWand *, const double, const double) + * extern size_t MagickGetImageWidth(MagickWand *) * } */ - public static FunctionDescriptor MagickWaveletDenoiseImage$descriptor() { - return MagickWaveletDenoiseImage.DESC; + public static FunctionDescriptor MagickGetImageWidth$descriptor() { + return MagickGetImageWidth.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickWaveletDenoiseImage(MagickWand *, const double, const double) + * extern size_t MagickGetImageWidth(MagickWand *) * } */ - public static MethodHandle MagickWaveletDenoiseImage$handle() { - return MagickWaveletDenoiseImage.HANDLE; + public static MethodHandle MagickGetImageWidth$handle() { + return MagickGetImageWidth.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickWaveletDenoiseImage(MagickWand *, const double, const double) + * extern size_t MagickGetImageWidth(MagickWand *) * } */ - public static MemorySegment MagickWaveletDenoiseImage$address() { - return MagickWaveletDenoiseImage.ADDR; + public static MemorySegment MagickGetImageWidth$address() { + return MagickGetImageWidth.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickWaveletDenoiseImage(MagickWand *, const double, const double) + * extern size_t MagickGetImageWidth(MagickWand *) * } */ - public static int MagickWaveletDenoiseImage(MemorySegment x0, double x1, double x2) { - var mh$ = MagickWaveletDenoiseImage.HANDLE; + public static long MagickGetImageWidth(MemorySegment x0) { + var mh$ = MagickGetImageWidth.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickWaveletDenoiseImage", x0, x1, x2); + traceDowncall("MagickGetImageWidth", x0); } - return (int)mh$.invokeExact(x0, x1, x2); + return (long)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickWhiteBalanceImage { + private static class MagickGetNumberImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_LONG, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWhiteBalanceImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetNumberImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18678,58 +33166,58 @@ private static class MagickWhiteBalanceImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickWhiteBalanceImage(MagickWand *) + * extern size_t MagickGetNumberImages(MagickWand *) * } */ - public static FunctionDescriptor MagickWhiteBalanceImage$descriptor() { - return MagickWhiteBalanceImage.DESC; + public static FunctionDescriptor MagickGetNumberImages$descriptor() { + return MagickGetNumberImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickWhiteBalanceImage(MagickWand *) + * extern size_t MagickGetNumberImages(MagickWand *) * } */ - public static MethodHandle MagickWhiteBalanceImage$handle() { - return MagickWhiteBalanceImage.HANDLE; + public static MethodHandle MagickGetNumberImages$handle() { + return MagickGetNumberImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickWhiteBalanceImage(MagickWand *) + * extern size_t MagickGetNumberImages(MagickWand *) * } */ - public static MemorySegment MagickWhiteBalanceImage$address() { - return MagickWhiteBalanceImage.ADDR; + public static MemorySegment MagickGetNumberImages$address() { + return MagickGetNumberImages.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickWhiteBalanceImage(MagickWand *) + * extern size_t MagickGetNumberImages(MagickWand *) * } */ - public static int MagickWhiteBalanceImage(MemorySegment x0) { - var mh$ = MagickWhiteBalanceImage.HANDLE; + public static long MagickGetNumberImages(MemorySegment x0) { + var mh$ = MagickGetNumberImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickWhiteBalanceImage", x0); + traceDowncall("MagickGetNumberImages", x0); } - return (int)mh$.invokeExact(x0); + return (long)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickWhiteThresholdImage { + private static class MagickGetImageBlob { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWhiteThresholdImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageBlob"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18737,58 +33225,58 @@ private static class MagickWhiteThresholdImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickWhiteThresholdImage(MagickWand *, const PixelWand *) + * extern unsigned char *MagickGetImageBlob(MagickWand *, size_t *) * } */ - public static FunctionDescriptor MagickWhiteThresholdImage$descriptor() { - return MagickWhiteThresholdImage.DESC; + public static FunctionDescriptor MagickGetImageBlob$descriptor() { + return MagickGetImageBlob.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickWhiteThresholdImage(MagickWand *, const PixelWand *) + * extern unsigned char *MagickGetImageBlob(MagickWand *, size_t *) * } */ - public static MethodHandle MagickWhiteThresholdImage$handle() { - return MagickWhiteThresholdImage.HANDLE; + public static MethodHandle MagickGetImageBlob$handle() { + return MagickGetImageBlob.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickWhiteThresholdImage(MagickWand *, const PixelWand *) + * extern unsigned char *MagickGetImageBlob(MagickWand *, size_t *) * } */ - public static MemorySegment MagickWhiteThresholdImage$address() { - return MagickWhiteThresholdImage.ADDR; + public static MemorySegment MagickGetImageBlob$address() { + return MagickGetImageBlob.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickWhiteThresholdImage(MagickWand *, const PixelWand *) + * extern unsigned char *MagickGetImageBlob(MagickWand *, size_t *) * } */ - public static int MagickWhiteThresholdImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickWhiteThresholdImage.HANDLE; + public static MemorySegment MagickGetImageBlob(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickGetImageBlob.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickWhiteThresholdImage", x0, x1); + traceDowncall("MagickGetImageBlob", x0, x1); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickWriteImage { + private static class MagickGetImagesBlob { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWriteImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImagesBlob"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18796,58 +33284,57 @@ private static class MagickWriteImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickWriteImage(MagickWand *, const char *) + * extern unsigned char *MagickGetImagesBlob(MagickWand *, size_t *) * } */ - public static FunctionDescriptor MagickWriteImage$descriptor() { - return MagickWriteImage.DESC; + public static FunctionDescriptor MagickGetImagesBlob$descriptor() { + return MagickGetImagesBlob.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickWriteImage(MagickWand *, const char *) + * extern unsigned char *MagickGetImagesBlob(MagickWand *, size_t *) * } */ - public static MethodHandle MagickWriteImage$handle() { - return MagickWriteImage.HANDLE; + public static MethodHandle MagickGetImagesBlob$handle() { + return MagickGetImagesBlob.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickWriteImage(MagickWand *, const char *) + * extern unsigned char *MagickGetImagesBlob(MagickWand *, size_t *) * } */ - public static MemorySegment MagickWriteImage$address() { - return MagickWriteImage.ADDR; + public static MemorySegment MagickGetImagesBlob$address() { + return MagickGetImagesBlob.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickWriteImage(MagickWand *, const char *) + * extern unsigned char *MagickGetImagesBlob(MagickWand *, size_t *) * } */ - public static int MagickWriteImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickWriteImage.HANDLE; + public static MemorySegment MagickGetImagesBlob(MemorySegment x0, MemorySegment x1) { + var mh$ = MagickGetImagesBlob.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickWriteImage", x0, x1); + traceDowncall("MagickGetImagesBlob", x0, x1); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickWriteImageFile { + private static class MagickGetImageVirtualPixelMethod { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWriteImageFile"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageVirtualPixelMethod"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18855,59 +33342,58 @@ private static class MagickWriteImageFile { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickWriteImageFile(MagickWand *, FILE *) + * extern VirtualPixelMethod MagickGetImageVirtualPixelMethod(MagickWand *) * } */ - public static FunctionDescriptor MagickWriteImageFile$descriptor() { - return MagickWriteImageFile.DESC; + public static FunctionDescriptor MagickGetImageVirtualPixelMethod$descriptor() { + return MagickGetImageVirtualPixelMethod.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickWriteImageFile(MagickWand *, FILE *) + * extern VirtualPixelMethod MagickGetImageVirtualPixelMethod(MagickWand *) * } */ - public static MethodHandle MagickWriteImageFile$handle() { - return MagickWriteImageFile.HANDLE; + public static MethodHandle MagickGetImageVirtualPixelMethod$handle() { + return MagickGetImageVirtualPixelMethod.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickWriteImageFile(MagickWand *, FILE *) + * extern VirtualPixelMethod MagickGetImageVirtualPixelMethod(MagickWand *) * } */ - public static MemorySegment MagickWriteImageFile$address() { - return MagickWriteImageFile.ADDR; + public static MemorySegment MagickGetImageVirtualPixelMethod$address() { + return MagickGetImageVirtualPixelMethod.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickWriteImageFile(MagickWand *, FILE *) + * extern VirtualPixelMethod MagickGetImageVirtualPixelMethod(MagickWand *) * } */ - public static int MagickWriteImageFile(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickWriteImageFile.HANDLE; + public static int MagickGetImageVirtualPixelMethod(MemorySegment x0) { + var mh$ = MagickGetImageVirtualPixelMethod.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickWriteImageFile", x0, x1); + traceDowncall("MagickGetImageVirtualPixelMethod", x0); } - return (int)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickWriteImages { + private static class MagickSetImageVirtualPixelMethod { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, MagickWand_h.C_INT ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickWriteImages"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageVirtualPixelMethod"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18915,59 +33401,61 @@ private static class MagickWriteImages { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickBooleanType MagickWriteImages(MagickWand *, const char *, const MagickBooleanType) + * extern VirtualPixelMethod MagickSetImageVirtualPixelMethod(MagickWand *, const VirtualPixelMethod) * } */ - public static FunctionDescriptor MagickWriteImages$descriptor() { - return MagickWriteImages.DESC; + public static FunctionDescriptor MagickSetImageVirtualPixelMethod$descriptor() { + return MagickSetImageVirtualPixelMethod.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickBooleanType MagickWriteImages(MagickWand *, const char *, const MagickBooleanType) + * extern VirtualPixelMethod MagickSetImageVirtualPixelMethod(MagickWand *, const VirtualPixelMethod) * } */ - public static MethodHandle MagickWriteImages$handle() { - return MagickWriteImages.HANDLE; + public static MethodHandle MagickSetImageVirtualPixelMethod$handle() { + return MagickSetImageVirtualPixelMethod.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickBooleanType MagickWriteImages(MagickWand *, const char *, const MagickBooleanType) + * extern VirtualPixelMethod MagickSetImageVirtualPixelMethod(MagickWand *, const VirtualPixelMethod) * } */ - public static MemorySegment MagickWriteImages$address() { - return MagickWriteImages.ADDR; + public static MemorySegment MagickSetImageVirtualPixelMethod$address() { + return MagickSetImageVirtualPixelMethod.ADDR; } /** * {@snippet lang=c : - * extern MagickBooleanType MagickWriteImages(MagickWand *, const char *, const MagickBooleanType) + * extern VirtualPixelMethod MagickSetImageVirtualPixelMethod(MagickWand *, const VirtualPixelMethod) * } */ - public static int MagickWriteImages(MemorySegment x0, MemorySegment x1, int x2) { - var mh$ = MagickWriteImages.HANDLE; + public static int MagickSetImageVirtualPixelMethod(MemorySegment x0, int x1) { + var mh$ = MagickSetImageVirtualPixelMethod.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickWriteImages", x0, x1, x2); + traceDowncall("MagickSetImageVirtualPixelMethod", x0, x1); } - return (int)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageProgressMonitor { + private static class MogrifyImage { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageProgressMonitor"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MogrifyImage"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -18975,58 +33463,61 @@ private static class MagickSetImageProgressMonitor { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickProgressMonitor MagickSetImageProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) + * extern MagickBooleanType MogrifyImage(ImageInfo *, const int, const char **, Image **, ExceptionInfo *) * } */ - public static FunctionDescriptor MagickSetImageProgressMonitor$descriptor() { - return MagickSetImageProgressMonitor.DESC; + public static FunctionDescriptor MogrifyImage$descriptor() { + return MogrifyImage.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickProgressMonitor MagickSetImageProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) + * extern MagickBooleanType MogrifyImage(ImageInfo *, const int, const char **, Image **, ExceptionInfo *) * } */ - public static MethodHandle MagickSetImageProgressMonitor$handle() { - return MagickSetImageProgressMonitor.HANDLE; + public static MethodHandle MogrifyImage$handle() { + return MogrifyImage.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickProgressMonitor MagickSetImageProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) + * extern MagickBooleanType MogrifyImage(ImageInfo *, const int, const char **, Image **, ExceptionInfo *) * } */ - public static MemorySegment MagickSetImageProgressMonitor$address() { - return MagickSetImageProgressMonitor.ADDR; + public static MemorySegment MogrifyImage$address() { + return MogrifyImage.ADDR; } /** * {@snippet lang=c : - * extern MagickProgressMonitor MagickSetImageProgressMonitor(MagickWand *, const MagickProgressMonitor, void *) + * extern MagickBooleanType MogrifyImage(ImageInfo *, const int, const char **, Image **, ExceptionInfo *) * } */ - public static MemorySegment MagickSetImageProgressMonitor(MemorySegment x0, MemorySegment x1, MemorySegment x2) { - var mh$ = MagickSetImageProgressMonitor.HANDLE; + public static int MogrifyImage(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = MogrifyImage.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageProgressMonitor", x0, x1, x2); + traceDowncall("MogrifyImage", x0, x1, x2, x3, x4); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickAppendImages { + private static class MogrifyImageCommand { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickAppendImages"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MogrifyImageCommand"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19034,58 +33525,60 @@ private static class MagickAppendImages { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickAppendImages(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MogrifyImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) * } */ - public static FunctionDescriptor MagickAppendImages$descriptor() { - return MagickAppendImages.DESC; + public static FunctionDescriptor MogrifyImageCommand$descriptor() { + return MogrifyImageCommand.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickAppendImages(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MogrifyImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) * } */ - public static MethodHandle MagickAppendImages$handle() { - return MagickAppendImages.HANDLE; + public static MethodHandle MogrifyImageCommand$handle() { + return MogrifyImageCommand.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickAppendImages(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MogrifyImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) * } */ - public static MemorySegment MagickAppendImages$address() { - return MagickAppendImages.ADDR; + public static MemorySegment MogrifyImageCommand$address() { + return MogrifyImageCommand.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickAppendImages(MagickWand *, const MagickBooleanType) + * extern MagickBooleanType MogrifyImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) * } */ - public static MemorySegment MagickAppendImages(MemorySegment x0, int x1) { - var mh$ = MagickAppendImages.HANDLE; + public static int MogrifyImageCommand(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = MogrifyImageCommand.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickAppendImages", x0, x1); + traceDowncall("MogrifyImageCommand", x0, x1, x2, x3, x4); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickChannelFxImage { + private static class MogrifyImageInfo { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickChannelFxImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MogrifyImageInfo"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19093,57 +33586,61 @@ private static class MagickChannelFxImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickChannelFxImage(MagickWand *, const char *) + * extern MagickBooleanType MogrifyImageInfo(ImageInfo *, const int, const char **, ExceptionInfo *) * } */ - public static FunctionDescriptor MagickChannelFxImage$descriptor() { - return MagickChannelFxImage.DESC; + public static FunctionDescriptor MogrifyImageInfo$descriptor() { + return MogrifyImageInfo.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickChannelFxImage(MagickWand *, const char *) + * extern MagickBooleanType MogrifyImageInfo(ImageInfo *, const int, const char **, ExceptionInfo *) * } */ - public static MethodHandle MagickChannelFxImage$handle() { - return MagickChannelFxImage.HANDLE; + public static MethodHandle MogrifyImageInfo$handle() { + return MogrifyImageInfo.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickChannelFxImage(MagickWand *, const char *) + * extern MagickBooleanType MogrifyImageInfo(ImageInfo *, const int, const char **, ExceptionInfo *) * } */ - public static MemorySegment MagickChannelFxImage$address() { - return MagickChannelFxImage.ADDR; + public static MemorySegment MogrifyImageInfo$address() { + return MogrifyImageInfo.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickChannelFxImage(MagickWand *, const char *) + * extern MagickBooleanType MogrifyImageInfo(ImageInfo *, const int, const char **, ExceptionInfo *) * } */ - public static MemorySegment MagickChannelFxImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickChannelFxImage.HANDLE; + public static int MogrifyImageInfo(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3) { + var mh$ = MogrifyImageInfo.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickChannelFxImage", x0, x1); + traceDowncall("MogrifyImageInfo", x0, x1, x2, x3); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickCoalesceImages { + private static class MogrifyImageList { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCoalesceImages"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MogrifyImageList"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19151,58 +33648,62 @@ private static class MagickCoalesceImages { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickCoalesceImages(MagickWand *) + * extern MagickBooleanType MogrifyImageList(ImageInfo *, const int, const char **, Image **, ExceptionInfo *) * } */ - public static FunctionDescriptor MagickCoalesceImages$descriptor() { - return MagickCoalesceImages.DESC; + public static FunctionDescriptor MogrifyImageList$descriptor() { + return MogrifyImageList.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickCoalesceImages(MagickWand *) + * extern MagickBooleanType MogrifyImageList(ImageInfo *, const int, const char **, Image **, ExceptionInfo *) * } */ - public static MethodHandle MagickCoalesceImages$handle() { - return MagickCoalesceImages.HANDLE; + public static MethodHandle MogrifyImageList$handle() { + return MogrifyImageList.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickCoalesceImages(MagickWand *) + * extern MagickBooleanType MogrifyImageList(ImageInfo *, const int, const char **, Image **, ExceptionInfo *) * } */ - public static MemorySegment MagickCoalesceImages$address() { - return MagickCoalesceImages.ADDR; + public static MemorySegment MogrifyImageList$address() { + return MogrifyImageList.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickCoalesceImages(MagickWand *) + * extern MagickBooleanType MogrifyImageList(ImageInfo *, const int, const char **, Image **, ExceptionInfo *) * } */ - public static MemorySegment MagickCoalesceImages(MemorySegment x0) { - var mh$ = MagickCoalesceImages.HANDLE; + public static int MogrifyImageList(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = MogrifyImageList.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickCoalesceImages", x0); + traceDowncall("MogrifyImageList", x0, x1, x2, x3, x4); } - return (MemorySegment)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickCombineImages { + private static class MogrifyImages { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_INT, + MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCombineImages"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MogrifyImages"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19210,60 +33711,61 @@ private static class MagickCombineImages { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickCombineImages(MagickWand *, const ColorspaceType) + * extern MagickBooleanType MogrifyImages(ImageInfo *, const MagickBooleanType, const int, const char **, Image **, ExceptionInfo *) * } */ - public static FunctionDescriptor MagickCombineImages$descriptor() { - return MagickCombineImages.DESC; + public static FunctionDescriptor MogrifyImages$descriptor() { + return MogrifyImages.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickCombineImages(MagickWand *, const ColorspaceType) + * extern MagickBooleanType MogrifyImages(ImageInfo *, const MagickBooleanType, const int, const char **, Image **, ExceptionInfo *) * } */ - public static MethodHandle MagickCombineImages$handle() { - return MagickCombineImages.HANDLE; + public static MethodHandle MogrifyImages$handle() { + return MogrifyImages.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickCombineImages(MagickWand *, const ColorspaceType) + * extern MagickBooleanType MogrifyImages(ImageInfo *, const MagickBooleanType, const int, const char **, Image **, ExceptionInfo *) * } */ - public static MemorySegment MagickCombineImages$address() { - return MagickCombineImages.ADDR; + public static MemorySegment MogrifyImages$address() { + return MogrifyImages.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickCombineImages(MagickWand *, const ColorspaceType) + * extern MagickBooleanType MogrifyImages(ImageInfo *, const MagickBooleanType, const int, const char **, Image **, ExceptionInfo *) * } */ - public static MemorySegment MagickCombineImages(MemorySegment x0, int x1) { - var mh$ = MagickCombineImages.HANDLE; + public static int MogrifyImages(MemorySegment x0, int x1, int x2, MemorySegment x3, MemorySegment x4, MemorySegment x5) { + var mh$ = MogrifyImages.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickCombineImages", x0, x1); + traceDowncall("MogrifyImages", x0, x1, x2, x3, x4, x5); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4, x5); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickCompareImages { + private static class MontageImageCommand { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, - MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCompareImages"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MontageImageCommand"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19271,58 +33773,58 @@ private static class MagickCompareImages { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickCompareImages(MagickWand *, const MagickWand *, const MetricType, double *) + * extern MagickBooleanType MontageImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) * } */ - public static FunctionDescriptor MagickCompareImages$descriptor() { - return MagickCompareImages.DESC; + public static FunctionDescriptor MontageImageCommand$descriptor() { + return MontageImageCommand.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickCompareImages(MagickWand *, const MagickWand *, const MetricType, double *) + * extern MagickBooleanType MontageImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) * } */ - public static MethodHandle MagickCompareImages$handle() { - return MagickCompareImages.HANDLE; + public static MethodHandle MontageImageCommand$handle() { + return MontageImageCommand.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickCompareImages(MagickWand *, const MagickWand *, const MetricType, double *) + * extern MagickBooleanType MontageImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) * } */ - public static MemorySegment MagickCompareImages$address() { - return MagickCompareImages.ADDR; + public static MemorySegment MontageImageCommand$address() { + return MontageImageCommand.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickCompareImages(MagickWand *, const MagickWand *, const MetricType, double *) + * extern MagickBooleanType MontageImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) * } */ - public static MemorySegment MagickCompareImages(MemorySegment x0, MemorySegment x1, int x2, MemorySegment x3) { - var mh$ = MagickCompareImages.HANDLE; + public static int MontageImageCommand(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = MontageImageCommand.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickCompareImages", x0, x1, x2, x3); + traceDowncall("MontageImageCommand", x0, x1, x2, x3, x4); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2, x3); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickCompareImagesLayers { + private static class PixelGetIteratorException { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickCompareImagesLayers"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelGetIteratorException"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19330,43 +33832,43 @@ private static class MagickCompareImagesLayers { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickCompareImagesLayers(MagickWand *, const LayerMethod) + * extern char *PixelGetIteratorException(const PixelIterator *, ExceptionType *) * } */ - public static FunctionDescriptor MagickCompareImagesLayers$descriptor() { - return MagickCompareImagesLayers.DESC; + public static FunctionDescriptor PixelGetIteratorException$descriptor() { + return PixelGetIteratorException.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickCompareImagesLayers(MagickWand *, const LayerMethod) + * extern char *PixelGetIteratorException(const PixelIterator *, ExceptionType *) * } */ - public static MethodHandle MagickCompareImagesLayers$handle() { - return MagickCompareImagesLayers.HANDLE; + public static MethodHandle PixelGetIteratorException$handle() { + return PixelGetIteratorException.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickCompareImagesLayers(MagickWand *, const LayerMethod) + * extern char *PixelGetIteratorException(const PixelIterator *, ExceptionType *) * } */ - public static MemorySegment MagickCompareImagesLayers$address() { - return MagickCompareImagesLayers.ADDR; + public static MemorySegment PixelGetIteratorException$address() { + return PixelGetIteratorException.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickCompareImagesLayers(MagickWand *, const LayerMethod) + * extern char *PixelGetIteratorException(const PixelIterator *, ExceptionType *) * } */ - public static MemorySegment MagickCompareImagesLayers(MemorySegment x0, int x1) { - var mh$ = MagickCompareImagesLayers.HANDLE; + public static MemorySegment PixelGetIteratorException(MemorySegment x0, MemorySegment x1) { + var mh$ = PixelGetIteratorException.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickCompareImagesLayers", x0, x1); + traceDowncall("PixelGetIteratorException", x0, x1); } return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { @@ -19374,14 +33876,13 @@ public static MemorySegment MagickCompareImagesLayers(MemorySegment x0, int x1) } } - private static class MagickComplexImages { + private static class PixelGetIteratorExceptionType { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_INT, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickComplexImages"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelGetIteratorExceptionType"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19389,57 +33890,57 @@ private static class MagickComplexImages { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickComplexImages(MagickWand *, const ComplexOperator) + * extern ExceptionType PixelGetIteratorExceptionType(const PixelIterator *) * } */ - public static FunctionDescriptor MagickComplexImages$descriptor() { - return MagickComplexImages.DESC; + public static FunctionDescriptor PixelGetIteratorExceptionType$descriptor() { + return PixelGetIteratorExceptionType.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickComplexImages(MagickWand *, const ComplexOperator) + * extern ExceptionType PixelGetIteratorExceptionType(const PixelIterator *) * } */ - public static MethodHandle MagickComplexImages$handle() { - return MagickComplexImages.HANDLE; + public static MethodHandle PixelGetIteratorExceptionType$handle() { + return PixelGetIteratorExceptionType.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickComplexImages(MagickWand *, const ComplexOperator) + * extern ExceptionType PixelGetIteratorExceptionType(const PixelIterator *) * } */ - public static MemorySegment MagickComplexImages$address() { - return MagickComplexImages.ADDR; + public static MemorySegment PixelGetIteratorExceptionType$address() { + return PixelGetIteratorExceptionType.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickComplexImages(MagickWand *, const ComplexOperator) + * extern ExceptionType PixelGetIteratorExceptionType(const PixelIterator *) * } */ - public static MemorySegment MagickComplexImages(MemorySegment x0, int x1) { - var mh$ = MagickComplexImages.HANDLE; + public static int PixelGetIteratorExceptionType(MemorySegment x0) { + var mh$ = PixelGetIteratorExceptionType.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickComplexImages", x0, x1); + traceDowncall("PixelGetIteratorExceptionType", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickDeconstructImages { + private static class IsPixelIterator { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickDeconstructImages"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("IsPixelIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19447,58 +33948,57 @@ private static class MagickDeconstructImages { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickDeconstructImages(MagickWand *) + * extern MagickBooleanType IsPixelIterator(const PixelIterator *) * } */ - public static FunctionDescriptor MagickDeconstructImages$descriptor() { - return MagickDeconstructImages.DESC; + public static FunctionDescriptor IsPixelIterator$descriptor() { + return IsPixelIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickDeconstructImages(MagickWand *) + * extern MagickBooleanType IsPixelIterator(const PixelIterator *) * } */ - public static MethodHandle MagickDeconstructImages$handle() { - return MagickDeconstructImages.HANDLE; + public static MethodHandle IsPixelIterator$handle() { + return IsPixelIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickDeconstructImages(MagickWand *) + * extern MagickBooleanType IsPixelIterator(const PixelIterator *) * } */ - public static MemorySegment MagickDeconstructImages$address() { - return MagickDeconstructImages.ADDR; + public static MemorySegment IsPixelIterator$address() { + return IsPixelIterator.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickDeconstructImages(MagickWand *) + * extern MagickBooleanType IsPixelIterator(const PixelIterator *) * } */ - public static MemorySegment MagickDeconstructImages(MemorySegment x0) { - var mh$ = MagickDeconstructImages.HANDLE; + public static int IsPixelIterator(MemorySegment x0) { + var mh$ = IsPixelIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickDeconstructImages", x0); + traceDowncall("IsPixelIterator", x0); } - return (MemorySegment)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickFxImage { + private static class PixelClearIteratorException { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickFxImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelClearIteratorException"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19506,57 +34006,58 @@ private static class MagickFxImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickFxImage(MagickWand *, const char *) + * extern MagickBooleanType PixelClearIteratorException(PixelIterator *) * } */ - public static FunctionDescriptor MagickFxImage$descriptor() { - return MagickFxImage.DESC; + public static FunctionDescriptor PixelClearIteratorException$descriptor() { + return PixelClearIteratorException.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickFxImage(MagickWand *, const char *) + * extern MagickBooleanType PixelClearIteratorException(PixelIterator *) * } */ - public static MethodHandle MagickFxImage$handle() { - return MagickFxImage.HANDLE; + public static MethodHandle PixelClearIteratorException$handle() { + return PixelClearIteratorException.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickFxImage(MagickWand *, const char *) + * extern MagickBooleanType PixelClearIteratorException(PixelIterator *) * } */ - public static MemorySegment MagickFxImage$address() { - return MagickFxImage.ADDR; + public static MemorySegment PixelClearIteratorException$address() { + return PixelClearIteratorException.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickFxImage(MagickWand *, const char *) + * extern MagickBooleanType PixelClearIteratorException(PixelIterator *) * } */ - public static MemorySegment MagickFxImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickFxImage.HANDLE; + public static int PixelClearIteratorException(MemorySegment x0) { + var mh$ = PixelClearIteratorException.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickFxImage", x0, x1); + traceDowncall("PixelClearIteratorException", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImage { + private static class PixelSetIteratorRow { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelSetIteratorRow"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19564,58 +34065,57 @@ private static class MagickGetImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickGetImage(MagickWand *) + * extern MagickBooleanType PixelSetIteratorRow(PixelIterator *, const ssize_t) * } */ - public static FunctionDescriptor MagickGetImage$descriptor() { - return MagickGetImage.DESC; + public static FunctionDescriptor PixelSetIteratorRow$descriptor() { + return PixelSetIteratorRow.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickGetImage(MagickWand *) + * extern MagickBooleanType PixelSetIteratorRow(PixelIterator *, const ssize_t) * } */ - public static MethodHandle MagickGetImage$handle() { - return MagickGetImage.HANDLE; + public static MethodHandle PixelSetIteratorRow$handle() { + return PixelSetIteratorRow.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickGetImage(MagickWand *) + * extern MagickBooleanType PixelSetIteratorRow(PixelIterator *, const ssize_t) * } */ - public static MemorySegment MagickGetImage$address() { - return MagickGetImage.ADDR; + public static MemorySegment PixelSetIteratorRow$address() { + return PixelSetIteratorRow.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickGetImage(MagickWand *) + * extern MagickBooleanType PixelSetIteratorRow(PixelIterator *, const ssize_t) * } */ - public static MemorySegment MagickGetImage(MemorySegment x0) { - var mh$ = MagickGetImage.HANDLE; + public static int PixelSetIteratorRow(MemorySegment x0, long x1) { + var mh$ = PixelSetIteratorRow.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImage", x0); + traceDowncall("PixelSetIteratorRow", x0, x1); } - return (MemorySegment)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageMask { + private static class PixelSyncIterator { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_INT, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageMask"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelSyncIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19623,61 +34123,57 @@ private static class MagickGetImageMask { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickGetImageMask(MagickWand *, const PixelMask) + * extern MagickBooleanType PixelSyncIterator(PixelIterator *) * } */ - public static FunctionDescriptor MagickGetImageMask$descriptor() { - return MagickGetImageMask.DESC; + public static FunctionDescriptor PixelSyncIterator$descriptor() { + return PixelSyncIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickGetImageMask(MagickWand *, const PixelMask) + * extern MagickBooleanType PixelSyncIterator(PixelIterator *) * } */ - public static MethodHandle MagickGetImageMask$handle() { - return MagickGetImageMask.HANDLE; + public static MethodHandle PixelSyncIterator$handle() { + return PixelSyncIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickGetImageMask(MagickWand *, const PixelMask) + * extern MagickBooleanType PixelSyncIterator(PixelIterator *) * } */ - public static MemorySegment MagickGetImageMask$address() { - return MagickGetImageMask.ADDR; + public static MemorySegment PixelSyncIterator$address() { + return PixelSyncIterator.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickGetImageMask(MagickWand *, const PixelMask) + * extern MagickBooleanType PixelSyncIterator(PixelIterator *) * } */ - public static MemorySegment MagickGetImageMask(MemorySegment x0, int x1) { - var mh$ = MagickGetImageMask.HANDLE; + public static int PixelSyncIterator(MemorySegment x0) { + var mh$ = PixelSyncIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageMask", x0, x1); + traceDowncall("PixelSyncIterator", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageRegion { + private static class ClonePixelIterator { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageRegion"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ClonePixelIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19685,58 +34181,57 @@ private static class MagickGetImageRegion { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickGetImageRegion(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern PixelIterator *ClonePixelIterator(const PixelIterator *) * } */ - public static FunctionDescriptor MagickGetImageRegion$descriptor() { - return MagickGetImageRegion.DESC; + public static FunctionDescriptor ClonePixelIterator$descriptor() { + return ClonePixelIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickGetImageRegion(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern PixelIterator *ClonePixelIterator(const PixelIterator *) * } */ - public static MethodHandle MagickGetImageRegion$handle() { - return MagickGetImageRegion.HANDLE; + public static MethodHandle ClonePixelIterator$handle() { + return ClonePixelIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickGetImageRegion(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern PixelIterator *ClonePixelIterator(const PixelIterator *) * } */ - public static MemorySegment MagickGetImageRegion$address() { - return MagickGetImageRegion.ADDR; + public static MemorySegment ClonePixelIterator$address() { + return ClonePixelIterator.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickGetImageRegion(MagickWand *, const size_t, const size_t, const ssize_t, const ssize_t) + * extern PixelIterator *ClonePixelIterator(const PixelIterator *) * } */ - public static MemorySegment MagickGetImageRegion(MemorySegment x0, long x1, long x2, long x3, long x4) { - var mh$ = MagickGetImageRegion.HANDLE; + public static MemorySegment ClonePixelIterator(MemorySegment x0) { + var mh$ = ClonePixelIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageRegion", x0, x1, x2, x3, x4); + traceDowncall("ClonePixelIterator", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2, x3, x4); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickMergeImageLayers { + private static class DestroyPixelIterator { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMergeImageLayers"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DestroyPixelIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19744,58 +34239,57 @@ private static class MagickMergeImageLayers { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickMergeImageLayers(MagickWand *, const LayerMethod) + * extern PixelIterator *DestroyPixelIterator(PixelIterator *) * } */ - public static FunctionDescriptor MagickMergeImageLayers$descriptor() { - return MagickMergeImageLayers.DESC; + public static FunctionDescriptor DestroyPixelIterator$descriptor() { + return DestroyPixelIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickMergeImageLayers(MagickWand *, const LayerMethod) + * extern PixelIterator *DestroyPixelIterator(PixelIterator *) * } */ - public static MethodHandle MagickMergeImageLayers$handle() { - return MagickMergeImageLayers.HANDLE; + public static MethodHandle DestroyPixelIterator$handle() { + return DestroyPixelIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickMergeImageLayers(MagickWand *, const LayerMethod) + * extern PixelIterator *DestroyPixelIterator(PixelIterator *) * } */ - public static MemorySegment MagickMergeImageLayers$address() { - return MagickMergeImageLayers.ADDR; + public static MemorySegment DestroyPixelIterator$address() { + return DestroyPixelIterator.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickMergeImageLayers(MagickWand *, const LayerMethod) + * extern PixelIterator *DestroyPixelIterator(PixelIterator *) * } */ - public static MemorySegment MagickMergeImageLayers(MemorySegment x0, int x1) { - var mh$ = MagickMergeImageLayers.HANDLE; + public static MemorySegment DestroyPixelIterator(MemorySegment x0) { + var mh$ = DestroyPixelIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickMergeImageLayers", x0, x1); + traceDowncall("DestroyPixelIterator", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickMorphImages { + private static class NewPixelIterator { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMorphImages"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("NewPixelIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19803,62 +34297,61 @@ private static class MagickMorphImages { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickMorphImages(MagickWand *, const size_t) + * extern PixelIterator *NewPixelIterator(MagickWand *) * } */ - public static FunctionDescriptor MagickMorphImages$descriptor() { - return MagickMorphImages.DESC; + public static FunctionDescriptor NewPixelIterator$descriptor() { + return NewPixelIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickMorphImages(MagickWand *, const size_t) + * extern PixelIterator *NewPixelIterator(MagickWand *) * } */ - public static MethodHandle MagickMorphImages$handle() { - return MagickMorphImages.HANDLE; + public static MethodHandle NewPixelIterator$handle() { + return NewPixelIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickMorphImages(MagickWand *, const size_t) + * extern PixelIterator *NewPixelIterator(MagickWand *) * } */ - public static MemorySegment MagickMorphImages$address() { - return MagickMorphImages.ADDR; + public static MemorySegment NewPixelIterator$address() { + return NewPixelIterator.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickMorphImages(MagickWand *, const size_t) + * extern PixelIterator *NewPixelIterator(MagickWand *) * } */ - public static MemorySegment MagickMorphImages(MemorySegment x0, long x1) { - var mh$ = MagickMorphImages.HANDLE; + public static MemorySegment NewPixelIterator(MemorySegment x0) { + var mh$ = NewPixelIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickMorphImages", x0, x1); + traceDowncall("NewPixelIterator", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickMontageImage { + private static class NewPixelRegionIterator { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_POINTER + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickMontageImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("NewPixelRegionIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19866,57 +34359,58 @@ private static class MagickMontageImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickMontageImage(MagickWand *, const DrawingWand *, const char *, const char *, const MontageMode, const char *) + * extern PixelIterator *NewPixelRegionIterator(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t) * } */ - public static FunctionDescriptor MagickMontageImage$descriptor() { - return MagickMontageImage.DESC; + public static FunctionDescriptor NewPixelRegionIterator$descriptor() { + return NewPixelRegionIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickMontageImage(MagickWand *, const DrawingWand *, const char *, const char *, const MontageMode, const char *) + * extern PixelIterator *NewPixelRegionIterator(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t) * } */ - public static MethodHandle MagickMontageImage$handle() { - return MagickMontageImage.HANDLE; + public static MethodHandle NewPixelRegionIterator$handle() { + return NewPixelRegionIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickMontageImage(MagickWand *, const DrawingWand *, const char *, const char *, const MontageMode, const char *) + * extern PixelIterator *NewPixelRegionIterator(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t) * } */ - public static MemorySegment MagickMontageImage$address() { - return MagickMontageImage.ADDR; + public static MemorySegment NewPixelRegionIterator$address() { + return NewPixelRegionIterator.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickMontageImage(MagickWand *, const DrawingWand *, const char *, const char *, const MontageMode, const char *) + * extern PixelIterator *NewPixelRegionIterator(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t) * } */ - public static MemorySegment MagickMontageImage(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3, int x4, MemorySegment x5) { - var mh$ = MagickMontageImage.HANDLE; + public static MemorySegment NewPixelRegionIterator(MemorySegment x0, long x1, long x2, long x3, long x4) { + var mh$ = NewPixelRegionIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickMontageImage", x0, x1, x2, x3, x4, x5); + traceDowncall("NewPixelRegionIterator", x0, x1, x2, x3, x4); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2, x3, x4, x5); + return (MemorySegment)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickOptimizeImageLayers { + private static class PixelGetCurrentIteratorRow { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickOptimizeImageLayers"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelGetCurrentIteratorRow"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19924,58 +34418,58 @@ private static class MagickOptimizeImageLayers { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickOptimizeImageLayers(MagickWand *) + * extern PixelWand **PixelGetCurrentIteratorRow(PixelIterator *, size_t *) * } */ - public static FunctionDescriptor MagickOptimizeImageLayers$descriptor() { - return MagickOptimizeImageLayers.DESC; + public static FunctionDescriptor PixelGetCurrentIteratorRow$descriptor() { + return PixelGetCurrentIteratorRow.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickOptimizeImageLayers(MagickWand *) + * extern PixelWand **PixelGetCurrentIteratorRow(PixelIterator *, size_t *) * } */ - public static MethodHandle MagickOptimizeImageLayers$handle() { - return MagickOptimizeImageLayers.HANDLE; + public static MethodHandle PixelGetCurrentIteratorRow$handle() { + return PixelGetCurrentIteratorRow.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickOptimizeImageLayers(MagickWand *) + * extern PixelWand **PixelGetCurrentIteratorRow(PixelIterator *, size_t *) * } */ - public static MemorySegment MagickOptimizeImageLayers$address() { - return MagickOptimizeImageLayers.ADDR; + public static MemorySegment PixelGetCurrentIteratorRow$address() { + return PixelGetCurrentIteratorRow.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickOptimizeImageLayers(MagickWand *) + * extern PixelWand **PixelGetCurrentIteratorRow(PixelIterator *, size_t *) * } */ - public static MemorySegment MagickOptimizeImageLayers(MemorySegment x0) { - var mh$ = MagickOptimizeImageLayers.HANDLE; + public static MemorySegment PixelGetCurrentIteratorRow(MemorySegment x0, MemorySegment x1) { + var mh$ = PixelGetCurrentIteratorRow.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickOptimizeImageLayers", x0); + traceDowncall("PixelGetCurrentIteratorRow", x0, x1); } - return (MemorySegment)mh$.invokeExact(x0); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickPreviewImages { + private static class PixelGetNextIteratorRow { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickPreviewImages"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelGetNextIteratorRow"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -19983,62 +34477,58 @@ private static class MagickPreviewImages { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickPreviewImages(MagickWand *wand, const PreviewType) + * extern PixelWand **PixelGetNextIteratorRow(PixelIterator *, size_t *) * } */ - public static FunctionDescriptor MagickPreviewImages$descriptor() { - return MagickPreviewImages.DESC; + public static FunctionDescriptor PixelGetNextIteratorRow$descriptor() { + return PixelGetNextIteratorRow.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickPreviewImages(MagickWand *wand, const PreviewType) + * extern PixelWand **PixelGetNextIteratorRow(PixelIterator *, size_t *) * } */ - public static MethodHandle MagickPreviewImages$handle() { - return MagickPreviewImages.HANDLE; + public static MethodHandle PixelGetNextIteratorRow$handle() { + return PixelGetNextIteratorRow.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickPreviewImages(MagickWand *wand, const PreviewType) + * extern PixelWand **PixelGetNextIteratorRow(PixelIterator *, size_t *) * } */ - public static MemorySegment MagickPreviewImages$address() { - return MagickPreviewImages.ADDR; + public static MemorySegment PixelGetNextIteratorRow$address() { + return PixelGetNextIteratorRow.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickPreviewImages(MagickWand *wand, const PreviewType) + * extern PixelWand **PixelGetNextIteratorRow(PixelIterator *, size_t *) * } */ - public static MemorySegment MagickPreviewImages(MemorySegment wand, int x1) { - var mh$ = MagickPreviewImages.HANDLE; + public static MemorySegment PixelGetNextIteratorRow(MemorySegment x0, MemorySegment x1) { + var mh$ = PixelGetNextIteratorRow.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickPreviewImages", wand, x1); + traceDowncall("PixelGetNextIteratorRow", x0, x1); } - return (MemorySegment)mh$.invokeExact(wand, x1); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSimilarityImage { + private static class PixelGetPreviousIteratorRow { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_DOUBLE, - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSimilarityImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelGetPreviousIteratorRow"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20046,59 +34536,57 @@ private static class MagickSimilarityImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickSimilarityImage(MagickWand *, const MagickWand *, const MetricType, const double, RectangleInfo *, double *) + * extern PixelWand **PixelGetPreviousIteratorRow(PixelIterator *, size_t *) * } */ - public static FunctionDescriptor MagickSimilarityImage$descriptor() { - return MagickSimilarityImage.DESC; + public static FunctionDescriptor PixelGetPreviousIteratorRow$descriptor() { + return PixelGetPreviousIteratorRow.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickSimilarityImage(MagickWand *, const MagickWand *, const MetricType, const double, RectangleInfo *, double *) + * extern PixelWand **PixelGetPreviousIteratorRow(PixelIterator *, size_t *) * } */ - public static MethodHandle MagickSimilarityImage$handle() { - return MagickSimilarityImage.HANDLE; + public static MethodHandle PixelGetPreviousIteratorRow$handle() { + return PixelGetPreviousIteratorRow.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickSimilarityImage(MagickWand *, const MagickWand *, const MetricType, const double, RectangleInfo *, double *) + * extern PixelWand **PixelGetPreviousIteratorRow(PixelIterator *, size_t *) * } */ - public static MemorySegment MagickSimilarityImage$address() { - return MagickSimilarityImage.ADDR; + public static MemorySegment PixelGetPreviousIteratorRow$address() { + return PixelGetPreviousIteratorRow.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickSimilarityImage(MagickWand *, const MagickWand *, const MetricType, const double, RectangleInfo *, double *) + * extern PixelWand **PixelGetPreviousIteratorRow(PixelIterator *, size_t *) * } */ - public static MemorySegment MagickSimilarityImage(MemorySegment x0, MemorySegment x1, int x2, double x3, MemorySegment x4, MemorySegment x5) { - var mh$ = MagickSimilarityImage.HANDLE; + public static MemorySegment PixelGetPreviousIteratorRow(MemorySegment x0, MemorySegment x1) { + var mh$ = PixelGetPreviousIteratorRow.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSimilarityImage", x0, x1, x2, x3, x4, x5); + traceDowncall("PixelGetPreviousIteratorRow", x0, x1); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2, x3, x4, x5); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSmushImages { + private static class PixelGetIteratorRow { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_INT, - MagickWand_h.C_LONG + MagickWand_h.C_LONG, + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSmushImages"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelGetIteratorRow"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20106,59 +34594,56 @@ private static class MagickSmushImages { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickSmushImages(MagickWand *, const MagickBooleanType, const ssize_t) + * extern ssize_t PixelGetIteratorRow(PixelIterator *) * } */ - public static FunctionDescriptor MagickSmushImages$descriptor() { - return MagickSmushImages.DESC; + public static FunctionDescriptor PixelGetIteratorRow$descriptor() { + return PixelGetIteratorRow.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickSmushImages(MagickWand *, const MagickBooleanType, const ssize_t) + * extern ssize_t PixelGetIteratorRow(PixelIterator *) * } */ - public static MethodHandle MagickSmushImages$handle() { - return MagickSmushImages.HANDLE; + public static MethodHandle PixelGetIteratorRow$handle() { + return PixelGetIteratorRow.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickSmushImages(MagickWand *, const MagickBooleanType, const ssize_t) + * extern ssize_t PixelGetIteratorRow(PixelIterator *) * } */ - public static MemorySegment MagickSmushImages$address() { - return MagickSmushImages.ADDR; + public static MemorySegment PixelGetIteratorRow$address() { + return PixelGetIteratorRow.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickSmushImages(MagickWand *, const MagickBooleanType, const ssize_t) + * extern ssize_t PixelGetIteratorRow(PixelIterator *) * } */ - public static MemorySegment MagickSmushImages(MemorySegment x0, int x1, long x2) { - var mh$ = MagickSmushImages.HANDLE; + public static long PixelGetIteratorRow(MemorySegment x0) { + var mh$ = PixelGetIteratorRow.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSmushImages", x0, x1, x2); + traceDowncall("PixelGetIteratorRow", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2); + return (long)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSteganoImage { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, - MagickWand_h.C_LONG + private static class ClearPixelIterator { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSteganoImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("ClearPixelIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20166,58 +34651,56 @@ private static class MagickSteganoImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickSteganoImage(MagickWand *, const MagickWand *, const ssize_t) + * extern void ClearPixelIterator(PixelIterator *) * } */ - public static FunctionDescriptor MagickSteganoImage$descriptor() { - return MagickSteganoImage.DESC; + public static FunctionDescriptor ClearPixelIterator$descriptor() { + return ClearPixelIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickSteganoImage(MagickWand *, const MagickWand *, const ssize_t) + * extern void ClearPixelIterator(PixelIterator *) * } */ - public static MethodHandle MagickSteganoImage$handle() { - return MagickSteganoImage.HANDLE; + public static MethodHandle ClearPixelIterator$handle() { + return ClearPixelIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickSteganoImage(MagickWand *, const MagickWand *, const ssize_t) + * extern void ClearPixelIterator(PixelIterator *) * } */ - public static MemorySegment MagickSteganoImage$address() { - return MagickSteganoImage.ADDR; + public static MemorySegment ClearPixelIterator$address() { + return ClearPixelIterator.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickSteganoImage(MagickWand *, const MagickWand *, const ssize_t) + * extern void ClearPixelIterator(PixelIterator *) * } */ - public static MemorySegment MagickSteganoImage(MemorySegment x0, MemorySegment x1, long x2) { - var mh$ = MagickSteganoImage.HANDLE; + public static void ClearPixelIterator(MemorySegment x0) { + var mh$ = ClearPixelIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSteganoImage", x0, x1, x2); + traceDowncall("ClearPixelIterator", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1, x2); + mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickStereoImage { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, + private static class PixelResetIterator { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickStereoImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelResetIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20225,58 +34708,56 @@ private static class MagickStereoImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickStereoImage(MagickWand *, const MagickWand *) + * extern void PixelResetIterator(PixelIterator *) * } */ - public static FunctionDescriptor MagickStereoImage$descriptor() { - return MagickStereoImage.DESC; + public static FunctionDescriptor PixelResetIterator$descriptor() { + return PixelResetIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickStereoImage(MagickWand *, const MagickWand *) + * extern void PixelResetIterator(PixelIterator *) * } */ - public static MethodHandle MagickStereoImage$handle() { - return MagickStereoImage.HANDLE; + public static MethodHandle PixelResetIterator$handle() { + return PixelResetIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickStereoImage(MagickWand *, const MagickWand *) + * extern void PixelResetIterator(PixelIterator *) * } */ - public static MemorySegment MagickStereoImage$address() { - return MagickStereoImage.ADDR; + public static MemorySegment PixelResetIterator$address() { + return PixelResetIterator.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickStereoImage(MagickWand *, const MagickWand *) + * extern void PixelResetIterator(PixelIterator *) * } */ - public static MemorySegment MagickStereoImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickStereoImage.HANDLE; + public static void PixelResetIterator(MemorySegment x0) { + var mh$ = PixelResetIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickStereoImage", x0, x1); + traceDowncall("PixelResetIterator", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1); + mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickTextureImage { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, - MagickWand_h.C_POINTER, + private static class PixelSetFirstIteratorRow { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickTextureImage"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelSetFirstIteratorRow"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20284,57 +34765,56 @@ private static class MagickTextureImage { /** * Function descriptor for: * {@snippet lang=c : - * extern MagickWand *MagickTextureImage(MagickWand *, const MagickWand *) + * extern void PixelSetFirstIteratorRow(PixelIterator *) * } */ - public static FunctionDescriptor MagickTextureImage$descriptor() { - return MagickTextureImage.DESC; + public static FunctionDescriptor PixelSetFirstIteratorRow$descriptor() { + return PixelSetFirstIteratorRow.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern MagickWand *MagickTextureImage(MagickWand *, const MagickWand *) + * extern void PixelSetFirstIteratorRow(PixelIterator *) * } */ - public static MethodHandle MagickTextureImage$handle() { - return MagickTextureImage.HANDLE; + public static MethodHandle PixelSetFirstIteratorRow$handle() { + return PixelSetFirstIteratorRow.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern MagickWand *MagickTextureImage(MagickWand *, const MagickWand *) + * extern void PixelSetFirstIteratorRow(PixelIterator *) * } */ - public static MemorySegment MagickTextureImage$address() { - return MagickTextureImage.ADDR; + public static MemorySegment PixelSetFirstIteratorRow$address() { + return PixelSetFirstIteratorRow.ADDR; } /** * {@snippet lang=c : - * extern MagickWand *MagickTextureImage(MagickWand *, const MagickWand *) + * extern void PixelSetFirstIteratorRow(PixelIterator *) * } */ - public static MemorySegment MagickTextureImage(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickTextureImage.HANDLE; + public static void PixelSetFirstIteratorRow(MemorySegment x0) { + var mh$ = PixelSetFirstIteratorRow.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickTextureImage", x0, x1); + traceDowncall("PixelSetFirstIteratorRow", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1); + mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageOrientation { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + private static class PixelSetLastIteratorRow { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageOrientation"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("PixelSetLastIteratorRow"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20342,58 +34822,61 @@ private static class MagickGetImageOrientation { /** * Function descriptor for: * {@snippet lang=c : - * extern OrientationType MagickGetImageOrientation(MagickWand *) + * extern void PixelSetLastIteratorRow(PixelIterator *) * } */ - public static FunctionDescriptor MagickGetImageOrientation$descriptor() { - return MagickGetImageOrientation.DESC; + public static FunctionDescriptor PixelSetLastIteratorRow$descriptor() { + return PixelSetLastIteratorRow.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern OrientationType MagickGetImageOrientation(MagickWand *) + * extern void PixelSetLastIteratorRow(PixelIterator *) * } */ - public static MethodHandle MagickGetImageOrientation$handle() { - return MagickGetImageOrientation.HANDLE; + public static MethodHandle PixelSetLastIteratorRow$handle() { + return PixelSetLastIteratorRow.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern OrientationType MagickGetImageOrientation(MagickWand *) + * extern void PixelSetLastIteratorRow(PixelIterator *) * } */ - public static MemorySegment MagickGetImageOrientation$address() { - return MagickGetImageOrientation.ADDR; + public static MemorySegment PixelSetLastIteratorRow$address() { + return PixelSetLastIteratorRow.ADDR; } /** * {@snippet lang=c : - * extern OrientationType MagickGetImageOrientation(MagickWand *) + * extern void PixelSetLastIteratorRow(PixelIterator *) * } */ - public static int MagickGetImageOrientation(MemorySegment x0) { - var mh$ = MagickGetImageOrientation.HANDLE; + public static void PixelSetLastIteratorRow(MemorySegment x0) { + var mh$ = PixelSetLastIteratorRow.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageOrientation", x0); + traceDowncall("PixelSetLastIteratorRow", x0); } - return (int)mh$.invokeExact(x0); + mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageHistogram { + private static class StreamImageCommand { public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_INT, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageHistogram"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("StreamImageCommand"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20401,57 +34884,58 @@ private static class MagickGetImageHistogram { /** * Function descriptor for: * {@snippet lang=c : - * extern PixelWand **MagickGetImageHistogram(MagickWand *, size_t *) + * extern MagickBooleanType StreamImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) * } */ - public static FunctionDescriptor MagickGetImageHistogram$descriptor() { - return MagickGetImageHistogram.DESC; + public static FunctionDescriptor StreamImageCommand$descriptor() { + return StreamImageCommand.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern PixelWand **MagickGetImageHistogram(MagickWand *, size_t *) + * extern MagickBooleanType StreamImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) * } */ - public static MethodHandle MagickGetImageHistogram$handle() { - return MagickGetImageHistogram.HANDLE; + public static MethodHandle StreamImageCommand$handle() { + return StreamImageCommand.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern PixelWand **MagickGetImageHistogram(MagickWand *, size_t *) + * extern MagickBooleanType StreamImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) * } */ - public static MemorySegment MagickGetImageHistogram$address() { - return MagickGetImageHistogram.ADDR; + public static MemorySegment StreamImageCommand$address() { + return StreamImageCommand.ADDR; } /** * {@snippet lang=c : - * extern PixelWand **MagickGetImageHistogram(MagickWand *, size_t *) + * extern MagickBooleanType StreamImageCommand(ImageInfo *, int, char **, char **, ExceptionInfo *) * } */ - public static MemorySegment MagickGetImageHistogram(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickGetImageHistogram.HANDLE; + public static int StreamImageCommand(MemorySegment x0, int x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = StreamImageCommand.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageHistogram", x0, x1); + traceDowncall("StreamImageCommand", x0, x1, x2, x3, x4); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageRenderingIntent { + private static class GetWandViewException { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageRenderingIntent"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetWandViewException"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20459,57 +34943,61 @@ private static class MagickGetImageRenderingIntent { /** * Function descriptor for: * {@snippet lang=c : - * extern RenderingIntent MagickGetImageRenderingIntent(MagickWand *) + * extern char *GetWandViewException(const WandView *, ExceptionType *) * } */ - public static FunctionDescriptor MagickGetImageRenderingIntent$descriptor() { - return MagickGetImageRenderingIntent.DESC; + public static FunctionDescriptor GetWandViewException$descriptor() { + return GetWandViewException.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern RenderingIntent MagickGetImageRenderingIntent(MagickWand *) + * extern char *GetWandViewException(const WandView *, ExceptionType *) * } */ - public static MethodHandle MagickGetImageRenderingIntent$handle() { - return MagickGetImageRenderingIntent.HANDLE; + public static MethodHandle GetWandViewException$handle() { + return GetWandViewException.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern RenderingIntent MagickGetImageRenderingIntent(MagickWand *) + * extern char *GetWandViewException(const WandView *, ExceptionType *) * } */ - public static MemorySegment MagickGetImageRenderingIntent$address() { - return MagickGetImageRenderingIntent.ADDR; + public static MemorySegment GetWandViewException$address() { + return GetWandViewException.ADDR; } /** * {@snippet lang=c : - * extern RenderingIntent MagickGetImageRenderingIntent(MagickWand *) + * extern char *GetWandViewException(const WandView *, ExceptionType *) * } */ - public static int MagickGetImageRenderingIntent(MemorySegment x0) { - var mh$ = MagickGetImageRenderingIntent.HANDLE; + public static MemorySegment GetWandViewException(MemorySegment x0, MemorySegment x1) { + var mh$ = GetWandViewException.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageRenderingIntent", x0); + traceDowncall("GetWandViewException", x0, x1); } - return (int)mh$.invokeExact(x0); + return (MemorySegment)mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageUnits { + private static class DuplexTransferWandViewIterator { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageUnits"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DuplexTransferWandViewIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20517,57 +35005,59 @@ private static class MagickGetImageUnits { /** * Function descriptor for: * {@snippet lang=c : - * extern ResolutionType MagickGetImageUnits(MagickWand *) + * extern MagickBooleanType DuplexTransferWandViewIterator(WandView *, WandView *, WandView *, DuplexTransferWandViewMethod, void *) * } */ - public static FunctionDescriptor MagickGetImageUnits$descriptor() { - return MagickGetImageUnits.DESC; + public static FunctionDescriptor DuplexTransferWandViewIterator$descriptor() { + return DuplexTransferWandViewIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern ResolutionType MagickGetImageUnits(MagickWand *) + * extern MagickBooleanType DuplexTransferWandViewIterator(WandView *, WandView *, WandView *, DuplexTransferWandViewMethod, void *) * } */ - public static MethodHandle MagickGetImageUnits$handle() { - return MagickGetImageUnits.HANDLE; + public static MethodHandle DuplexTransferWandViewIterator$handle() { + return DuplexTransferWandViewIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern ResolutionType MagickGetImageUnits(MagickWand *) + * extern MagickBooleanType DuplexTransferWandViewIterator(WandView *, WandView *, WandView *, DuplexTransferWandViewMethod, void *) * } */ - public static MemorySegment MagickGetImageUnits$address() { - return MagickGetImageUnits.ADDR; + public static MemorySegment DuplexTransferWandViewIterator$address() { + return DuplexTransferWandViewIterator.ADDR; } /** * {@snippet lang=c : - * extern ResolutionType MagickGetImageUnits(MagickWand *) + * extern MagickBooleanType DuplexTransferWandViewIterator(WandView *, WandView *, WandView *, DuplexTransferWandViewMethod, void *) * } */ - public static int MagickGetImageUnits(MemorySegment x0) { - var mh$ = MagickGetImageUnits.HANDLE; + public static int DuplexTransferWandViewIterator(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3, MemorySegment x4) { + var mh$ = DuplexTransferWandViewIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageUnits", x0); + traceDowncall("DuplexTransferWandViewIterator", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageColors { + private static class GetWandViewIterator { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageColors"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetWandViewIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20575,57 +35065,57 @@ private static class MagickGetImageColors { /** * Function descriptor for: * {@snippet lang=c : - * extern size_t MagickGetImageColors(MagickWand *) + * extern MagickBooleanType GetWandViewIterator(WandView *, GetWandViewMethod, void *) * } */ - public static FunctionDescriptor MagickGetImageColors$descriptor() { - return MagickGetImageColors.DESC; + public static FunctionDescriptor GetWandViewIterator$descriptor() { + return GetWandViewIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern size_t MagickGetImageColors(MagickWand *) + * extern MagickBooleanType GetWandViewIterator(WandView *, GetWandViewMethod, void *) * } */ - public static MethodHandle MagickGetImageColors$handle() { - return MagickGetImageColors.HANDLE; + public static MethodHandle GetWandViewIterator$handle() { + return GetWandViewIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern size_t MagickGetImageColors(MagickWand *) + * extern MagickBooleanType GetWandViewIterator(WandView *, GetWandViewMethod, void *) * } */ - public static MemorySegment MagickGetImageColors$address() { - return MagickGetImageColors.ADDR; + public static MemorySegment GetWandViewIterator$address() { + return GetWandViewIterator.ADDR; } /** * {@snippet lang=c : - * extern size_t MagickGetImageColors(MagickWand *) + * extern MagickBooleanType GetWandViewIterator(WandView *, GetWandViewMethod, void *) * } */ - public static long MagickGetImageColors(MemorySegment x0) { - var mh$ = MagickGetImageColors.HANDLE; + public static int GetWandViewIterator(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = GetWandViewIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageColors", x0); + traceDowncall("GetWandViewIterator", x0, x1, x2); } - return (long)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageCompressionQuality { + private static class IsWandView { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_LONG, + MagickWand_h.C_INT, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageCompressionQuality"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("IsWandView"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20633,57 +35123,59 @@ private static class MagickGetImageCompressionQuality { /** * Function descriptor for: * {@snippet lang=c : - * extern size_t MagickGetImageCompressionQuality(MagickWand *) + * extern MagickBooleanType IsWandView(const WandView *) * } */ - public static FunctionDescriptor MagickGetImageCompressionQuality$descriptor() { - return MagickGetImageCompressionQuality.DESC; + public static FunctionDescriptor IsWandView$descriptor() { + return IsWandView.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern size_t MagickGetImageCompressionQuality(MagickWand *) + * extern MagickBooleanType IsWandView(const WandView *) * } */ - public static MethodHandle MagickGetImageCompressionQuality$handle() { - return MagickGetImageCompressionQuality.HANDLE; + public static MethodHandle IsWandView$handle() { + return IsWandView.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern size_t MagickGetImageCompressionQuality(MagickWand *) + * extern MagickBooleanType IsWandView(const WandView *) * } */ - public static MemorySegment MagickGetImageCompressionQuality$address() { - return MagickGetImageCompressionQuality.ADDR; + public static MemorySegment IsWandView$address() { + return IsWandView.ADDR; } /** * {@snippet lang=c : - * extern size_t MagickGetImageCompressionQuality(MagickWand *) + * extern MagickBooleanType IsWandView(const WandView *) * } */ - public static long MagickGetImageCompressionQuality(MemorySegment x0) { - var mh$ = MagickGetImageCompressionQuality.HANDLE; + public static int IsWandView(MemorySegment x0) { + var mh$ = IsWandView.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageCompressionQuality", x0); + traceDowncall("IsWandView", x0); } - return (long)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageDelay { + private static class SetWandViewIterator { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageDelay"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("SetWandViewIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20691,57 +35183,60 @@ private static class MagickGetImageDelay { /** * Function descriptor for: * {@snippet lang=c : - * extern size_t MagickGetImageDelay(MagickWand *) + * extern MagickBooleanType SetWandViewIterator(WandView *, SetWandViewMethod, void *) * } */ - public static FunctionDescriptor MagickGetImageDelay$descriptor() { - return MagickGetImageDelay.DESC; + public static FunctionDescriptor SetWandViewIterator$descriptor() { + return SetWandViewIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern size_t MagickGetImageDelay(MagickWand *) + * extern MagickBooleanType SetWandViewIterator(WandView *, SetWandViewMethod, void *) * } */ - public static MethodHandle MagickGetImageDelay$handle() { - return MagickGetImageDelay.HANDLE; + public static MethodHandle SetWandViewIterator$handle() { + return SetWandViewIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern size_t MagickGetImageDelay(MagickWand *) + * extern MagickBooleanType SetWandViewIterator(WandView *, SetWandViewMethod, void *) * } */ - public static MemorySegment MagickGetImageDelay$address() { - return MagickGetImageDelay.ADDR; + public static MemorySegment SetWandViewIterator$address() { + return SetWandViewIterator.ADDR; } /** * {@snippet lang=c : - * extern size_t MagickGetImageDelay(MagickWand *) + * extern MagickBooleanType SetWandViewIterator(WandView *, SetWandViewMethod, void *) * } */ - public static long MagickGetImageDelay(MemorySegment x0) { - var mh$ = MagickGetImageDelay.HANDLE; + public static int SetWandViewIterator(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = SetWandViewIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageDelay", x0); + traceDowncall("SetWandViewIterator", x0, x1, x2); } - return (long)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageDepth { + private static class TransferWandViewIterator { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageDepth"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("TransferWandViewIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20749,57 +35244,59 @@ private static class MagickGetImageDepth { /** * Function descriptor for: * {@snippet lang=c : - * extern size_t MagickGetImageDepth(MagickWand *) + * extern MagickBooleanType TransferWandViewIterator(WandView *, WandView *, TransferWandViewMethod, void *) * } */ - public static FunctionDescriptor MagickGetImageDepth$descriptor() { - return MagickGetImageDepth.DESC; + public static FunctionDescriptor TransferWandViewIterator$descriptor() { + return TransferWandViewIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern size_t MagickGetImageDepth(MagickWand *) + * extern MagickBooleanType TransferWandViewIterator(WandView *, WandView *, TransferWandViewMethod, void *) * } */ - public static MethodHandle MagickGetImageDepth$handle() { - return MagickGetImageDepth.HANDLE; + public static MethodHandle TransferWandViewIterator$handle() { + return TransferWandViewIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern size_t MagickGetImageDepth(MagickWand *) + * extern MagickBooleanType TransferWandViewIterator(WandView *, WandView *, TransferWandViewMethod, void *) * } */ - public static MemorySegment MagickGetImageDepth$address() { - return MagickGetImageDepth.ADDR; + public static MemorySegment TransferWandViewIterator$address() { + return TransferWandViewIterator.ADDR; } /** * {@snippet lang=c : - * extern size_t MagickGetImageDepth(MagickWand *) + * extern MagickBooleanType TransferWandViewIterator(WandView *, WandView *, TransferWandViewMethod, void *) * } */ - public static long MagickGetImageDepth(MemorySegment x0) { - var mh$ = MagickGetImageDepth.HANDLE; + public static int TransferWandViewIterator(MemorySegment x0, MemorySegment x1, MemorySegment x2, MemorySegment x3) { + var mh$ = TransferWandViewIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageDepth", x0); + traceDowncall("TransferWandViewIterator", x0, x1, x2, x3); } - return (long)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2, x3); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageHeight { + private static class UpdateWandViewIterator { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageHeight"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("UpdateWandViewIterator"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20807,57 +35304,57 @@ private static class MagickGetImageHeight { /** * Function descriptor for: * {@snippet lang=c : - * extern size_t MagickGetImageHeight(MagickWand *) + * extern MagickBooleanType UpdateWandViewIterator(WandView *, UpdateWandViewMethod, void *) * } */ - public static FunctionDescriptor MagickGetImageHeight$descriptor() { - return MagickGetImageHeight.DESC; + public static FunctionDescriptor UpdateWandViewIterator$descriptor() { + return UpdateWandViewIterator.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern size_t MagickGetImageHeight(MagickWand *) + * extern MagickBooleanType UpdateWandViewIterator(WandView *, UpdateWandViewMethod, void *) * } */ - public static MethodHandle MagickGetImageHeight$handle() { - return MagickGetImageHeight.HANDLE; + public static MethodHandle UpdateWandViewIterator$handle() { + return UpdateWandViewIterator.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern size_t MagickGetImageHeight(MagickWand *) + * extern MagickBooleanType UpdateWandViewIterator(WandView *, UpdateWandViewMethod, void *) * } */ - public static MemorySegment MagickGetImageHeight$address() { - return MagickGetImageHeight.ADDR; + public static MemorySegment UpdateWandViewIterator$address() { + return UpdateWandViewIterator.ADDR; } /** * {@snippet lang=c : - * extern size_t MagickGetImageHeight(MagickWand *) + * extern MagickBooleanType UpdateWandViewIterator(WandView *, UpdateWandViewMethod, void *) * } */ - public static long MagickGetImageHeight(MemorySegment x0) { - var mh$ = MagickGetImageHeight.HANDLE; + public static int UpdateWandViewIterator(MemorySegment x0, MemorySegment x1, MemorySegment x2) { + var mh$ = UpdateWandViewIterator.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageHeight", x0); + traceDowncall("UpdateWandViewIterator", x0, x1, x2); } - return (long)mh$.invokeExact(x0); + return (int)mh$.invokeExact(x0, x1, x2); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageIterations { + private static class GetWandViewWand { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_LONG, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageIterations"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetWandViewWand"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20865,57 +35362,57 @@ private static class MagickGetImageIterations { /** * Function descriptor for: * {@snippet lang=c : - * extern size_t MagickGetImageIterations(MagickWand *) + * extern MagickWand *GetWandViewWand(const WandView *) * } */ - public static FunctionDescriptor MagickGetImageIterations$descriptor() { - return MagickGetImageIterations.DESC; + public static FunctionDescriptor GetWandViewWand$descriptor() { + return GetWandViewWand.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern size_t MagickGetImageIterations(MagickWand *) + * extern MagickWand *GetWandViewWand(const WandView *) * } */ - public static MethodHandle MagickGetImageIterations$handle() { - return MagickGetImageIterations.HANDLE; + public static MethodHandle GetWandViewWand$handle() { + return GetWandViewWand.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern size_t MagickGetImageIterations(MagickWand *) + * extern MagickWand *GetWandViewWand(const WandView *) * } */ - public static MemorySegment MagickGetImageIterations$address() { - return MagickGetImageIterations.ADDR; + public static MemorySegment GetWandViewWand$address() { + return GetWandViewWand.ADDR; } /** * {@snippet lang=c : - * extern size_t MagickGetImageIterations(MagickWand *) + * extern MagickWand *GetWandViewWand(const WandView *) * } */ - public static long MagickGetImageIterations(MemorySegment x0) { - var mh$ = MagickGetImageIterations.HANDLE; + public static MemorySegment GetWandViewWand(MemorySegment x0) { + var mh$ = GetWandViewWand.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageIterations", x0); + traceDowncall("GetWandViewWand", x0); } - return (long)mh$.invokeExact(x0); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageScene { + private static class GetWandViewPixels { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_LONG, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageScene"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetWandViewPixels"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20923,57 +35420,57 @@ private static class MagickGetImageScene { /** * Function descriptor for: * {@snippet lang=c : - * extern size_t MagickGetImageScene(MagickWand *) + * extern PixelWand **GetWandViewPixels(const WandView *) * } */ - public static FunctionDescriptor MagickGetImageScene$descriptor() { - return MagickGetImageScene.DESC; + public static FunctionDescriptor GetWandViewPixels$descriptor() { + return GetWandViewPixels.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern size_t MagickGetImageScene(MagickWand *) + * extern PixelWand **GetWandViewPixels(const WandView *) * } */ - public static MethodHandle MagickGetImageScene$handle() { - return MagickGetImageScene.HANDLE; + public static MethodHandle GetWandViewPixels$handle() { + return GetWandViewPixels.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern size_t MagickGetImageScene(MagickWand *) + * extern PixelWand **GetWandViewPixels(const WandView *) * } */ - public static MemorySegment MagickGetImageScene$address() { - return MagickGetImageScene.ADDR; + public static MemorySegment GetWandViewPixels$address() { + return GetWandViewPixels.ADDR; } /** * {@snippet lang=c : - * extern size_t MagickGetImageScene(MagickWand *) + * extern PixelWand **GetWandViewPixels(const WandView *) * } */ - public static long MagickGetImageScene(MemorySegment x0) { - var mh$ = MagickGetImageScene.HANDLE; + public static MemorySegment GetWandViewPixels(MemorySegment x0) { + var mh$ = GetWandViewPixels.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageScene", x0); + traceDowncall("GetWandViewPixels", x0); } - return (long)mh$.invokeExact(x0); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageTicksPerSecond { + private static class GetWandViewExtent { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_LONG, + _RectangleInfo.layout(), MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageTicksPerSecond"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("GetWandViewExtent"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -20981,57 +35478,57 @@ private static class MagickGetImageTicksPerSecond { /** * Function descriptor for: * {@snippet lang=c : - * extern size_t MagickGetImageTicksPerSecond(MagickWand *) + * extern RectangleInfo GetWandViewExtent(const WandView *) * } */ - public static FunctionDescriptor MagickGetImageTicksPerSecond$descriptor() { - return MagickGetImageTicksPerSecond.DESC; + public static FunctionDescriptor GetWandViewExtent$descriptor() { + return GetWandViewExtent.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern size_t MagickGetImageTicksPerSecond(MagickWand *) + * extern RectangleInfo GetWandViewExtent(const WandView *) * } */ - public static MethodHandle MagickGetImageTicksPerSecond$handle() { - return MagickGetImageTicksPerSecond.HANDLE; + public static MethodHandle GetWandViewExtent$handle() { + return GetWandViewExtent.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern size_t MagickGetImageTicksPerSecond(MagickWand *) + * extern RectangleInfo GetWandViewExtent(const WandView *) * } */ - public static MemorySegment MagickGetImageTicksPerSecond$address() { - return MagickGetImageTicksPerSecond.ADDR; + public static MemorySegment GetWandViewExtent$address() { + return GetWandViewExtent.ADDR; } /** * {@snippet lang=c : - * extern size_t MagickGetImageTicksPerSecond(MagickWand *) + * extern RectangleInfo GetWandViewExtent(const WandView *) * } */ - public static long MagickGetImageTicksPerSecond(MemorySegment x0) { - var mh$ = MagickGetImageTicksPerSecond.HANDLE; + public static MemorySegment GetWandViewExtent(SegmentAllocator allocator, MemorySegment x0) { + var mh$ = GetWandViewExtent.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageTicksPerSecond", x0); + traceDowncall("GetWandViewExtent", allocator, x0); } - return (long)mh$.invokeExact(x0); + return (MemorySegment)mh$.invokeExact(allocator, x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageWidth { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_LONG, + private static class SetWandViewDescription { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageWidth"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("SetWandViewDescription"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -21039,57 +35536,57 @@ private static class MagickGetImageWidth { /** * Function descriptor for: * {@snippet lang=c : - * extern size_t MagickGetImageWidth(MagickWand *) + * extern void SetWandViewDescription(WandView *, const char *) * } */ - public static FunctionDescriptor MagickGetImageWidth$descriptor() { - return MagickGetImageWidth.DESC; + public static FunctionDescriptor SetWandViewDescription$descriptor() { + return SetWandViewDescription.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern size_t MagickGetImageWidth(MagickWand *) + * extern void SetWandViewDescription(WandView *, const char *) * } */ - public static MethodHandle MagickGetImageWidth$handle() { - return MagickGetImageWidth.HANDLE; + public static MethodHandle SetWandViewDescription$handle() { + return SetWandViewDescription.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern size_t MagickGetImageWidth(MagickWand *) + * extern void SetWandViewDescription(WandView *, const char *) * } */ - public static MemorySegment MagickGetImageWidth$address() { - return MagickGetImageWidth.ADDR; + public static MemorySegment SetWandViewDescription$address() { + return SetWandViewDescription.ADDR; } /** * {@snippet lang=c : - * extern size_t MagickGetImageWidth(MagickWand *) + * extern void SetWandViewDescription(WandView *, const char *) * } */ - public static long MagickGetImageWidth(MemorySegment x0) { - var mh$ = MagickGetImageWidth.HANDLE; + public static void SetWandViewDescription(MemorySegment x0, MemorySegment x1) { + var mh$ = SetWandViewDescription.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageWidth", x0); + traceDowncall("SetWandViewDescription", x0, x1); } - return (long)mh$.invokeExact(x0); + mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetNumberImages { - public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_LONG, - MagickWand_h.C_POINTER + private static class SetWandViewThreads { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetNumberImages"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("SetWandViewThreads"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -21097,58 +35594,57 @@ private static class MagickGetNumberImages { /** * Function descriptor for: * {@snippet lang=c : - * extern size_t MagickGetNumberImages(MagickWand *) + * extern void SetWandViewThreads(WandView *, const size_t) * } */ - public static FunctionDescriptor MagickGetNumberImages$descriptor() { - return MagickGetNumberImages.DESC; + public static FunctionDescriptor SetWandViewThreads$descriptor() { + return SetWandViewThreads.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern size_t MagickGetNumberImages(MagickWand *) + * extern void SetWandViewThreads(WandView *, const size_t) * } */ - public static MethodHandle MagickGetNumberImages$handle() { - return MagickGetNumberImages.HANDLE; + public static MethodHandle SetWandViewThreads$handle() { + return SetWandViewThreads.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern size_t MagickGetNumberImages(MagickWand *) + * extern void SetWandViewThreads(WandView *, const size_t) * } */ - public static MemorySegment MagickGetNumberImages$address() { - return MagickGetNumberImages.ADDR; + public static MemorySegment SetWandViewThreads$address() { + return SetWandViewThreads.ADDR; } /** * {@snippet lang=c : - * extern size_t MagickGetNumberImages(MagickWand *) + * extern void SetWandViewThreads(WandView *, const size_t) * } */ - public static long MagickGetNumberImages(MemorySegment x0) { - var mh$ = MagickGetNumberImages.HANDLE; + public static void SetWandViewThreads(MemorySegment x0, long x1) { + var mh$ = SetWandViewThreads.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetNumberImages", x0); + traceDowncall("SetWandViewThreads", x0, x1); } - return (long)mh$.invokeExact(x0); + mh$.invokeExact(x0, x1); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageBlob { + private static class CloneWandView { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageBlob"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("CloneWandView"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -21156,58 +35652,57 @@ private static class MagickGetImageBlob { /** * Function descriptor for: * {@snippet lang=c : - * extern unsigned char *MagickGetImageBlob(MagickWand *, size_t *) + * extern WandView *CloneWandView(const WandView *) * } */ - public static FunctionDescriptor MagickGetImageBlob$descriptor() { - return MagickGetImageBlob.DESC; + public static FunctionDescriptor CloneWandView$descriptor() { + return CloneWandView.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern unsigned char *MagickGetImageBlob(MagickWand *, size_t *) + * extern WandView *CloneWandView(const WandView *) * } */ - public static MethodHandle MagickGetImageBlob$handle() { - return MagickGetImageBlob.HANDLE; + public static MethodHandle CloneWandView$handle() { + return CloneWandView.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern unsigned char *MagickGetImageBlob(MagickWand *, size_t *) + * extern WandView *CloneWandView(const WandView *) * } */ - public static MemorySegment MagickGetImageBlob$address() { - return MagickGetImageBlob.ADDR; + public static MemorySegment CloneWandView$address() { + return CloneWandView.ADDR; } /** * {@snippet lang=c : - * extern unsigned char *MagickGetImageBlob(MagickWand *, size_t *) + * extern WandView *CloneWandView(const WandView *) * } */ - public static MemorySegment MagickGetImageBlob(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickGetImageBlob.HANDLE; + public static MemorySegment CloneWandView(MemorySegment x0) { + var mh$ = CloneWandView.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageBlob", x0, x1); + traceDowncall("CloneWandView", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImagesBlob { + private static class DestroyWandView { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_POINTER, MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImagesBlob"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("DestroyWandView"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -21215,57 +35710,57 @@ private static class MagickGetImagesBlob { /** * Function descriptor for: * {@snippet lang=c : - * extern unsigned char *MagickGetImagesBlob(MagickWand *, size_t *) + * extern WandView *DestroyWandView(WandView *) * } */ - public static FunctionDescriptor MagickGetImagesBlob$descriptor() { - return MagickGetImagesBlob.DESC; + public static FunctionDescriptor DestroyWandView$descriptor() { + return DestroyWandView.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern unsigned char *MagickGetImagesBlob(MagickWand *, size_t *) + * extern WandView *DestroyWandView(WandView *) * } */ - public static MethodHandle MagickGetImagesBlob$handle() { - return MagickGetImagesBlob.HANDLE; + public static MethodHandle DestroyWandView$handle() { + return DestroyWandView.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern unsigned char *MagickGetImagesBlob(MagickWand *, size_t *) + * extern WandView *DestroyWandView(WandView *) * } */ - public static MemorySegment MagickGetImagesBlob$address() { - return MagickGetImagesBlob.ADDR; + public static MemorySegment DestroyWandView$address() { + return DestroyWandView.ADDR; } /** * {@snippet lang=c : - * extern unsigned char *MagickGetImagesBlob(MagickWand *, size_t *) + * extern WandView *DestroyWandView(WandView *) * } */ - public static MemorySegment MagickGetImagesBlob(MemorySegment x0, MemorySegment x1) { - var mh$ = MagickGetImagesBlob.HANDLE; + public static MemorySegment DestroyWandView(MemorySegment x0) { + var mh$ = DestroyWandView.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImagesBlob", x0, x1); + traceDowncall("DestroyWandView", x0); } - return (MemorySegment)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickGetImageVirtualPixelMethod { + private static class NewWandView { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, + MagickWand_h.C_POINTER, MagickWand_h.C_POINTER ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickGetImageVirtualPixelMethod"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("NewWandView"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -21273,58 +35768,61 @@ private static class MagickGetImageVirtualPixelMethod { /** * Function descriptor for: * {@snippet lang=c : - * extern VirtualPixelMethod MagickGetImageVirtualPixelMethod(MagickWand *) + * extern WandView *NewWandView(MagickWand *) * } */ - public static FunctionDescriptor MagickGetImageVirtualPixelMethod$descriptor() { - return MagickGetImageVirtualPixelMethod.DESC; + public static FunctionDescriptor NewWandView$descriptor() { + return NewWandView.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern VirtualPixelMethod MagickGetImageVirtualPixelMethod(MagickWand *) + * extern WandView *NewWandView(MagickWand *) * } */ - public static MethodHandle MagickGetImageVirtualPixelMethod$handle() { - return MagickGetImageVirtualPixelMethod.HANDLE; + public static MethodHandle NewWandView$handle() { + return NewWandView.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern VirtualPixelMethod MagickGetImageVirtualPixelMethod(MagickWand *) + * extern WandView *NewWandView(MagickWand *) * } */ - public static MemorySegment MagickGetImageVirtualPixelMethod$address() { - return MagickGetImageVirtualPixelMethod.ADDR; + public static MemorySegment NewWandView$address() { + return NewWandView.ADDR; } /** * {@snippet lang=c : - * extern VirtualPixelMethod MagickGetImageVirtualPixelMethod(MagickWand *) + * extern WandView *NewWandView(MagickWand *) * } */ - public static int MagickGetImageVirtualPixelMethod(MemorySegment x0) { - var mh$ = MagickGetImageVirtualPixelMethod.HANDLE; + public static MemorySegment NewWandView(MemorySegment x0) { + var mh$ = NewWandView.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickGetImageVirtualPixelMethod", x0); + traceDowncall("NewWandView", x0); } - return (int)mh$.invokeExact(x0); + return (MemorySegment)mh$.invokeExact(x0); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } } - private static class MagickSetImageVirtualPixelMethod { + private static class NewWandViewExtent { public static final FunctionDescriptor DESC = FunctionDescriptor.of( - MagickWand_h.C_INT, MagickWand_h.C_POINTER, - MagickWand_h.C_INT + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG, + MagickWand_h.C_LONG ); - public static final MemorySegment ADDR = MagickWand_h.findOrThrow("MagickSetImageVirtualPixelMethod"); + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("NewWandViewExtent"); public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); } @@ -21332,45 +35830,45 @@ private static class MagickSetImageVirtualPixelMethod { /** * Function descriptor for: * {@snippet lang=c : - * extern VirtualPixelMethod MagickSetImageVirtualPixelMethod(MagickWand *, const VirtualPixelMethod) + * extern WandView *NewWandViewExtent(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t) * } */ - public static FunctionDescriptor MagickSetImageVirtualPixelMethod$descriptor() { - return MagickSetImageVirtualPixelMethod.DESC; + public static FunctionDescriptor NewWandViewExtent$descriptor() { + return NewWandViewExtent.DESC; } /** * Downcall method handle for: * {@snippet lang=c : - * extern VirtualPixelMethod MagickSetImageVirtualPixelMethod(MagickWand *, const VirtualPixelMethod) + * extern WandView *NewWandViewExtent(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t) * } */ - public static MethodHandle MagickSetImageVirtualPixelMethod$handle() { - return MagickSetImageVirtualPixelMethod.HANDLE; + public static MethodHandle NewWandViewExtent$handle() { + return NewWandViewExtent.HANDLE; } /** * Address for: * {@snippet lang=c : - * extern VirtualPixelMethod MagickSetImageVirtualPixelMethod(MagickWand *, const VirtualPixelMethod) + * extern WandView *NewWandViewExtent(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t) * } */ - public static MemorySegment MagickSetImageVirtualPixelMethod$address() { - return MagickSetImageVirtualPixelMethod.ADDR; + public static MemorySegment NewWandViewExtent$address() { + return NewWandViewExtent.ADDR; } /** * {@snippet lang=c : - * extern VirtualPixelMethod MagickSetImageVirtualPixelMethod(MagickWand *, const VirtualPixelMethod) + * extern WandView *NewWandViewExtent(MagickWand *, const ssize_t, const ssize_t, const size_t, const size_t) * } */ - public static int MagickSetImageVirtualPixelMethod(MemorySegment x0, int x1) { - var mh$ = MagickSetImageVirtualPixelMethod.HANDLE; + public static MemorySegment NewWandViewExtent(MemorySegment x0, long x1, long x2, long x3, long x4) { + var mh$ = NewWandViewExtent.HANDLE; try { if (TRACE_DOWNCALLS) { - traceDowncall("MagickSetImageVirtualPixelMethod", x0, x1); + traceDowncall("NewWandViewExtent", x0, x1, x2, x3, x4); } - return (int)mh$.invokeExact(x0, x1); + return (MemorySegment)mh$.invokeExact(x0, x1, x2, x3, x4); } catch (Throwable ex$) { throw new AssertionError("should not reach here", ex$); } @@ -21551,6 +36049,62 @@ public static int IsMagickWand(MemorySegment x0) { } } + private static class IsMagickWandInstantiated { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + MagickWand_h.C_INT ); + + public static final MemorySegment ADDR = MagickWand_h.findOrThrow("IsMagickWandInstantiated"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern MagickBooleanType IsMagickWandInstantiated() + * } + */ + public static FunctionDescriptor IsMagickWandInstantiated$descriptor() { + return IsMagickWandInstantiated.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern MagickBooleanType IsMagickWandInstantiated() + * } + */ + public static MethodHandle IsMagickWandInstantiated$handle() { + return IsMagickWandInstantiated.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern MagickBooleanType IsMagickWandInstantiated() + * } + */ + public static MemorySegment IsMagickWandInstantiated$address() { + return IsMagickWandInstantiated.ADDR; + } + + /** + * {@snippet lang=c : + * extern MagickBooleanType IsMagickWandInstantiated() + * } + */ + public static int IsMagickWandInstantiated() { + var mh$ = IsMagickWandInstantiated.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("IsMagickWandInstantiated"); + } + return (int)mh$.invokeExact(); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + private static class MagickClearException { public static final FunctionDescriptor DESC = FunctionDescriptor.of( MagickWand_h.C_INT, @@ -22351,5 +36905,350 @@ public static void MagickSetLastIterator(MemorySegment x0) { throw new AssertionError("should not reach here", ex$); } } + private static final long MagickWandSignature = 2880220587L; + /** + * {@snippet lang=c : + * #define MagickWandSignature 2880220587 + * } + */ + public static long MagickWandSignature() { + return MagickWandSignature; + } + private static final long MagickCoreSignature = 2880220587L; + /** + * {@snippet lang=c : + * #define MagickCoreSignature 2880220587 + * } + */ + public static long MagickCoreSignature() { + return MagickCoreSignature; + } + private static final double MagickEpsilon = 1.0E-12d; + /** + * {@snippet lang=c : + * #define MagickEpsilon 1.0E-12 + * } + */ + public static double MagickEpsilon() { + return MagickEpsilon; + } + private static final double MagickMaximumValue = 1.7976931348623157E308d; + /** + * {@snippet lang=c : + * #define MagickMaximumValue 1.7976931348623157E308 + * } + */ + public static double MagickMaximumValue() { + return MagickMaximumValue; + } + private static final double MagickMinimumValue = 2.2250738585072014E-308d; + /** + * {@snippet lang=c : + * #define MagickMinimumValue 2.2250738585072014E-308 + * } + */ + public static double MagickMinimumValue() { + return MagickMinimumValue; + } + /** + * {@snippet lang=c : + * #define MagickOffsetFormat "lld" + * } + */ + public static MemorySegment MagickOffsetFormat() { + class Holder { + static final MemorySegment MagickOffsetFormat + = MagickWand_h.LIBRARY_ARENA.allocateFrom("lld"); + } + return Holder.MagickOffsetFormat; + } + /** + * {@snippet lang=c : + * #define MagickSizeFormat "llu" + * } + */ + public static MemorySegment MagickSizeFormat() { + class Holder { + static final MemorySegment MagickSizeFormat + = MagickWand_h.LIBRARY_ARENA.allocateFrom("llu"); + } + return Holder.MagickSizeFormat; + } + private static final int BesselFilter = (int)13L; + /** + * {@snippet lang=c : + * #define BesselFilter 13 + * } + */ + public static int BesselFilter() { + return BesselFilter; + } + private static final int WelshFilter = (int)17L; + /** + * {@snippet lang=c : + * #define WelshFilter 17 + * } + */ + public static int WelshFilter() { + return WelshFilter; + } + private static final int HanningFilter = (int)5L; + /** + * {@snippet lang=c : + * #define HanningFilter 5 + * } + */ + public static int HanningFilter() { + return HanningFilter; + } + /** + * {@snippet lang=c : + * #define MagickLogFilename "log.xml" + * } + */ + public static MemorySegment MagickLogFilename() { + class Holder { + static final MemorySegment MagickLogFilename + = MagickWand_h.LIBRARY_ARENA.allocateFrom("log.xml"); + } + return Holder.MagickLogFilename; + } + /** + * {@snippet lang=c : + * #define MagickPackageName "ImageMagick" + * } + */ + public static MemorySegment MagickPackageName() { + class Holder { + static final MemorySegment MagickPackageName + = MagickWand_h.LIBRARY_ARENA.allocateFrom("ImageMagick"); + } + return Holder.MagickPackageName; + } + /** + * {@snippet lang=c : + * #define MagickCopyright "(C) 1999 ImageMagick Studio LLC" + * } + */ + public static MemorySegment MagickCopyright() { + class Holder { + static final MemorySegment MagickCopyright + = MagickWand_h.LIBRARY_ARENA.allocateFrom("(C) 1999 ImageMagick Studio LLC"); + } + return Holder.MagickCopyright; + } + /** + * {@snippet lang=c : + * #define MagickLibVersionText "7.1.1" + * } + */ + public static MemorySegment MagickLibVersionText() { + class Holder { + static final MemorySegment MagickLibVersionText + = MagickWand_h.LIBRARY_ARENA.allocateFrom("7.1.1"); + } + return Holder.MagickLibVersionText; + } + private static final int MagickLibVersionNumber = (int)10L; + /** + * {@snippet lang=c : + * #define MagickLibVersionNumber 10 + * } + */ + public static int MagickLibVersionNumber() { + return MagickLibVersionNumber; + } + /** + * {@snippet lang=c : + * #define MagickLibAddendum "-36" + * } + */ + public static MemorySegment MagickLibAddendum() { + class Holder { + static final MemorySegment MagickLibAddendum + = MagickWand_h.LIBRARY_ARENA.allocateFrom("-36"); + } + return Holder.MagickLibAddendum; + } + /** + * {@snippet lang=c : + * #define MagickPlatform "aarch64" + * } + */ + public static MemorySegment MagickPlatform() { + class Holder { + static final MemorySegment MagickPlatform + = MagickWand_h.LIBRARY_ARENA.allocateFrom("aarch64"); + } + return Holder.MagickPlatform; + } + /** + * {@snippet lang=c : + * #define MagickppLibVersionText "7.1.1" + * } + */ + public static MemorySegment MagickppLibVersionText() { + class Holder { + static final MemorySegment MagickppLibVersionText + = MagickWand_h.LIBRARY_ARENA.allocateFrom("7.1.1"); + } + return Holder.MagickppLibVersionText; + } + private static final int MagickppLibVersionNumber = (int)5L; + /** + * {@snippet lang=c : + * #define MagickppLibVersionNumber 5 + * } + */ + public static int MagickppLibVersionNumber() { + return MagickppLibVersionNumber; + } + /** + * {@snippet lang=c : + * #define MagickppLibAddendum "-36" + * } + */ + public static MemorySegment MagickppLibAddendum() { + class Holder { + static final MemorySegment MagickppLibAddendum + = MagickWand_h.LIBRARY_ARENA.allocateFrom("-36"); + } + return Holder.MagickppLibAddendum; + } + /** + * {@snippet lang=c : + * #define MagickGitRevision "22352" + * } + */ + public static MemorySegment MagickGitRevision() { + class Holder { + static final MemorySegment MagickGitRevision + = MagickWand_h.LIBRARY_ARENA.allocateFrom("22352"); + } + return Holder.MagickGitRevision; + } + /** + * {@snippet lang=c : + * #define MagickReleaseDate "2024-07-27" + * } + */ + public static MemorySegment MagickReleaseDate() { + class Holder { + static final MemorySegment MagickReleaseDate + = MagickWand_h.LIBRARY_ARENA.allocateFrom("2024-07-27"); + } + return Holder.MagickReleaseDate; + } + /** + * {@snippet lang=c : + * #define MagickAuthoritativeLicense "https://imagemagick.org/script/license.php" + * } + */ + public static MemorySegment MagickAuthoritativeLicense() { + class Holder { + static final MemorySegment MagickAuthoritativeLicense + = MagickWand_h.LIBRARY_ARENA.allocateFrom("https://imagemagick.org/script/license.php"); + } + return Holder.MagickAuthoritativeLicense; + } + /** + * {@snippet lang=c : + * #define MagickAuthoritativeURL "https://imagemagick.org" + * } + */ + public static MemorySegment MagickAuthoritativeURL() { + class Holder { + static final MemorySegment MagickAuthoritativeURL + = MagickWand_h.LIBRARY_ARENA.allocateFrom("https://imagemagick.org"); + } + return Holder.MagickAuthoritativeURL; + } + /** + * {@snippet lang=c : + * #define MagickHomeURL "file:///opt/homebrew/Cellar/imagemagick/7.1.1-36/share/doc/ImageMagick-7/index.html" + * } + */ + public static MemorySegment MagickHomeURL() { + class Holder { + static final MemorySegment MagickHomeURL + = MagickWand_h.LIBRARY_ARENA.allocateFrom("file:///opt/homebrew/Cellar/imagemagick/7.1.1-36/share/doc/ImageMagick-7/index.html"); + } + return Holder.MagickHomeURL; + } + /** + * {@snippet lang=c : + * #define MagickQuantumDepth "Q16" + * } + */ + public static MemorySegment MagickQuantumDepth() { + class Holder { + static final MemorySegment MagickQuantumDepth + = MagickWand_h.LIBRARY_ARENA.allocateFrom("Q16"); + } + return Holder.MagickQuantumDepth; + } + /** + * {@snippet lang=c : + * #define MagickQuantumRange "65535" + * } + */ + public static MemorySegment MagickQuantumRange() { + class Holder { + static final MemorySegment MagickQuantumRange + = MagickWand_h.LIBRARY_ARENA.allocateFrom("65535"); + } + return Holder.MagickQuantumRange; + } + /** + * {@snippet lang=c : + * #define MagickHDRISupport "-HDRI" + * } + */ + public static MemorySegment MagickHDRISupport() { + class Holder { + static final MemorySegment MagickHDRISupport + = MagickWand_h.LIBRARY_ARENA.allocateFrom("-HDRI"); + } + return Holder.MagickHDRISupport; + } + /** + * {@snippet lang=c : + * #define MagickVersion "ImageMagick 7.1.1-36 Q16-HDRI aarch64 22352 https://imagemagick.org" + * } + */ + public static MemorySegment MagickVersion() { + class Holder { + static final MemorySegment MagickVersion + = MagickWand_h.LIBRARY_ARENA.allocateFrom("ImageMagick 7.1.1-36 Q16-HDRI aarch64 22352 https://imagemagick.org"); + } + return Holder.MagickVersion; + } + private static final long MagickImageCoderSignature = 2576L; + /** + * {@snippet lang=c : + * #define MagickImageCoderSignature 2576 + * } + */ + public static long MagickImageCoderSignature() { + return MagickImageCoderSignature; + } + private static final long MagickImageFilterSignature = 2576L; + /** + * {@snippet lang=c : + * #define MagickImageFilterSignature 2576 + * } + */ + public static long MagickImageFilterSignature() { + return MagickImageFilterSignature; + } + private static final long MagickResourceInfinity = 9223372036854775807L; + /** + * {@snippet lang=c : + * #define MagickResourceInfinity 9223372036854775807 + * } + */ + public static long MagickResourceInfinity() { + return MagickResourceInfinity; + } } diff --git a/lib/src/main/java/app/photofox/imffm/generated/MontageInfo.java b/lib/src/main/java/app/photofox/imffm/generated/MontageInfo.java new file mode 100644 index 0000000..99b2a12 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/MontageInfo.java @@ -0,0 +1,46 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef struct _MontageInfo { + * char *geometry; + * char *tile; + * char *title; + * char *frame; + * char *texture; + * char *font; + * double pointsize; + * size_t border_width; + * MagickBooleanType shadow; + * PixelInfo alpha_color; + * PixelInfo background_color; + * PixelInfo border_color; + * PixelInfo fill; + * PixelInfo stroke; + * GravityType gravity; + * char filename[4096]; + * MagickBooleanType debug; + * size_t signature; + * PixelInfo matte_color; + * } MontageInfo + * } + */ +public class MontageInfo extends _MontageInfo { + + MontageInfo() { + // Should not be called directly + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/PixelInfo.java b/lib/src/main/java/app/photofox/imffm/generated/PixelInfo.java new file mode 100644 index 0000000..e2bcd6d --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/PixelInfo.java @@ -0,0 +1,39 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef struct _PixelInfo { + * ClassType storage_class; + * ColorspaceType colorspace; + * PixelTrait alpha_trait; + * double fuzz; + * size_t depth; + * MagickSizeType count; + * MagickRealType red; + * MagickRealType green; + * MagickRealType blue; + * MagickRealType black; + * MagickRealType alpha; + * MagickRealType index; + * } PixelInfo + * } + */ +public class PixelInfo extends _PixelInfo { + + PixelInfo() { + // Should not be called directly + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/RectangleInfo.java b/lib/src/main/java/app/photofox/imffm/generated/RectangleInfo.java new file mode 100644 index 0000000..ee0b30d --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/RectangleInfo.java @@ -0,0 +1,31 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef struct _RectangleInfo { + * size_t width; + * size_t height; + * ssize_t x; + * ssize_t y; + * } RectangleInfo + * } + */ +public class RectangleInfo extends _RectangleInfo { + + RectangleInfo() { + // Should not be called directly + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/SetWandViewMethod.java b/lib/src/main/java/app/photofox/imffm/generated/SetWandViewMethod.java new file mode 100644 index 0000000..b22b811 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/SetWandViewMethod.java @@ -0,0 +1,71 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef MagickBooleanType (*SetWandViewMethod)(WandView *, const ssize_t, const int, void *) + * } + */ +public class SetWandViewMethod { + + SetWandViewMethod() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + int apply(MemorySegment _x0, long _x1, int _x2, MemorySegment _x3); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = MagickWand_h.upcallHandle(SetWandViewMethod.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(SetWandViewMethod.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static int invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1, int _x2, MemorySegment _x3) { + try { + return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/TransferWandViewMethod.java b/lib/src/main/java/app/photofox/imffm/generated/TransferWandViewMethod.java new file mode 100644 index 0000000..63b38a9 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/TransferWandViewMethod.java @@ -0,0 +1,72 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef MagickBooleanType (*TransferWandViewMethod)(const WandView *, WandView *, const ssize_t, const int, void *) + * } + */ +public class TransferWandViewMethod { + + TransferWandViewMethod() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + int apply(MemorySegment _x0, MemorySegment _x1, long _x2, int _x3, MemorySegment _x4); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = MagickWand_h.upcallHandle(TransferWandViewMethod.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(TransferWandViewMethod.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static int invoke(MemorySegment funcPtr,MemorySegment _x0, MemorySegment _x1, long _x2, int _x3, MemorySegment _x4) { + try { + return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/UpdateWandViewMethod.java b/lib/src/main/java/app/photofox/imffm/generated/UpdateWandViewMethod.java new file mode 100644 index 0000000..b131d38 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/UpdateWandViewMethod.java @@ -0,0 +1,71 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef MagickBooleanType (*UpdateWandViewMethod)(WandView *, const ssize_t, const int, void *) + * } + */ +public class UpdateWandViewMethod { + + UpdateWandViewMethod() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + int apply(MemorySegment _x0, long _x1, int _x2, MemorySegment _x3); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + MagickWand_h.C_INT, + MagickWand_h.C_POINTER, + MagickWand_h.C_LONG, + MagickWand_h.C_INT, + MagickWand_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = MagickWand_h.upcallHandle(UpdateWandViewMethod.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(UpdateWandViewMethod.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static int invoke(MemorySegment funcPtr,MemorySegment _x0, long _x1, int _x2, MemorySegment _x3) { + try { + return (int) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/_ExceptionInfo.java b/lib/src/main/java/app/photofox/imffm/generated/_ExceptionInfo.java new file mode 100644 index 0000000..cfd15f2 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/_ExceptionInfo.java @@ -0,0 +1,450 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * struct _ExceptionInfo { + * ExceptionType severity; + * int error_number; + * char *reason; + * char *description; + * void *exceptions; + * MagickBooleanType relinquish; + * SemaphoreInfo *semaphore; + * size_t signature; + * } + * } + */ +public class _ExceptionInfo { + + _ExceptionInfo() { + // Should not be called directly + } + + private static final GroupLayout $LAYOUT = MemoryLayout.structLayout( + MagickWand_h.C_INT.withName("severity"), + MagickWand_h.C_INT.withName("error_number"), + MagickWand_h.C_POINTER.withName("reason"), + MagickWand_h.C_POINTER.withName("description"), + MagickWand_h.C_POINTER.withName("exceptions"), + MagickWand_h.C_INT.withName("relinquish"), + MemoryLayout.paddingLayout(4), + MagickWand_h.C_POINTER.withName("semaphore"), + MagickWand_h.C_LONG.withName("signature") + ).withName("_ExceptionInfo"); + + /** + * The layout of this struct + */ + public static final GroupLayout layout() { + return $LAYOUT; + } + + private static final OfInt severity$LAYOUT = (OfInt)$LAYOUT.select(groupElement("severity")); + + /** + * Layout for field: + * {@snippet lang=c : + * ExceptionType severity + * } + */ + public static final OfInt severity$layout() { + return severity$LAYOUT; + } + + private static final long severity$OFFSET = 0; + + /** + * Offset for field: + * {@snippet lang=c : + * ExceptionType severity + * } + */ + public static final long severity$offset() { + return severity$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * ExceptionType severity + * } + */ + public static int severity(MemorySegment struct) { + return struct.get(severity$LAYOUT, severity$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * ExceptionType severity + * } + */ + public static void severity(MemorySegment struct, int fieldValue) { + struct.set(severity$LAYOUT, severity$OFFSET, fieldValue); + } + + private static final OfInt error_number$LAYOUT = (OfInt)$LAYOUT.select(groupElement("error_number")); + + /** + * Layout for field: + * {@snippet lang=c : + * int error_number + * } + */ + public static final OfInt error_number$layout() { + return error_number$LAYOUT; + } + + private static final long error_number$OFFSET = 4; + + /** + * Offset for field: + * {@snippet lang=c : + * int error_number + * } + */ + public static final long error_number$offset() { + return error_number$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * int error_number + * } + */ + public static int error_number(MemorySegment struct) { + return struct.get(error_number$LAYOUT, error_number$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * int error_number + * } + */ + public static void error_number(MemorySegment struct, int fieldValue) { + struct.set(error_number$LAYOUT, error_number$OFFSET, fieldValue); + } + + private static final AddressLayout reason$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("reason")); + + /** + * Layout for field: + * {@snippet lang=c : + * char *reason + * } + */ + public static final AddressLayout reason$layout() { + return reason$LAYOUT; + } + + private static final long reason$OFFSET = 8; + + /** + * Offset for field: + * {@snippet lang=c : + * char *reason + * } + */ + public static final long reason$offset() { + return reason$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char *reason + * } + */ + public static MemorySegment reason(MemorySegment struct) { + return struct.get(reason$LAYOUT, reason$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char *reason + * } + */ + public static void reason(MemorySegment struct, MemorySegment fieldValue) { + struct.set(reason$LAYOUT, reason$OFFSET, fieldValue); + } + + private static final AddressLayout description$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("description")); + + /** + * Layout for field: + * {@snippet lang=c : + * char *description + * } + */ + public static final AddressLayout description$layout() { + return description$LAYOUT; + } + + private static final long description$OFFSET = 16; + + /** + * Offset for field: + * {@snippet lang=c : + * char *description + * } + */ + public static final long description$offset() { + return description$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char *description + * } + */ + public static MemorySegment description(MemorySegment struct) { + return struct.get(description$LAYOUT, description$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char *description + * } + */ + public static void description(MemorySegment struct, MemorySegment fieldValue) { + struct.set(description$LAYOUT, description$OFFSET, fieldValue); + } + + private static final AddressLayout exceptions$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("exceptions")); + + /** + * Layout for field: + * {@snippet lang=c : + * void *exceptions + * } + */ + public static final AddressLayout exceptions$layout() { + return exceptions$LAYOUT; + } + + private static final long exceptions$OFFSET = 24; + + /** + * Offset for field: + * {@snippet lang=c : + * void *exceptions + * } + */ + public static final long exceptions$offset() { + return exceptions$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * void *exceptions + * } + */ + public static MemorySegment exceptions(MemorySegment struct) { + return struct.get(exceptions$LAYOUT, exceptions$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * void *exceptions + * } + */ + public static void exceptions(MemorySegment struct, MemorySegment fieldValue) { + struct.set(exceptions$LAYOUT, exceptions$OFFSET, fieldValue); + } + + private static final OfInt relinquish$LAYOUT = (OfInt)$LAYOUT.select(groupElement("relinquish")); + + /** + * Layout for field: + * {@snippet lang=c : + * MagickBooleanType relinquish + * } + */ + public static final OfInt relinquish$layout() { + return relinquish$LAYOUT; + } + + private static final long relinquish$OFFSET = 32; + + /** + * Offset for field: + * {@snippet lang=c : + * MagickBooleanType relinquish + * } + */ + public static final long relinquish$offset() { + return relinquish$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * MagickBooleanType relinquish + * } + */ + public static int relinquish(MemorySegment struct) { + return struct.get(relinquish$LAYOUT, relinquish$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * MagickBooleanType relinquish + * } + */ + public static void relinquish(MemorySegment struct, int fieldValue) { + struct.set(relinquish$LAYOUT, relinquish$OFFSET, fieldValue); + } + + private static final AddressLayout semaphore$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("semaphore")); + + /** + * Layout for field: + * {@snippet lang=c : + * SemaphoreInfo *semaphore + * } + */ + public static final AddressLayout semaphore$layout() { + return semaphore$LAYOUT; + } + + private static final long semaphore$OFFSET = 40; + + /** + * Offset for field: + * {@snippet lang=c : + * SemaphoreInfo *semaphore + * } + */ + public static final long semaphore$offset() { + return semaphore$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * SemaphoreInfo *semaphore + * } + */ + public static MemorySegment semaphore(MemorySegment struct) { + return struct.get(semaphore$LAYOUT, semaphore$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * SemaphoreInfo *semaphore + * } + */ + public static void semaphore(MemorySegment struct, MemorySegment fieldValue) { + struct.set(semaphore$LAYOUT, semaphore$OFFSET, fieldValue); + } + + private static final OfLong signature$LAYOUT = (OfLong)$LAYOUT.select(groupElement("signature")); + + /** + * Layout for field: + * {@snippet lang=c : + * size_t signature + * } + */ + public static final OfLong signature$layout() { + return signature$LAYOUT; + } + + private static final long signature$OFFSET = 48; + + /** + * Offset for field: + * {@snippet lang=c : + * size_t signature + * } + */ + public static final long signature$offset() { + return signature$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * size_t signature + * } + */ + public static long signature(MemorySegment struct) { + return struct.get(signature$LAYOUT, signature$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * size_t signature + * } + */ + public static void signature(MemorySegment struct, long fieldValue) { + struct.set(signature$LAYOUT, signature$OFFSET, fieldValue); + } + + /** + * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}. + * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()} + */ + public static MemorySegment asSlice(MemorySegment array, long index) { + return array.asSlice(layout().byteSize() * index); + } + + /** + * The size (in bytes) of this struct + */ + public static long sizeof() { return layout().byteSize(); } + + /** + * Allocate a segment of size {@code layout().byteSize()} using {@code allocator} + */ + public static MemorySegment allocate(SegmentAllocator allocator) { + return allocator.allocate(layout()); + } + + /** + * Allocate an array of size {@code elementCount} using {@code allocator}. + * The returned segment has size {@code elementCount * layout().byteSize()}. + */ + public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) { + return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout())); + } + + /** + * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction} (if any). + * The returned segment has size {@code layout().byteSize()} + */ + public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer cleanup) { + return reinterpret(addr, 1, arena, cleanup); + } + + /** + * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction} (if any). + * The returned segment has size {@code elementCount * layout().byteSize()} + */ + public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer cleanup) { + return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup); + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/_MagickInfo.java b/lib/src/main/java/app/photofox/imffm/generated/_MagickInfo.java new file mode 100644 index 0000000..ad9a2db --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/_MagickInfo.java @@ -0,0 +1,771 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * struct _MagickInfo { + * char *name; + * char *description; + * char *version; + * char *mime_type; + * char *note; + * char *module; + * DecodeImageHandler *decoder; + * EncodeImageHandler *encoder; + * ImageInfo *image_info; + * IsImageFormatHandler *magick; + * MagickFormatType format_type; + * MagickStatusType flags; + * SemaphoreInfo *semaphore; + * size_t signature; + * void *client_data; + * } + * } + */ +public class _MagickInfo { + + _MagickInfo() { + // Should not be called directly + } + + private static final GroupLayout $LAYOUT = MemoryLayout.structLayout( + MagickWand_h.C_POINTER.withName("name"), + MagickWand_h.C_POINTER.withName("description"), + MagickWand_h.C_POINTER.withName("version"), + MagickWand_h.C_POINTER.withName("mime_type"), + MagickWand_h.C_POINTER.withName("note"), + MagickWand_h.C_POINTER.withName("module"), + MagickWand_h.C_POINTER.withName("decoder"), + MagickWand_h.C_POINTER.withName("encoder"), + MagickWand_h.C_POINTER.withName("image_info"), + MagickWand_h.C_POINTER.withName("magick"), + MagickWand_h.C_INT.withName("format_type"), + MagickWand_h.C_INT.withName("flags"), + MagickWand_h.C_POINTER.withName("semaphore"), + MagickWand_h.C_LONG.withName("signature"), + MagickWand_h.C_POINTER.withName("client_data") + ).withName("_MagickInfo"); + + /** + * The layout of this struct + */ + public static final GroupLayout layout() { + return $LAYOUT; + } + + private static final AddressLayout name$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("name")); + + /** + * Layout for field: + * {@snippet lang=c : + * char *name + * } + */ + public static final AddressLayout name$layout() { + return name$LAYOUT; + } + + private static final long name$OFFSET = 0; + + /** + * Offset for field: + * {@snippet lang=c : + * char *name + * } + */ + public static final long name$offset() { + return name$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char *name + * } + */ + public static MemorySegment name(MemorySegment struct) { + return struct.get(name$LAYOUT, name$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char *name + * } + */ + public static void name(MemorySegment struct, MemorySegment fieldValue) { + struct.set(name$LAYOUT, name$OFFSET, fieldValue); + } + + private static final AddressLayout description$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("description")); + + /** + * Layout for field: + * {@snippet lang=c : + * char *description + * } + */ + public static final AddressLayout description$layout() { + return description$LAYOUT; + } + + private static final long description$OFFSET = 8; + + /** + * Offset for field: + * {@snippet lang=c : + * char *description + * } + */ + public static final long description$offset() { + return description$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char *description + * } + */ + public static MemorySegment description(MemorySegment struct) { + return struct.get(description$LAYOUT, description$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char *description + * } + */ + public static void description(MemorySegment struct, MemorySegment fieldValue) { + struct.set(description$LAYOUT, description$OFFSET, fieldValue); + } + + private static final AddressLayout version$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("version")); + + /** + * Layout for field: + * {@snippet lang=c : + * char *version + * } + */ + public static final AddressLayout version$layout() { + return version$LAYOUT; + } + + private static final long version$OFFSET = 16; + + /** + * Offset for field: + * {@snippet lang=c : + * char *version + * } + */ + public static final long version$offset() { + return version$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char *version + * } + */ + public static MemorySegment version(MemorySegment struct) { + return struct.get(version$LAYOUT, version$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char *version + * } + */ + public static void version(MemorySegment struct, MemorySegment fieldValue) { + struct.set(version$LAYOUT, version$OFFSET, fieldValue); + } + + private static final AddressLayout mime_type$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("mime_type")); + + /** + * Layout for field: + * {@snippet lang=c : + * char *mime_type + * } + */ + public static final AddressLayout mime_type$layout() { + return mime_type$LAYOUT; + } + + private static final long mime_type$OFFSET = 24; + + /** + * Offset for field: + * {@snippet lang=c : + * char *mime_type + * } + */ + public static final long mime_type$offset() { + return mime_type$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char *mime_type + * } + */ + public static MemorySegment mime_type(MemorySegment struct) { + return struct.get(mime_type$LAYOUT, mime_type$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char *mime_type + * } + */ + public static void mime_type(MemorySegment struct, MemorySegment fieldValue) { + struct.set(mime_type$LAYOUT, mime_type$OFFSET, fieldValue); + } + + private static final AddressLayout note$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("note")); + + /** + * Layout for field: + * {@snippet lang=c : + * char *note + * } + */ + public static final AddressLayout note$layout() { + return note$LAYOUT; + } + + private static final long note$OFFSET = 32; + + /** + * Offset for field: + * {@snippet lang=c : + * char *note + * } + */ + public static final long note$offset() { + return note$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char *note + * } + */ + public static MemorySegment note(MemorySegment struct) { + return struct.get(note$LAYOUT, note$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char *note + * } + */ + public static void note(MemorySegment struct, MemorySegment fieldValue) { + struct.set(note$LAYOUT, note$OFFSET, fieldValue); + } + + private static final AddressLayout module$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("module")); + + /** + * Layout for field: + * {@snippet lang=c : + * char *module + * } + */ + public static final AddressLayout module$layout() { + return module$LAYOUT; + } + + private static final long module$OFFSET = 40; + + /** + * Offset for field: + * {@snippet lang=c : + * char *module + * } + */ + public static final long module$offset() { + return module$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char *module + * } + */ + public static MemorySegment module(MemorySegment struct) { + return struct.get(module$LAYOUT, module$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char *module + * } + */ + public static void module(MemorySegment struct, MemorySegment fieldValue) { + struct.set(module$LAYOUT, module$OFFSET, fieldValue); + } + + private static final AddressLayout decoder$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("decoder")); + + /** + * Layout for field: + * {@snippet lang=c : + * DecodeImageHandler *decoder + * } + */ + public static final AddressLayout decoder$layout() { + return decoder$LAYOUT; + } + + private static final long decoder$OFFSET = 48; + + /** + * Offset for field: + * {@snippet lang=c : + * DecodeImageHandler *decoder + * } + */ + public static final long decoder$offset() { + return decoder$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * DecodeImageHandler *decoder + * } + */ + public static MemorySegment decoder(MemorySegment struct) { + return struct.get(decoder$LAYOUT, decoder$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * DecodeImageHandler *decoder + * } + */ + public static void decoder(MemorySegment struct, MemorySegment fieldValue) { + struct.set(decoder$LAYOUT, decoder$OFFSET, fieldValue); + } + + private static final AddressLayout encoder$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("encoder")); + + /** + * Layout for field: + * {@snippet lang=c : + * EncodeImageHandler *encoder + * } + */ + public static final AddressLayout encoder$layout() { + return encoder$LAYOUT; + } + + private static final long encoder$OFFSET = 56; + + /** + * Offset for field: + * {@snippet lang=c : + * EncodeImageHandler *encoder + * } + */ + public static final long encoder$offset() { + return encoder$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * EncodeImageHandler *encoder + * } + */ + public static MemorySegment encoder(MemorySegment struct) { + return struct.get(encoder$LAYOUT, encoder$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * EncodeImageHandler *encoder + * } + */ + public static void encoder(MemorySegment struct, MemorySegment fieldValue) { + struct.set(encoder$LAYOUT, encoder$OFFSET, fieldValue); + } + + private static final AddressLayout image_info$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("image_info")); + + /** + * Layout for field: + * {@snippet lang=c : + * ImageInfo *image_info + * } + */ + public static final AddressLayout image_info$layout() { + return image_info$LAYOUT; + } + + private static final long image_info$OFFSET = 64; + + /** + * Offset for field: + * {@snippet lang=c : + * ImageInfo *image_info + * } + */ + public static final long image_info$offset() { + return image_info$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * ImageInfo *image_info + * } + */ + public static MemorySegment image_info(MemorySegment struct) { + return struct.get(image_info$LAYOUT, image_info$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * ImageInfo *image_info + * } + */ + public static void image_info(MemorySegment struct, MemorySegment fieldValue) { + struct.set(image_info$LAYOUT, image_info$OFFSET, fieldValue); + } + + private static final AddressLayout magick$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("magick")); + + /** + * Layout for field: + * {@snippet lang=c : + * IsImageFormatHandler *magick + * } + */ + public static final AddressLayout magick$layout() { + return magick$LAYOUT; + } + + private static final long magick$OFFSET = 72; + + /** + * Offset for field: + * {@snippet lang=c : + * IsImageFormatHandler *magick + * } + */ + public static final long magick$offset() { + return magick$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * IsImageFormatHandler *magick + * } + */ + public static MemorySegment magick(MemorySegment struct) { + return struct.get(magick$LAYOUT, magick$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * IsImageFormatHandler *magick + * } + */ + public static void magick(MemorySegment struct, MemorySegment fieldValue) { + struct.set(magick$LAYOUT, magick$OFFSET, fieldValue); + } + + private static final OfInt format_type$LAYOUT = (OfInt)$LAYOUT.select(groupElement("format_type")); + + /** + * Layout for field: + * {@snippet lang=c : + * MagickFormatType format_type + * } + */ + public static final OfInt format_type$layout() { + return format_type$LAYOUT; + } + + private static final long format_type$OFFSET = 80; + + /** + * Offset for field: + * {@snippet lang=c : + * MagickFormatType format_type + * } + */ + public static final long format_type$offset() { + return format_type$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * MagickFormatType format_type + * } + */ + public static int format_type(MemorySegment struct) { + return struct.get(format_type$LAYOUT, format_type$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * MagickFormatType format_type + * } + */ + public static void format_type(MemorySegment struct, int fieldValue) { + struct.set(format_type$LAYOUT, format_type$OFFSET, fieldValue); + } + + private static final OfInt flags$LAYOUT = (OfInt)$LAYOUT.select(groupElement("flags")); + + /** + * Layout for field: + * {@snippet lang=c : + * MagickStatusType flags + * } + */ + public static final OfInt flags$layout() { + return flags$LAYOUT; + } + + private static final long flags$OFFSET = 84; + + /** + * Offset for field: + * {@snippet lang=c : + * MagickStatusType flags + * } + */ + public static final long flags$offset() { + return flags$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * MagickStatusType flags + * } + */ + public static int flags(MemorySegment struct) { + return struct.get(flags$LAYOUT, flags$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * MagickStatusType flags + * } + */ + public static void flags(MemorySegment struct, int fieldValue) { + struct.set(flags$LAYOUT, flags$OFFSET, fieldValue); + } + + private static final AddressLayout semaphore$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("semaphore")); + + /** + * Layout for field: + * {@snippet lang=c : + * SemaphoreInfo *semaphore + * } + */ + public static final AddressLayout semaphore$layout() { + return semaphore$LAYOUT; + } + + private static final long semaphore$OFFSET = 88; + + /** + * Offset for field: + * {@snippet lang=c : + * SemaphoreInfo *semaphore + * } + */ + public static final long semaphore$offset() { + return semaphore$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * SemaphoreInfo *semaphore + * } + */ + public static MemorySegment semaphore(MemorySegment struct) { + return struct.get(semaphore$LAYOUT, semaphore$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * SemaphoreInfo *semaphore + * } + */ + public static void semaphore(MemorySegment struct, MemorySegment fieldValue) { + struct.set(semaphore$LAYOUT, semaphore$OFFSET, fieldValue); + } + + private static final OfLong signature$LAYOUT = (OfLong)$LAYOUT.select(groupElement("signature")); + + /** + * Layout for field: + * {@snippet lang=c : + * size_t signature + * } + */ + public static final OfLong signature$layout() { + return signature$LAYOUT; + } + + private static final long signature$OFFSET = 96; + + /** + * Offset for field: + * {@snippet lang=c : + * size_t signature + * } + */ + public static final long signature$offset() { + return signature$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * size_t signature + * } + */ + public static long signature(MemorySegment struct) { + return struct.get(signature$LAYOUT, signature$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * size_t signature + * } + */ + public static void signature(MemorySegment struct, long fieldValue) { + struct.set(signature$LAYOUT, signature$OFFSET, fieldValue); + } + + private static final AddressLayout client_data$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("client_data")); + + /** + * Layout for field: + * {@snippet lang=c : + * void *client_data + * } + */ + public static final AddressLayout client_data$layout() { + return client_data$LAYOUT; + } + + private static final long client_data$OFFSET = 104; + + /** + * Offset for field: + * {@snippet lang=c : + * void *client_data + * } + */ + public static final long client_data$offset() { + return client_data$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * void *client_data + * } + */ + public static MemorySegment client_data(MemorySegment struct) { + return struct.get(client_data$LAYOUT, client_data$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * void *client_data + * } + */ + public static void client_data(MemorySegment struct, MemorySegment fieldValue) { + struct.set(client_data$LAYOUT, client_data$OFFSET, fieldValue); + } + + /** + * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}. + * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()} + */ + public static MemorySegment asSlice(MemorySegment array, long index) { + return array.asSlice(layout().byteSize() * index); + } + + /** + * The size (in bytes) of this struct + */ + public static long sizeof() { return layout().byteSize(); } + + /** + * Allocate a segment of size {@code layout().byteSize()} using {@code allocator} + */ + public static MemorySegment allocate(SegmentAllocator allocator) { + return allocator.allocate(layout()); + } + + /** + * Allocate an array of size {@code elementCount} using {@code allocator}. + * The returned segment has size {@code elementCount * layout().byteSize()}. + */ + public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) { + return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout())); + } + + /** + * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction} (if any). + * The returned segment has size {@code layout().byteSize()} + */ + public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer cleanup) { + return reinterpret(addr, 1, arena, cleanup); + } + + /** + * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction} (if any). + * The returned segment has size {@code elementCount * layout().byteSize()} + */ + public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer cleanup) { + return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup); + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/_MontageInfo.java b/lib/src/main/java/app/photofox/imffm/generated/_MontageInfo.java new file mode 100644 index 0000000..9790df0 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/_MontageInfo.java @@ -0,0 +1,989 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * struct _MontageInfo { + * char *geometry; + * char *tile; + * char *title; + * char *frame; + * char *texture; + * char *font; + * double pointsize; + * size_t border_width; + * MagickBooleanType shadow; + * PixelInfo alpha_color; + * PixelInfo background_color; + * PixelInfo border_color; + * PixelInfo fill; + * PixelInfo stroke; + * GravityType gravity; + * char filename[4096]; + * MagickBooleanType debug; + * size_t signature; + * PixelInfo matte_color; + * } + * } + */ +public class _MontageInfo { + + _MontageInfo() { + // Should not be called directly + } + + private static final GroupLayout $LAYOUT = MemoryLayout.structLayout( + MagickWand_h.C_POINTER.withName("geometry"), + MagickWand_h.C_POINTER.withName("tile"), + MagickWand_h.C_POINTER.withName("title"), + MagickWand_h.C_POINTER.withName("frame"), + MagickWand_h.C_POINTER.withName("texture"), + MagickWand_h.C_POINTER.withName("font"), + MagickWand_h.C_DOUBLE.withName("pointsize"), + MagickWand_h.C_LONG.withName("border_width"), + MagickWand_h.C_INT.withName("shadow"), + MemoryLayout.paddingLayout(4), + _PixelInfo.layout().withName("alpha_color"), + _PixelInfo.layout().withName("background_color"), + _PixelInfo.layout().withName("border_color"), + _PixelInfo.layout().withName("fill"), + _PixelInfo.layout().withName("stroke"), + MagickWand_h.C_INT.withName("gravity"), + MemoryLayout.sequenceLayout(4096, MagickWand_h.C_CHAR).withName("filename"), + MagickWand_h.C_INT.withName("debug"), + MagickWand_h.C_LONG.withName("signature"), + _PixelInfo.layout().withName("matte_color") + ).withName("_MontageInfo"); + + /** + * The layout of this struct + */ + public static final GroupLayout layout() { + return $LAYOUT; + } + + private static final AddressLayout geometry$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("geometry")); + + /** + * Layout for field: + * {@snippet lang=c : + * char *geometry + * } + */ + public static final AddressLayout geometry$layout() { + return geometry$LAYOUT; + } + + private static final long geometry$OFFSET = 0; + + /** + * Offset for field: + * {@snippet lang=c : + * char *geometry + * } + */ + public static final long geometry$offset() { + return geometry$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char *geometry + * } + */ + public static MemorySegment geometry(MemorySegment struct) { + return struct.get(geometry$LAYOUT, geometry$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char *geometry + * } + */ + public static void geometry(MemorySegment struct, MemorySegment fieldValue) { + struct.set(geometry$LAYOUT, geometry$OFFSET, fieldValue); + } + + private static final AddressLayout tile$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("tile")); + + /** + * Layout for field: + * {@snippet lang=c : + * char *tile + * } + */ + public static final AddressLayout tile$layout() { + return tile$LAYOUT; + } + + private static final long tile$OFFSET = 8; + + /** + * Offset for field: + * {@snippet lang=c : + * char *tile + * } + */ + public static final long tile$offset() { + return tile$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char *tile + * } + */ + public static MemorySegment tile(MemorySegment struct) { + return struct.get(tile$LAYOUT, tile$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char *tile + * } + */ + public static void tile(MemorySegment struct, MemorySegment fieldValue) { + struct.set(tile$LAYOUT, tile$OFFSET, fieldValue); + } + + private static final AddressLayout title$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("title")); + + /** + * Layout for field: + * {@snippet lang=c : + * char *title + * } + */ + public static final AddressLayout title$layout() { + return title$LAYOUT; + } + + private static final long title$OFFSET = 16; + + /** + * Offset for field: + * {@snippet lang=c : + * char *title + * } + */ + public static final long title$offset() { + return title$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char *title + * } + */ + public static MemorySegment title(MemorySegment struct) { + return struct.get(title$LAYOUT, title$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char *title + * } + */ + public static void title(MemorySegment struct, MemorySegment fieldValue) { + struct.set(title$LAYOUT, title$OFFSET, fieldValue); + } + + private static final AddressLayout frame$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("frame")); + + /** + * Layout for field: + * {@snippet lang=c : + * char *frame + * } + */ + public static final AddressLayout frame$layout() { + return frame$LAYOUT; + } + + private static final long frame$OFFSET = 24; + + /** + * Offset for field: + * {@snippet lang=c : + * char *frame + * } + */ + public static final long frame$offset() { + return frame$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char *frame + * } + */ + public static MemorySegment frame(MemorySegment struct) { + return struct.get(frame$LAYOUT, frame$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char *frame + * } + */ + public static void frame(MemorySegment struct, MemorySegment fieldValue) { + struct.set(frame$LAYOUT, frame$OFFSET, fieldValue); + } + + private static final AddressLayout texture$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("texture")); + + /** + * Layout for field: + * {@snippet lang=c : + * char *texture + * } + */ + public static final AddressLayout texture$layout() { + return texture$LAYOUT; + } + + private static final long texture$OFFSET = 32; + + /** + * Offset for field: + * {@snippet lang=c : + * char *texture + * } + */ + public static final long texture$offset() { + return texture$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char *texture + * } + */ + public static MemorySegment texture(MemorySegment struct) { + return struct.get(texture$LAYOUT, texture$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char *texture + * } + */ + public static void texture(MemorySegment struct, MemorySegment fieldValue) { + struct.set(texture$LAYOUT, texture$OFFSET, fieldValue); + } + + private static final AddressLayout font$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("font")); + + /** + * Layout for field: + * {@snippet lang=c : + * char *font + * } + */ + public static final AddressLayout font$layout() { + return font$LAYOUT; + } + + private static final long font$OFFSET = 40; + + /** + * Offset for field: + * {@snippet lang=c : + * char *font + * } + */ + public static final long font$offset() { + return font$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char *font + * } + */ + public static MemorySegment font(MemorySegment struct) { + return struct.get(font$LAYOUT, font$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char *font + * } + */ + public static void font(MemorySegment struct, MemorySegment fieldValue) { + struct.set(font$LAYOUT, font$OFFSET, fieldValue); + } + + private static final OfDouble pointsize$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("pointsize")); + + /** + * Layout for field: + * {@snippet lang=c : + * double pointsize + * } + */ + public static final OfDouble pointsize$layout() { + return pointsize$LAYOUT; + } + + private static final long pointsize$OFFSET = 48; + + /** + * Offset for field: + * {@snippet lang=c : + * double pointsize + * } + */ + public static final long pointsize$offset() { + return pointsize$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * double pointsize + * } + */ + public static double pointsize(MemorySegment struct) { + return struct.get(pointsize$LAYOUT, pointsize$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * double pointsize + * } + */ + public static void pointsize(MemorySegment struct, double fieldValue) { + struct.set(pointsize$LAYOUT, pointsize$OFFSET, fieldValue); + } + + private static final OfLong border_width$LAYOUT = (OfLong)$LAYOUT.select(groupElement("border_width")); + + /** + * Layout for field: + * {@snippet lang=c : + * size_t border_width + * } + */ + public static final OfLong border_width$layout() { + return border_width$LAYOUT; + } + + private static final long border_width$OFFSET = 56; + + /** + * Offset for field: + * {@snippet lang=c : + * size_t border_width + * } + */ + public static final long border_width$offset() { + return border_width$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * size_t border_width + * } + */ + public static long border_width(MemorySegment struct) { + return struct.get(border_width$LAYOUT, border_width$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * size_t border_width + * } + */ + public static void border_width(MemorySegment struct, long fieldValue) { + struct.set(border_width$LAYOUT, border_width$OFFSET, fieldValue); + } + + private static final OfInt shadow$LAYOUT = (OfInt)$LAYOUT.select(groupElement("shadow")); + + /** + * Layout for field: + * {@snippet lang=c : + * MagickBooleanType shadow + * } + */ + public static final OfInt shadow$layout() { + return shadow$LAYOUT; + } + + private static final long shadow$OFFSET = 64; + + /** + * Offset for field: + * {@snippet lang=c : + * MagickBooleanType shadow + * } + */ + public static final long shadow$offset() { + return shadow$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * MagickBooleanType shadow + * } + */ + public static int shadow(MemorySegment struct) { + return struct.get(shadow$LAYOUT, shadow$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * MagickBooleanType shadow + * } + */ + public static void shadow(MemorySegment struct, int fieldValue) { + struct.set(shadow$LAYOUT, shadow$OFFSET, fieldValue); + } + + private static final GroupLayout alpha_color$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("alpha_color")); + + /** + * Layout for field: + * {@snippet lang=c : + * PixelInfo alpha_color + * } + */ + public static final GroupLayout alpha_color$layout() { + return alpha_color$LAYOUT; + } + + private static final long alpha_color$OFFSET = 72; + + /** + * Offset for field: + * {@snippet lang=c : + * PixelInfo alpha_color + * } + */ + public static final long alpha_color$offset() { + return alpha_color$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * PixelInfo alpha_color + * } + */ + public static MemorySegment alpha_color(MemorySegment struct) { + return struct.asSlice(alpha_color$OFFSET, alpha_color$LAYOUT.byteSize()); + } + + /** + * Setter for field: + * {@snippet lang=c : + * PixelInfo alpha_color + * } + */ + public static void alpha_color(MemorySegment struct, MemorySegment fieldValue) { + MemorySegment.copy(fieldValue, 0L, struct, alpha_color$OFFSET, alpha_color$LAYOUT.byteSize()); + } + + private static final GroupLayout background_color$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("background_color")); + + /** + * Layout for field: + * {@snippet lang=c : + * PixelInfo background_color + * } + */ + public static final GroupLayout background_color$layout() { + return background_color$LAYOUT; + } + + private static final long background_color$OFFSET = 160; + + /** + * Offset for field: + * {@snippet lang=c : + * PixelInfo background_color + * } + */ + public static final long background_color$offset() { + return background_color$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * PixelInfo background_color + * } + */ + public static MemorySegment background_color(MemorySegment struct) { + return struct.asSlice(background_color$OFFSET, background_color$LAYOUT.byteSize()); + } + + /** + * Setter for field: + * {@snippet lang=c : + * PixelInfo background_color + * } + */ + public static void background_color(MemorySegment struct, MemorySegment fieldValue) { + MemorySegment.copy(fieldValue, 0L, struct, background_color$OFFSET, background_color$LAYOUT.byteSize()); + } + + private static final GroupLayout border_color$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("border_color")); + + /** + * Layout for field: + * {@snippet lang=c : + * PixelInfo border_color + * } + */ + public static final GroupLayout border_color$layout() { + return border_color$LAYOUT; + } + + private static final long border_color$OFFSET = 248; + + /** + * Offset for field: + * {@snippet lang=c : + * PixelInfo border_color + * } + */ + public static final long border_color$offset() { + return border_color$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * PixelInfo border_color + * } + */ + public static MemorySegment border_color(MemorySegment struct) { + return struct.asSlice(border_color$OFFSET, border_color$LAYOUT.byteSize()); + } + + /** + * Setter for field: + * {@snippet lang=c : + * PixelInfo border_color + * } + */ + public static void border_color(MemorySegment struct, MemorySegment fieldValue) { + MemorySegment.copy(fieldValue, 0L, struct, border_color$OFFSET, border_color$LAYOUT.byteSize()); + } + + private static final GroupLayout fill$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("fill")); + + /** + * Layout for field: + * {@snippet lang=c : + * PixelInfo fill + * } + */ + public static final GroupLayout fill$layout() { + return fill$LAYOUT; + } + + private static final long fill$OFFSET = 336; + + /** + * Offset for field: + * {@snippet lang=c : + * PixelInfo fill + * } + */ + public static final long fill$offset() { + return fill$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * PixelInfo fill + * } + */ + public static MemorySegment fill(MemorySegment struct) { + return struct.asSlice(fill$OFFSET, fill$LAYOUT.byteSize()); + } + + /** + * Setter for field: + * {@snippet lang=c : + * PixelInfo fill + * } + */ + public static void fill(MemorySegment struct, MemorySegment fieldValue) { + MemorySegment.copy(fieldValue, 0L, struct, fill$OFFSET, fill$LAYOUT.byteSize()); + } + + private static final GroupLayout stroke$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("stroke")); + + /** + * Layout for field: + * {@snippet lang=c : + * PixelInfo stroke + * } + */ + public static final GroupLayout stroke$layout() { + return stroke$LAYOUT; + } + + private static final long stroke$OFFSET = 424; + + /** + * Offset for field: + * {@snippet lang=c : + * PixelInfo stroke + * } + */ + public static final long stroke$offset() { + return stroke$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * PixelInfo stroke + * } + */ + public static MemorySegment stroke(MemorySegment struct) { + return struct.asSlice(stroke$OFFSET, stroke$LAYOUT.byteSize()); + } + + /** + * Setter for field: + * {@snippet lang=c : + * PixelInfo stroke + * } + */ + public static void stroke(MemorySegment struct, MemorySegment fieldValue) { + MemorySegment.copy(fieldValue, 0L, struct, stroke$OFFSET, stroke$LAYOUT.byteSize()); + } + + private static final OfInt gravity$LAYOUT = (OfInt)$LAYOUT.select(groupElement("gravity")); + + /** + * Layout for field: + * {@snippet lang=c : + * GravityType gravity + * } + */ + public static final OfInt gravity$layout() { + return gravity$LAYOUT; + } + + private static final long gravity$OFFSET = 512; + + /** + * Offset for field: + * {@snippet lang=c : + * GravityType gravity + * } + */ + public static final long gravity$offset() { + return gravity$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * GravityType gravity + * } + */ + public static int gravity(MemorySegment struct) { + return struct.get(gravity$LAYOUT, gravity$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * GravityType gravity + * } + */ + public static void gravity(MemorySegment struct, int fieldValue) { + struct.set(gravity$LAYOUT, gravity$OFFSET, fieldValue); + } + + private static final SequenceLayout filename$LAYOUT = (SequenceLayout)$LAYOUT.select(groupElement("filename")); + + /** + * Layout for field: + * {@snippet lang=c : + * char filename[4096] + * } + */ + public static final SequenceLayout filename$layout() { + return filename$LAYOUT; + } + + private static final long filename$OFFSET = 516; + + /** + * Offset for field: + * {@snippet lang=c : + * char filename[4096] + * } + */ + public static final long filename$offset() { + return filename$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * char filename[4096] + * } + */ + public static MemorySegment filename(MemorySegment struct) { + return struct.asSlice(filename$OFFSET, filename$LAYOUT.byteSize()); + } + + /** + * Setter for field: + * {@snippet lang=c : + * char filename[4096] + * } + */ + public static void filename(MemorySegment struct, MemorySegment fieldValue) { + MemorySegment.copy(fieldValue, 0L, struct, filename$OFFSET, filename$LAYOUT.byteSize()); + } + + private static long[] filename$DIMS = { 4096 }; + + /** + * Dimensions for array field: + * {@snippet lang=c : + * char filename[4096] + * } + */ + public static long[] filename$dimensions() { + return filename$DIMS; + } + private static final VarHandle filename$ELEM_HANDLE = filename$LAYOUT.varHandle(sequenceElement()); + + /** + * Indexed getter for field: + * {@snippet lang=c : + * char filename[4096] + * } + */ + public static byte filename(MemorySegment struct, long index0) { + return (byte)filename$ELEM_HANDLE.get(struct, 0L, index0); + } + + /** + * Indexed setter for field: + * {@snippet lang=c : + * char filename[4096] + * } + */ + public static void filename(MemorySegment struct, long index0, byte fieldValue) { + filename$ELEM_HANDLE.set(struct, 0L, index0, fieldValue); + } + + private static final OfInt debug$LAYOUT = (OfInt)$LAYOUT.select(groupElement("debug")); + + /** + * Layout for field: + * {@snippet lang=c : + * MagickBooleanType debug + * } + */ + public static final OfInt debug$layout() { + return debug$LAYOUT; + } + + private static final long debug$OFFSET = 4612; + + /** + * Offset for field: + * {@snippet lang=c : + * MagickBooleanType debug + * } + */ + public static final long debug$offset() { + return debug$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * MagickBooleanType debug + * } + */ + public static int debug(MemorySegment struct) { + return struct.get(debug$LAYOUT, debug$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * MagickBooleanType debug + * } + */ + public static void debug(MemorySegment struct, int fieldValue) { + struct.set(debug$LAYOUT, debug$OFFSET, fieldValue); + } + + private static final OfLong signature$LAYOUT = (OfLong)$LAYOUT.select(groupElement("signature")); + + /** + * Layout for field: + * {@snippet lang=c : + * size_t signature + * } + */ + public static final OfLong signature$layout() { + return signature$LAYOUT; + } + + private static final long signature$OFFSET = 4616; + + /** + * Offset for field: + * {@snippet lang=c : + * size_t signature + * } + */ + public static final long signature$offset() { + return signature$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * size_t signature + * } + */ + public static long signature(MemorySegment struct) { + return struct.get(signature$LAYOUT, signature$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * size_t signature + * } + */ + public static void signature(MemorySegment struct, long fieldValue) { + struct.set(signature$LAYOUT, signature$OFFSET, fieldValue); + } + + private static final GroupLayout matte_color$LAYOUT = (GroupLayout)$LAYOUT.select(groupElement("matte_color")); + + /** + * Layout for field: + * {@snippet lang=c : + * PixelInfo matte_color + * } + */ + public static final GroupLayout matte_color$layout() { + return matte_color$LAYOUT; + } + + private static final long matte_color$OFFSET = 4624; + + /** + * Offset for field: + * {@snippet lang=c : + * PixelInfo matte_color + * } + */ + public static final long matte_color$offset() { + return matte_color$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * PixelInfo matte_color + * } + */ + public static MemorySegment matte_color(MemorySegment struct) { + return struct.asSlice(matte_color$OFFSET, matte_color$LAYOUT.byteSize()); + } + + /** + * Setter for field: + * {@snippet lang=c : + * PixelInfo matte_color + * } + */ + public static void matte_color(MemorySegment struct, MemorySegment fieldValue) { + MemorySegment.copy(fieldValue, 0L, struct, matte_color$OFFSET, matte_color$LAYOUT.byteSize()); + } + + /** + * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}. + * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()} + */ + public static MemorySegment asSlice(MemorySegment array, long index) { + return array.asSlice(layout().byteSize() * index); + } + + /** + * The size (in bytes) of this struct + */ + public static long sizeof() { return layout().byteSize(); } + + /** + * Allocate a segment of size {@code layout().byteSize()} using {@code allocator} + */ + public static MemorySegment allocate(SegmentAllocator allocator) { + return allocator.allocate(layout()); + } + + /** + * Allocate an array of size {@code elementCount} using {@code allocator}. + * The returned segment has size {@code elementCount * layout().byteSize()}. + */ + public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) { + return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout())); + } + + /** + * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction} (if any). + * The returned segment has size {@code layout().byteSize()} + */ + public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer cleanup) { + return reinterpret(addr, 1, arena, cleanup); + } + + /** + * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction} (if any). + * The returned segment has size {@code elementCount * layout().byteSize()} + */ + public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer cleanup) { + return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup); + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/_PixelInfo.java b/lib/src/main/java/app/photofox/imffm/generated/_PixelInfo.java new file mode 100644 index 0000000..b53f224 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/_PixelInfo.java @@ -0,0 +1,634 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * struct _PixelInfo { + * ClassType storage_class; + * ColorspaceType colorspace; + * PixelTrait alpha_trait; + * double fuzz; + * size_t depth; + * MagickSizeType count; + * MagickRealType red; + * MagickRealType green; + * MagickRealType blue; + * MagickRealType black; + * MagickRealType alpha; + * MagickRealType index; + * } + * } + */ +public class _PixelInfo { + + _PixelInfo() { + // Should not be called directly + } + + private static final GroupLayout $LAYOUT = MemoryLayout.structLayout( + MagickWand_h.C_INT.withName("storage_class"), + MagickWand_h.C_INT.withName("colorspace"), + MagickWand_h.C_INT.withName("alpha_trait"), + MemoryLayout.paddingLayout(4), + MagickWand_h.C_DOUBLE.withName("fuzz"), + MagickWand_h.C_LONG.withName("depth"), + MagickWand_h.C_LONG_LONG.withName("count"), + MagickWand_h.C_DOUBLE.withName("red"), + MagickWand_h.C_DOUBLE.withName("green"), + MagickWand_h.C_DOUBLE.withName("blue"), + MagickWand_h.C_DOUBLE.withName("black"), + MagickWand_h.C_DOUBLE.withName("alpha"), + MagickWand_h.C_DOUBLE.withName("index") + ).withName("_PixelInfo"); + + /** + * The layout of this struct + */ + public static final GroupLayout layout() { + return $LAYOUT; + } + + private static final OfInt storage_class$LAYOUT = (OfInt)$LAYOUT.select(groupElement("storage_class")); + + /** + * Layout for field: + * {@snippet lang=c : + * ClassType storage_class + * } + */ + public static final OfInt storage_class$layout() { + return storage_class$LAYOUT; + } + + private static final long storage_class$OFFSET = 0; + + /** + * Offset for field: + * {@snippet lang=c : + * ClassType storage_class + * } + */ + public static final long storage_class$offset() { + return storage_class$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * ClassType storage_class + * } + */ + public static int storage_class(MemorySegment struct) { + return struct.get(storage_class$LAYOUT, storage_class$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * ClassType storage_class + * } + */ + public static void storage_class(MemorySegment struct, int fieldValue) { + struct.set(storage_class$LAYOUT, storage_class$OFFSET, fieldValue); + } + + private static final OfInt colorspace$LAYOUT = (OfInt)$LAYOUT.select(groupElement("colorspace")); + + /** + * Layout for field: + * {@snippet lang=c : + * ColorspaceType colorspace + * } + */ + public static final OfInt colorspace$layout() { + return colorspace$LAYOUT; + } + + private static final long colorspace$OFFSET = 4; + + /** + * Offset for field: + * {@snippet lang=c : + * ColorspaceType colorspace + * } + */ + public static final long colorspace$offset() { + return colorspace$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * ColorspaceType colorspace + * } + */ + public static int colorspace(MemorySegment struct) { + return struct.get(colorspace$LAYOUT, colorspace$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * ColorspaceType colorspace + * } + */ + public static void colorspace(MemorySegment struct, int fieldValue) { + struct.set(colorspace$LAYOUT, colorspace$OFFSET, fieldValue); + } + + private static final OfInt alpha_trait$LAYOUT = (OfInt)$LAYOUT.select(groupElement("alpha_trait")); + + /** + * Layout for field: + * {@snippet lang=c : + * PixelTrait alpha_trait + * } + */ + public static final OfInt alpha_trait$layout() { + return alpha_trait$LAYOUT; + } + + private static final long alpha_trait$OFFSET = 8; + + /** + * Offset for field: + * {@snippet lang=c : + * PixelTrait alpha_trait + * } + */ + public static final long alpha_trait$offset() { + return alpha_trait$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * PixelTrait alpha_trait + * } + */ + public static int alpha_trait(MemorySegment struct) { + return struct.get(alpha_trait$LAYOUT, alpha_trait$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * PixelTrait alpha_trait + * } + */ + public static void alpha_trait(MemorySegment struct, int fieldValue) { + struct.set(alpha_trait$LAYOUT, alpha_trait$OFFSET, fieldValue); + } + + private static final OfDouble fuzz$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("fuzz")); + + /** + * Layout for field: + * {@snippet lang=c : + * double fuzz + * } + */ + public static final OfDouble fuzz$layout() { + return fuzz$LAYOUT; + } + + private static final long fuzz$OFFSET = 16; + + /** + * Offset for field: + * {@snippet lang=c : + * double fuzz + * } + */ + public static final long fuzz$offset() { + return fuzz$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * double fuzz + * } + */ + public static double fuzz(MemorySegment struct) { + return struct.get(fuzz$LAYOUT, fuzz$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * double fuzz + * } + */ + public static void fuzz(MemorySegment struct, double fieldValue) { + struct.set(fuzz$LAYOUT, fuzz$OFFSET, fieldValue); + } + + private static final OfLong depth$LAYOUT = (OfLong)$LAYOUT.select(groupElement("depth")); + + /** + * Layout for field: + * {@snippet lang=c : + * size_t depth + * } + */ + public static final OfLong depth$layout() { + return depth$LAYOUT; + } + + private static final long depth$OFFSET = 24; + + /** + * Offset for field: + * {@snippet lang=c : + * size_t depth + * } + */ + public static final long depth$offset() { + return depth$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * size_t depth + * } + */ + public static long depth(MemorySegment struct) { + return struct.get(depth$LAYOUT, depth$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * size_t depth + * } + */ + public static void depth(MemorySegment struct, long fieldValue) { + struct.set(depth$LAYOUT, depth$OFFSET, fieldValue); + } + + private static final OfLong count$LAYOUT = (OfLong)$LAYOUT.select(groupElement("count")); + + /** + * Layout for field: + * {@snippet lang=c : + * MagickSizeType count + * } + */ + public static final OfLong count$layout() { + return count$LAYOUT; + } + + private static final long count$OFFSET = 32; + + /** + * Offset for field: + * {@snippet lang=c : + * MagickSizeType count + * } + */ + public static final long count$offset() { + return count$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * MagickSizeType count + * } + */ + public static long count(MemorySegment struct) { + return struct.get(count$LAYOUT, count$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * MagickSizeType count + * } + */ + public static void count(MemorySegment struct, long fieldValue) { + struct.set(count$LAYOUT, count$OFFSET, fieldValue); + } + + private static final OfDouble red$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("red")); + + /** + * Layout for field: + * {@snippet lang=c : + * MagickRealType red + * } + */ + public static final OfDouble red$layout() { + return red$LAYOUT; + } + + private static final long red$OFFSET = 40; + + /** + * Offset for field: + * {@snippet lang=c : + * MagickRealType red + * } + */ + public static final long red$offset() { + return red$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * MagickRealType red + * } + */ + public static double red(MemorySegment struct) { + return struct.get(red$LAYOUT, red$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * MagickRealType red + * } + */ + public static void red(MemorySegment struct, double fieldValue) { + struct.set(red$LAYOUT, red$OFFSET, fieldValue); + } + + private static final OfDouble green$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("green")); + + /** + * Layout for field: + * {@snippet lang=c : + * MagickRealType green + * } + */ + public static final OfDouble green$layout() { + return green$LAYOUT; + } + + private static final long green$OFFSET = 48; + + /** + * Offset for field: + * {@snippet lang=c : + * MagickRealType green + * } + */ + public static final long green$offset() { + return green$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * MagickRealType green + * } + */ + public static double green(MemorySegment struct) { + return struct.get(green$LAYOUT, green$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * MagickRealType green + * } + */ + public static void green(MemorySegment struct, double fieldValue) { + struct.set(green$LAYOUT, green$OFFSET, fieldValue); + } + + private static final OfDouble blue$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("blue")); + + /** + * Layout for field: + * {@snippet lang=c : + * MagickRealType blue + * } + */ + public static final OfDouble blue$layout() { + return blue$LAYOUT; + } + + private static final long blue$OFFSET = 56; + + /** + * Offset for field: + * {@snippet lang=c : + * MagickRealType blue + * } + */ + public static final long blue$offset() { + return blue$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * MagickRealType blue + * } + */ + public static double blue(MemorySegment struct) { + return struct.get(blue$LAYOUT, blue$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * MagickRealType blue + * } + */ + public static void blue(MemorySegment struct, double fieldValue) { + struct.set(blue$LAYOUT, blue$OFFSET, fieldValue); + } + + private static final OfDouble black$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("black")); + + /** + * Layout for field: + * {@snippet lang=c : + * MagickRealType black + * } + */ + public static final OfDouble black$layout() { + return black$LAYOUT; + } + + private static final long black$OFFSET = 64; + + /** + * Offset for field: + * {@snippet lang=c : + * MagickRealType black + * } + */ + public static final long black$offset() { + return black$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * MagickRealType black + * } + */ + public static double black(MemorySegment struct) { + return struct.get(black$LAYOUT, black$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * MagickRealType black + * } + */ + public static void black(MemorySegment struct, double fieldValue) { + struct.set(black$LAYOUT, black$OFFSET, fieldValue); + } + + private static final OfDouble alpha$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("alpha")); + + /** + * Layout for field: + * {@snippet lang=c : + * MagickRealType alpha + * } + */ + public static final OfDouble alpha$layout() { + return alpha$LAYOUT; + } + + private static final long alpha$OFFSET = 72; + + /** + * Offset for field: + * {@snippet lang=c : + * MagickRealType alpha + * } + */ + public static final long alpha$offset() { + return alpha$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * MagickRealType alpha + * } + */ + public static double alpha(MemorySegment struct) { + return struct.get(alpha$LAYOUT, alpha$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * MagickRealType alpha + * } + */ + public static void alpha(MemorySegment struct, double fieldValue) { + struct.set(alpha$LAYOUT, alpha$OFFSET, fieldValue); + } + + private static final OfDouble index$LAYOUT = (OfDouble)$LAYOUT.select(groupElement("index")); + + /** + * Layout for field: + * {@snippet lang=c : + * MagickRealType index + * } + */ + public static final OfDouble index$layout() { + return index$LAYOUT; + } + + private static final long index$OFFSET = 80; + + /** + * Offset for field: + * {@snippet lang=c : + * MagickRealType index + * } + */ + public static final long index$offset() { + return index$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * MagickRealType index + * } + */ + public static double index(MemorySegment struct) { + return struct.get(index$LAYOUT, index$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * MagickRealType index + * } + */ + public static void index(MemorySegment struct, double fieldValue) { + struct.set(index$LAYOUT, index$OFFSET, fieldValue); + } + + /** + * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}. + * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()} + */ + public static MemorySegment asSlice(MemorySegment array, long index) { + return array.asSlice(layout().byteSize() * index); + } + + /** + * The size (in bytes) of this struct + */ + public static long sizeof() { return layout().byteSize(); } + + /** + * Allocate a segment of size {@code layout().byteSize()} using {@code allocator} + */ + public static MemorySegment allocate(SegmentAllocator allocator) { + return allocator.allocate(layout()); + } + + /** + * Allocate an array of size {@code elementCount} using {@code allocator}. + * The returned segment has size {@code elementCount * layout().byteSize()}. + */ + public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) { + return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout())); + } + + /** + * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction} (if any). + * The returned segment has size {@code layout().byteSize()} + */ + public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer cleanup) { + return reinterpret(addr, 1, arena, cleanup); + } + + /** + * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction} (if any). + * The returned segment has size {@code elementCount * layout().byteSize()} + */ + public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer cleanup) { + return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup); + } +} + diff --git a/lib/src/main/java/app/photofox/imffm/generated/_RectangleInfo.java b/lib/src/main/java/app/photofox/imffm/generated/_RectangleInfo.java new file mode 100644 index 0000000..be4f4d8 --- /dev/null +++ b/lib/src/main/java/app/photofox/imffm/generated/_RectangleInfo.java @@ -0,0 +1,265 @@ +// Generated by jextract + +package app.photofox.imffm.generated; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * struct _RectangleInfo { + * size_t width; + * size_t height; + * ssize_t x; + * ssize_t y; + * } + * } + */ +public class _RectangleInfo { + + _RectangleInfo() { + // Should not be called directly + } + + private static final GroupLayout $LAYOUT = MemoryLayout.structLayout( + MagickWand_h.C_LONG.withName("width"), + MagickWand_h.C_LONG.withName("height"), + MagickWand_h.C_LONG.withName("x"), + MagickWand_h.C_LONG.withName("y") + ).withName("_RectangleInfo"); + + /** + * The layout of this struct + */ + public static final GroupLayout layout() { + return $LAYOUT; + } + + private static final OfLong width$LAYOUT = (OfLong)$LAYOUT.select(groupElement("width")); + + /** + * Layout for field: + * {@snippet lang=c : + * size_t width + * } + */ + public static final OfLong width$layout() { + return width$LAYOUT; + } + + private static final long width$OFFSET = 0; + + /** + * Offset for field: + * {@snippet lang=c : + * size_t width + * } + */ + public static final long width$offset() { + return width$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * size_t width + * } + */ + public static long width(MemorySegment struct) { + return struct.get(width$LAYOUT, width$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * size_t width + * } + */ + public static void width(MemorySegment struct, long fieldValue) { + struct.set(width$LAYOUT, width$OFFSET, fieldValue); + } + + private static final OfLong height$LAYOUT = (OfLong)$LAYOUT.select(groupElement("height")); + + /** + * Layout for field: + * {@snippet lang=c : + * size_t height + * } + */ + public static final OfLong height$layout() { + return height$LAYOUT; + } + + private static final long height$OFFSET = 8; + + /** + * Offset for field: + * {@snippet lang=c : + * size_t height + * } + */ + public static final long height$offset() { + return height$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * size_t height + * } + */ + public static long height(MemorySegment struct) { + return struct.get(height$LAYOUT, height$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * size_t height + * } + */ + public static void height(MemorySegment struct, long fieldValue) { + struct.set(height$LAYOUT, height$OFFSET, fieldValue); + } + + private static final OfLong x$LAYOUT = (OfLong)$LAYOUT.select(groupElement("x")); + + /** + * Layout for field: + * {@snippet lang=c : + * ssize_t x + * } + */ + public static final OfLong x$layout() { + return x$LAYOUT; + } + + private static final long x$OFFSET = 16; + + /** + * Offset for field: + * {@snippet lang=c : + * ssize_t x + * } + */ + public static final long x$offset() { + return x$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * ssize_t x + * } + */ + public static long x(MemorySegment struct) { + return struct.get(x$LAYOUT, x$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * ssize_t x + * } + */ + public static void x(MemorySegment struct, long fieldValue) { + struct.set(x$LAYOUT, x$OFFSET, fieldValue); + } + + private static final OfLong y$LAYOUT = (OfLong)$LAYOUT.select(groupElement("y")); + + /** + * Layout for field: + * {@snippet lang=c : + * ssize_t y + * } + */ + public static final OfLong y$layout() { + return y$LAYOUT; + } + + private static final long y$OFFSET = 24; + + /** + * Offset for field: + * {@snippet lang=c : + * ssize_t y + * } + */ + public static final long y$offset() { + return y$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * ssize_t y + * } + */ + public static long y(MemorySegment struct) { + return struct.get(y$LAYOUT, y$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * ssize_t y + * } + */ + public static void y(MemorySegment struct, long fieldValue) { + struct.set(y$LAYOUT, y$OFFSET, fieldValue); + } + + /** + * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}. + * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()} + */ + public static MemorySegment asSlice(MemorySegment array, long index) { + return array.asSlice(layout().byteSize() * index); + } + + /** + * The size (in bytes) of this struct + */ + public static long sizeof() { return layout().byteSize(); } + + /** + * Allocate a segment of size {@code layout().byteSize()} using {@code allocator} + */ + public static MemorySegment allocate(SegmentAllocator allocator) { + return allocator.allocate(layout()); + } + + /** + * Allocate an array of size {@code elementCount} using {@code allocator}. + * The returned segment has size {@code elementCount * layout().byteSize()}. + */ + public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) { + return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout())); + } + + /** + * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction} (if any). + * The returned segment has size {@code layout().byteSize()} + */ + public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer cleanup) { + return reinterpret(addr, 1, arena, cleanup); + } + + /** + * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction} (if any). + * The returned segment has size {@code elementCount * layout().byteSize()} + */ + public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer cleanup) { + return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup); + } +} +