/**
* Call MapImages.
*
* Ruby usage:
* - @verbatim ImageList#map(reference) @endverbatim
* - @verbatim ImageList#map(reference, dither) @endverbatim
*
* Notes:
* - Default dither is false
* - Sets \@scene to self.scene
*
* @param argc number of input arguments
* @param argv array of input arguments
* @param self this object
* @return a new ImageList with mapped images.
*/
VALUE
ImageList_map(int argc, VALUE *argv, VALUE self)
{
Image *images, *new_images = NULL;
Image *map;
unsigned int dither = MagickFalse;
VALUE scene, new_imagelist, t;
ExceptionInfo *exception;
#if defined(HAVE_REMAPIMAGES)
QuantizeInfo quantize_info;
rb_warning("ImageList#map is deprecated. Use ImageList#remap instead.");
#endif
switch (argc)
{
case 2:
dither = RTEST(argv[1]);
case 1:
t = rm_cur_image(argv[0]);
map = rm_check_destroyed(t);
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc);
break;
}
// Convert image array to image sequence, clone image sequence.
exception = AcquireExceptionInfo();
images = images_from_imagelist(self);
new_images = CloneImageList(images, exception);
rm_split(images);
rm_check_exception(exception, new_images, DestroyOnError);
(void) DestroyExceptionInfo(exception);
rm_ensure_result(new_images);
// Call ImageMagick
#if defined(HAVE_REMAPIMAGES)
GetQuantizeInfo(&quantize_info);
quantize_info.dither = dither;
(void) RemapImages(&quantize_info, new_images, map);
#else
(void) MapImages(new_images, map, dither);
#endif
rm_check_image_exception(new_images, DestroyOnError);
// Set @scene in new ImageList object to same value as in self.
new_imagelist = rm_imagelist_from_images(new_images);
scene = rb_iv_get(self, "@scene");
(void) imagelist_scene_eq(new_imagelist, scene);
RB_GC_GUARD(scene);
RB_GC_GUARD(new_imagelist);
RB_GC_GUARD(t);
return new_imagelist;
}
/**
* Call RemapImages.
*
* Ruby usage:
* - @verbatim ImageList#remap @endverbatim
* - @verbatim ImageList#remap(remap_image) @endverbatim
* - @verbatim ImageList#remap(remap_image, dither_method) @endverbatim
*
* Notes:
* - Default remap_image is nil
* - Default dither_method is RiemersmaDitherMethod
* - Modifies images in-place.
*
* @param argc number of input arguments
* @param argv array of input arguments
* @param self this object
* @see Image_remap
*/
VALUE
ImageList_remap(int argc, VALUE *argv, VALUE self)
{
#if defined(HAVE_REMAPIMAGES) || defined(HAVE_AFFINITYIMAGES)
Image *images, *remap_image = NULL;
QuantizeInfo quantize_info;
if (argc > 0 && argv[0] != Qnil)
{
VALUE t = rm_cur_image(argv[0]);
remap_image = rm_check_destroyed(t);
RB_GC_GUARD(t);
}
GetQuantizeInfo(&quantize_info);
if (argc > 1)
{
VALUE_TO_ENUM(argv[1], quantize_info.dither_method, DitherMethod);
quantize_info.dither = MagickTrue;
}
if (argc > 2)
{
rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc);
}
images = images_from_imagelist(self);
#if defined(HAVE_REMAPIMAGE)
(void) RemapImages(&quantize_info, images, remap_image);
#else
(void) AffinityImages(&quantize_info, images, remap_image);
#endif
rm_check_image_exception(images, RetainOnError);
rm_split(images);
return self;
#else
self = self;
argc = argc;
argv = argv;
rm_not_implemented();
return(VALUE)0;
#endif
}
/**
* Equivalent to -layers option in ImageMagick 6.2.6.
*
* Ruby usage:
* - @verbatim ImageList#optimize_layers(method) @endverbatim
*
* @param self this object
* @param method the method to use
* @return a new imagelist
*/
VALUE
ImageList_optimize_layers(VALUE self, VALUE method)
{
Image *images, *new_images, *new_images2;
LAYERMETHODTYPE mthd;
ExceptionInfo *exception;
QuantizeInfo quantize_info;
new_images2 = NULL; // defeat "unused variable" message
exception = AcquireExceptionInfo();
#if defined(HAVE_TYPE_IMAGELAYERMETHOD)
VALUE_TO_ENUM(method, mthd, ImageLayerMethod);
#else
VALUE_TO_ENUM(method, mthd, MagickLayerMethod);
#endif
images = images_from_imagelist(self);
switch (mthd)
{
case CoalesceLayer:
new_images = CoalesceImages(images, exception);
break;
case DisposeLayer:
new_images = DisposeImages(images, exception);
break;
case OptimizeTransLayer:
new_images = clone_imagelist(images);
OptimizeImageTransparency(new_images, exception);
break;
case RemoveDupsLayer:
new_images = clone_imagelist(images);
RemoveDuplicateLayers(&new_images, exception);
break;
case RemoveZeroLayer:
new_images = clone_imagelist(images);
RemoveZeroDelayLayers(&new_images, exception);
break;
case CompositeLayer:
rm_split(images);
rb_raise(rb_eNotImpError, "Magick::CompositeLayer is not supported. Use the composite_layers method instead.");
break;
// In 6.3.4-ish, OptimizeImageLayer replaced OptimizeLayer
case OptimizeImageLayer:
new_images = OptimizeImageLayers(images, exception);
break;
// and OptimizeLayer became a "General Purpose, GIF Animation Optimizer" (ref. mogrify.c)
case OptimizeLayer:
new_images = CoalesceImages(images, exception);
rm_split(images);
rm_check_exception(exception, new_images, DestroyOnError);
new_images2 = OptimizeImageLayers(new_images, exception);
DestroyImageList(new_images);
rm_check_exception(exception, new_images2, DestroyOnError);
new_images = new_images2;
OptimizeImageTransparency(new_images, exception);
rm_check_exception(exception, new_images, DestroyOnError);
// mogrify supports -dither here. We don't.
#if defined(HAVE_REMAPIMAGE)
GetQuantizeInfo(&quantize_info);
(void) RemapImages(&quantize_info, new_images, NULL);
#else
(void) MapImages(new_images, NULL, 0);
#endif
break;
case OptimizePlusLayer:
new_images = OptimizePlusImageLayers(images, exception);
break;
case CompareAnyLayer:
case CompareClearLayer:
case CompareOverlayLayer:
new_images = CompareImageLayers(images, mthd, exception);
break;
#if defined(HAVE_ENUM_MOSAICLAYER)
case MosaicLayer:
new_images = MergeImageLayers(images, mthd, exception);
break;
#endif
#if defined(HAVE_ENUM_FLATTENLAYER)
case FlattenLayer:
new_images = MergeImageLayers(images, mthd, exception);
break;
#endif
#if defined(HAVE_ENUM_MERGELAYER)
case MergeLayer:
new_images = MergeImageLayers(images, mthd, exception);
break;
#endif
#if defined(HAVE_ENUM_TRIMBOUNDSLAYER)
case TrimBoundsLayer:
new_images = MergeImageLayers(images, mthd, exception);
break;
#endif
default:
rm_split(images);
rb_raise(rb_eArgError, "undefined layer method");
break;
}
rm_split(images);
rm_check_exception(exception, new_images, DestroyOnError);
(void) DestroyExceptionInfo(exception);
rm_ensure_result(new_images);
return rm_imagelist_from_images(new_images);
}
void *
gif_encode(Image *image, int single, int *size)
{
int width = image->columns;
int height = image->rows;
int total = width * height;
GifByteType red[total];
GifByteType green[total];
GifByteType blue[total];
// Quantize the images using IM/GM first, to reduce
// their number of colors to 256.
int count = GetImageListLength(image);
QuantizeInfo info;
GetQuantizeInfo(&info);
info.dither = 0;
info.number_colors = NCOLORS;
QuantizeImage(&info, image);
if (count > 1) {
#ifdef _MAGICK_USES_IM
RemapImages(&info, image->next, image);
#else
MapImages(image->next, image, 0);
#endif
}
if (!acquire_image_pixels(image, red, green, blue)) {
return NULL;
}
size_t frame_size = sizeof(Frame) + total;
Frame *frames = malloc(frame_size * count);
ColorMapObject *palette = GifMakeMapObject(NCOLORS, NULL);
int palette_size = NCOLORS;
// Quantize again using giflib, since it yields a palette which produces
// better compression, reducing the file size by 20%. Note that this second
// quantization is very fast, because the image already has 256 colors, so
// its effect on performance is negligible.
if (GifQuantizeBuffer(width, height, &palette_size, red, green, blue, frames->data, palette->Colors) == GIF_ERROR) {
GifFreeMapObject(palette);
free(frames);
return NULL;
}
frames->width = width;
frames->height = height;
frames->duration = image->delay;
GifColorType *colors = palette->Colors;
Image *cur = image->next;
PixelCache *cache = pixel_cache_new();
unsigned char *p = (unsigned char*)frames;
int ii;
for (ii = 1; ii < count; ii++, cur = cur->next) {
p += frame_size;
Frame *frame = (Frame*)p;
frame->width = width;
frame->height = height;
frame->duration = cur->delay;
GifPixelType *data = frame->data;
if (!aprox_image_pixels(cur, colors, palette_size, cache, data)) {
GifFreeMapObject(palette);
free(frames);
pixel_cache_free(cache);
return NULL;
}
}
pixel_cache_free(cache);
void *ret = gif_save(image, palette, frames, count, frame_size, size);
GifFreeMapObject(palette);
free(frames);
return ret;
}
