/* save image to file */ static gboolean _save(struct data *data, MagickWand *wand, const gchar *uri) { gchar *desc; guchar *img_data; gsize img_len; ExceptionType severity; g_debug("in _save"); g_assert(data != NULL); g_assert(wand != NULL); g_assert(uri != NULL); if (data->gal->remove_exif && !MagickStripImage(wand)) { desc = MagickGetException(wand, &severity); g_warning("_save: error stripping image: %s\n", desc); desc = (char *) MagickRelinquishMemory(desc); } img_data = MagickGetImagesBlob(wand, &img_len); vfs_write_file(data, uri, img_data, img_len); MagickRelinquishMemory(img_data); return TRUE; }
/* Check the magick_wand is not empty. If it's empty and raise an exception */ void c_Gmagick::checkHasFormat() { char *buffer = MagickGetImageFormat(magick_wand); if (!buffer || *buffer == '\0') { MagickRelinquishMemory(buffer); throwException("Image has no format", ImageError); } else { MagickRelinquishMemory(buffer); } }
void save_image(ConvertContext *context) { int result = RESULT_OK; char *error_desc; ExceptionType error_type; // get pixel data if (context->hasAlphaChannel == MagickTrue) { if (MagickImportImagePixels(context->mw, 0, 0, context->imageWidth, context->imageHeight, "ARGB", CharPixel, context->pixels) == MagickFalse) { error_desc = MagickGetException(context->mw, &error_type); asprintf(&context->results.message, "Error exporting pixel data (%s): %s\n",error_desc,context->src_path); error_desc = (char *)MagickRelinquishMemory(error_desc); result += RESULT_ERROR; } } // convert image to PNG if (result == RESULT_OK) { if (MagickSetImageFormat(context->mw,"PNG") == MagickFalse) { error_desc = MagickGetException(context->mw, &error_type); asprintf(&context->results.message,"Error converting image (%s): %s\n",error_desc,context->src_path); error_desc = (char *)MagickRelinquishMemory(error_desc); result += RESULT_ERROR; } } // activate/deactivate alpha channel MagickSetImageAlphaChannel(context->mw, (context->results.alpha_type == ALPHA_TYPE_NONE ? DeactivateAlphaChannel : ActivateAlphaChannel)); // make sure image is saved as RGB and not crunched down to grayscale MagickSetType(context->mw, (context->results.alpha_type == ALPHA_TYPE_NONE ? TrueColorType : TrueColorMatteType)); // save image to disk if (result == RESULT_OK) { if (MagickWriteImage(context->mw, context->dst_path) == MagickFalse) { error_desc = MagickGetException(context->mw, &error_type); asprintf(&context->results.message, "Error saving image (%s): %s\n",error_desc,context->dst_path); error_desc = (char *)MagickRelinquishMemory(error_desc); result += RESULT_ERROR; } } if (result == RESULT_OK && context->options.delete_original != 0) { if (unlink(context->src_path) == -1) { asprintf(&context->results.message, "Unable to delete original image (%s): %s\n", strerror(errno), context->src_path); result += RESULT_ERROR; } } // cleanup and report results context->results.result = result; dispatch_group_async_f(context->conv_group, dispatch_get_main_queue(), context, (void (*)(void *))finish_image); }
/* * Apply image modifications (rotate, gamma, etc) to the * image. Resizing to web image or thumbnail is done afterwards */ static gboolean _apply_modifications(struct data *data, MagickWand *wand, struct image *image) { gchar *desc; ExceptionType severity; g_debug("in _apply_modifications"); g_assert(data != NULL); g_assert(wand != NULL); g_assert(image != NULL); /* rotate image */ if (image->rotate) { PixelWand *px; px = NewPixelWand(); g_assert(px); PixelSetColor(px, "blue"); if( !MagickRotateImage(wand, px, image->rotate)) { desc = MagickGetException(wand, &severity); /* FIXME: popup */ g_warning("_apply_modifications: " "error rotating image: %s\n", desc); ClearPixelWand(px); desc = (char *) MagickRelinquishMemory(desc); return FALSE; } DestroyPixelWand( px ); } /* Apply gamma, if over changed over 0.01 */ if (image->gamma <= 0.99 || image->gamma >= 1.01) { if (!MagickGammaImage(wand, image->gamma)) { desc = MagickGetException(wand, &severity); /* FIXME: popup */ g_warning("_apply_modifications: " "error setting gamma (%.2f) of image: %s\n", image->gamma, desc); desc = (char *) MagickRelinquishMemory(desc); return FALSE; } } return TRUE; }
void load_image(ConvertContext *context) { int result = RESULT_OK; char *error_desc; ExceptionType error_type; // wait for resources to be available dispatch_semaphore_wait(context->conv_semaphore, DISPATCH_TIME_FOREVER); // load image if (MagickReadImage(context->mw, context->src_path) == MagickFalse) { // deal with error error_desc = MagickGetException(context->mw, &error_type); asprintf(&context->results.message,"Error loading image (%s): %s\n",error_desc,context->src_path); error_desc = (char *)MagickRelinquishMemory(error_desc); result += RESULT_ERROR; } if (result == RESULT_OK) { // get image info context->hasAlphaChannel = MagickGetImageAlphaChannel(context->mw); if (context->hasAlphaChannel == MagickTrue) { context->imageWidth = MagickGetImageWidth(context->mw); context->imageHeight = MagickGetImageHeight(context->mw); // get pixel data context->pixel_count = context->imageWidth * context->imageHeight; context->pixels = malloc(context->pixel_count * sizeof(PixelData)); if (context->pixels == NULL) { asprintf(&context->results.message, "Error allocating memory for pixel data: %s\n",context->src_path); result += RESULT_ERROR; } else { if (MagickExportImagePixels(context->mw, 0, 0, context->imageWidth, context->imageHeight, "ARGB", CharPixel, context->pixels) == MagickFalse) { error_desc = MagickGetException(context->mw, &error_type); asprintf(&context->results.message, "Error exporting pixel data (%s): %s\n",error_desc,context->src_path); error_desc = (char *)MagickRelinquishMemory(error_desc); result += RESULT_ERROR; } } } } if (result != RESULT_OK) { // clean up mess context->results.result = result; dispatch_group_async_f(context->conv_group, dispatch_get_main_queue(), context, (void (*)(void *))finish_image); } else { // move to next step dispatch_group_async_f(context->conv_group, context->conv_queue, context, (void (*)(void *))conv_image); } }
/* * Resize image. */ static gboolean _resize(struct data *data, MagickWand *wand, struct image *image, gint width, gint height) { gchar *desc; ExceptionType severity; g_debug("in _resize"); g_assert(data != NULL); g_assert(wand != NULL); g_assert(image != NULL); /* CHECKME: 1.0 ok? LanczosFilter ok? */ if (!MagickResizeImage(wand, width, height, LanczosFilter, 1.0 ) ) { desc = MagickGetException(wand, &severity); g_warning("_resize: error resizing image: %s\n", desc); desc = (char *) MagickRelinquishMemory(desc); return FALSE; } /* FIXME: MagickUnsharpMaskImage */ return TRUE; }
/* * Load image to image magic */ static gboolean _load_image(struct data *data, MagickWand *wand, struct image *image) { gchar *desc; ExceptionType severity; guchar *img_data; gsize img_len; g_debug("in _load_image"); g_assert(data != NULL); g_assert(wand != NULL); g_assert(image != NULL); /* Read image from file to memory */ vfs_read_file(data, image->uri, &img_data, &img_len); /* Read image to image magick */ if (!MagickReadImageBlob(wand, img_data, img_len)) { desc = MagickGetException(wand, &severity) ; /* FIXME: popup */ g_warning("_load_image: error reading image: %s\n", desc); g_free(img_data); desc = (char *) MagickRelinquishMemory(desc); return FALSE; } g_free(img_data); return TRUE; }
caddr_t im_write (im_env_t *env) { if (env->ime_output_filename) { env->ime_status = MagickWriteImages (env->ime_magick_wand, env->ime_output_filename, MagickTrue); if (env->ime_status == MagickFalse) im_leave_with_error (env, "22023", "IM001", "Cannot write to file \"%.1000s\"", env->ime_output_filename); return NULL; } else { size_t length = 0; caddr_t image_blob = MagickGetImagesBlob (env->ime_magick_wand, &length); caddr_t res; if (length != 0) { res = dk_alloc_box (length, DV_BIN); memcpy (res, image_blob, length); MagickRelinquishMemory (image_blob); } else res = NEW_DB_NULL; return res; } }
// magick_set_exception {{{ PyObject* magick_set_exception(MagickWand *wand) { ExceptionType ext; char *desc = MagickGetException(wand, &ext); PyErr_SetString(PyExc_Exception, desc); MagickClearException(wand); desc = MagickRelinquishMemory(desc); return NULL; }
void ThrowWandException(MagickWand *wand) { char *description; ExceptionType severity; description = MagickGetException(wand, &severity); (void) fprintf(stderr,"%s %s %lu %s\n",GetMagickModule(),description); description=(char *) MagickRelinquishMemory(description); exit(-1); }
int main(int argc, char *argv[]) { MagickWand *wand = NULL; MagickBooleanType ret; char *description; ExceptionType excep; if (argc < 2) { fprintf(stderr, "Usage: %s file\n", argv[0]); return 1; } MagickWandGenesis(); wand = NewMagickWand(); if (wand == NULL) { description = MagickGetException(wand, &excep); fprintf(stderr, "%s; %s\n", "NewMagickWand() failed", description); MagickRelinquishMemory(description); return 1; } ret = MagickReadImage(wand, argv[1]); if (ret != MagickTrue) { description = MagickGetException(wand, &excep); fprintf(stderr, "%s; %s\n", "MagickReadImage() failed", description); MagickRelinquishMemory(description); return 1; } printf("Format: %s\n", MagickGetImageFormat(wand)); printf("Filename: %s\n", MagickGetImageFilename(wand)); printf("Compression Quality: %ld\n", MagickGetCompressionQuality(wand)); printf("Signature: %s\n", MagickGetImageSignature(wand)); printf("Width: %ld\n", MagickGetImageWidth(wand)); printf("Height: %ld\n", MagickGetImageHeight(wand)); if (wand != NULL) { DestroyMagickWand(wand); } MagickWandTerminus(); return 0; }
char* get_phone_img(const char *phone_str, size_t *img_size){ if(phone_str == NULL){ return NULL; } MagickWand *m_wand = NULL; PixelWand *p_wand = NULL; DrawingWand *d_wand = NULL; /* Create a wand */ m_wand = NewMagickWand(); p_wand = NewPixelWand(); d_wand = NewDrawingWand(); PixelSetColor(p_wand,"white"); int height = 18; int width = strlen(phone_str) * 130 / 12; MagickNewImage(m_wand, width,height ,p_wand); //draw number PixelSetColor(p_wand,"black"); DrawSetFillColor(d_wand,p_wand); DrawSetFont (d_wand, "Arial" ) ; DrawSetFontSize(d_wand,20); DrawSetStrokeColor(d_wand,p_wand); DrawAnnotation(d_wand,0,height -2,phone_str); MagickDrawImage(m_wand,d_wand); //MagickTrimImage(m_wand,0); //ImageFormat MUST be SET,otherwise,otherwise we will not MagickGetImageBlob properly MagickSetImageFormat(m_wand,"JPEG"); char *p = NULL; char *data = NULL; p = (char *)MagickGetImageBlob(m_wand,img_size); if(p != NULL){ data = (char *)malloc(*img_size); if(data != NULL){ memcpy(data,p,*img_size); }else{ LOG_PRINT(LOG_INFO, "malloc Failed!"); } }else{ LOG_PRINT(LOG_INFO, "MagickGetImageBlob Failed!"); } /* Tidy up */ MagickRelinquishMemory(p); DestroyMagickWand(m_wand); DestroyPixelWand(p_wand); return data; }
void iac_image_exception(const MagickWand *wand) { char *desc; ExceptionType severity; desc = MagickGetException(wand, &severity); fprintf(stderr, "%s %s %ld %s\n", GetMagickModule(), desc); desc = (char *) MagickRelinquishMemory(desc); }
/** * ImageMagick error-handler */ void im_error(MagickWand *wand) { #if HAVE_IMAGEMAGICK == 1 char *description; ExceptionType severity; description = MagickGetException(wand, &severity); NFT_LOG(L_ERROR, "%s %s %lu %s\n", GetMagickModule(), description); description = (char *) MagickRelinquishMemory(description); #endif }
static size_t blob_write( unsigned char *blob_in, size_t size_in, MagickWand *mw_out, const char *dst) { /* output image... */ size_t size_out = (size_t)-1; unsigned char *blob_out = MagickGetImageBlob(mw_out, &size_out); if (size_out > size_in) { /* results worse than original, output original input */ (void) MagickRelinquishMemory(blob_out); blob_out = blob_in; size_out = size_in; } { int fd; if (0 == strcmp("-", dst)) { fd = STDOUT_FILENO; } else { fd = creat(dst, 0644); if (-1 == fd) { perror("open"); exit(1); } } if ((ssize_t)size_out != write(fd, blob_out, size_out)) { perror("write"); exit(1); } if (blob_out != blob_in) (void) MagickRelinquishMemory(blob_out); if (fd != STDOUT_FILENO) close(fd); } return size_out; }
Handle<Value> MerlinImage::WriteImage(MagickWand *wand) { size_t length; unsigned char* data = MagickWriteImageBlob(wand, &length); node::Buffer *buf = node::Buffer::New(length); char *buff_data = BufferData(buf); memcpy(buff_data, data, length); MagickRelinquishMemory(data); DestroyMagickWand(wand); v8::Handle<v8::Value> argv[1] = {buf->handle_}; return MerlinImage::constructor_template->GetFunction()->NewInstance(1, argv); }
void ngx_http_small_light_imagemagick_term(void *data) { ngx_http_small_light_ctx_t *ctx; ngx_http_small_light_imagemagick_ctx_t *ictx; ctx = (ngx_http_small_light_ctx_t *)data; ictx = (ngx_http_small_light_imagemagick_ctx_t *)ctx->ictx; if (ictx->complete) { MagickRelinquishMemory(ctx->content); } DestroyMagickWand(ictx->wand); }
int fuppes_transcoder_transcode_image_mem(plugin_info* plugin, const unsigned char** inBuffer, size_t inSize, unsigned char** outBuffer, size_t* outSize, int width, int height, int less, int greater) { MagickBooleanType status; MagickWand* wand = NewMagickWand(); //printf("magickWand %d\n", 1); status = MagickReadImageBlob(wand, *inBuffer, inSize); if(status == MagickFalse) { plugin->cb.log(plugin, 0, __FILE__, __LINE__, "error reading image from buffer. size: %d", inSize); wand = DestroyMagickWand(wand); return -1; } //printf("magickWand %d\n", 2); MagickWand* wandOut; char geometry[123]; sprintf(&geometry, "%dx%d", width, height); //char* geometry = "250x250"; wandOut = MagickTransformImage(wand, "", geometry); wand = DestroyMagickWand(wand); if(wandOut == NULL) { return -1; } //printf("magickWand %d\n", 3); //MagickBooleanType MagickSetFormat(MagickWand *wand,const char *format) size_t length; unsigned char* blob; blob = MagickGetImageBlob(wandOut, &length); *outBuffer = realloc(*outBuffer, length); memcpy(*outBuffer, blob, length); *outSize = length; MagickRelinquishMemory(blob); //printf("magickWand %d, %d\n", 4, *outSize); //MagickRelinquishMemory(wandOut); wandOut = DestroyMagickWand(wandOut); return 0; }
void set_mw_err(MagickWand* magick_wand, dhash_err* error) { fprintf(stderr, "called set_mw_err"); ExceptionType severity; char* description; char* err_description; description = MagickGetException(magick_wand, &severity); err_description = (char*) malloc(sizeof(char) * strlen(description) + 1); strcpy(err_description, description); description = (char *) MagickRelinquishMemory(description); error->err_type = IMAGE_MAGICK_ERROR; if (error->description) { free(error->description); } error->description = err_description; }
String c_Gmagick::t_getimageprofile(CStrRef profile) { INSTANCE_METHOD_INJECTION_BUILTIN(Gmagick, Gmagick::getimageprofile); checkNotEmpty(); size_t profile_size; unsigned char *ret_profile = MagickGetImageProfile(magick_wand, profile.data(), &profile_size); if (!ret_profile) { return null; } String ret((char *)ret_profile, profile_size, CopyString); MagickRelinquishMemory(ret_profile); return ret; }
// Returns the current image sequence as a string String c_Gmagick::t_getimageblob() { INSTANCE_METHOD_INJECTION_BUILTIN(Gmagick, Gmagick::getimageblob); unsigned char * image_contents; size_t image_size; checkNotEmpty(); checkHasFormat(); MagickResetIterator(magick_wand); image_contents = MagickWriteImageBlob(magick_wand, &image_size); if (!image_contents) { return null; } String ret((const char *)image_contents, image_size, CopyString); MagickRelinquishMemory(image_contents); return ret; }
void probe_im(info_t *ipipe) { MagickWand *wand = NULL; MagickBooleanType status; MagickWandGenesis(); wand = NewMagickWand(); if (wand == NULL) { tc_log_error(__FILE__, "cannot create magick wand"); ipipe->error = 1; return; } status = MagickReadImage(wand, ipipe->name); if (status == MagickFalse) { ExceptionType severity; const char *description = MagickGetException(wand, &severity); tc_log_error(__FILE__, "%s", description); MagickRelinquishMemory((void*)description); ipipe->error = 1; return; } MagickSetLastIterator(wand); /* read all video parameter from input file */ ipipe->probe_info->width = MagickGetImageWidth(wand); ipipe->probe_info->height = MagickGetImageHeight(wand); /* slide show? */ ipipe->probe_info->frc = 9; /* FRC for 1 fps */ ipipe->probe_info->fps = 1.0; ipipe->probe_info->magic = ipipe->magic; ipipe->probe_info->codec = TC_CODEC_RGB24; DestroyMagickWand(wand); MagickWandTerminus(); return; }
static inline int dump_error(MagickWand *wand) { char *desc; ExceptionType severity; desc = MagickGetException(wand, &severity); if(severity >= FatalErrorException) exit_code = 2; else if(severity >= ErrorException) exit_code = 1; else exit_code = 0; static const char *sevdesc[] = { "WARNING", "ERROR", "FATAL" }; fprintf(stderr, "%s: %s\n", sevdesc[exit_code], desc); MagickRelinquishMemory(desc); return(exit_code); }
static PyObject * im_GetImageBlob(PyObject *self, PyObject *args) { void *magick_pointer; MagickWand *magick_wand; unsigned char *blob; size_t length; PyObject *ret; if (!PyArg_ParseTuple(args, "O", &magick_pointer)){ return Py_BuildValue("i", 0); } magick_wand = (MagickWand *) PyCObject_AsVoidPtr(magick_pointer); blob = MagickGetImagesBlob(magick_wand, &length); ret = Py_BuildValue("s#", blob, length); MagickRelinquishMemory(blob); return ret; }
int main(int argc,char **argv) { #define ThrowAPIException(wand) \ { \ description=MagickGetException(wand,&severity); \ (void) FormatLocaleFile(stderr,"%s %s %lu %s\n",GetMagickModule(), \ description); \ description=(char *) MagickRelinquishMemory(description); \ exit(-1); \ } static char CustomOption[] = "custom option", CustomProperty[] = "custom profile"; static unsigned char sRGBProfile[] = { 0x00, 0x00, 0x0c, 0x48, 0x4c, 0x69, 0x6e, 0x6f, 0x02, 0x10, 0x00, 0x00, 0x6d, 0x6e, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20, 0x07, 0xce, 0x00, 0x02, 0x00, 0x09, 0x00, 0x06, 0x00, 0x31, 0x00, 0x00, 0x61, 0x63, 0x73, 0x70, 0x4d, 0x53, 0x46, 0x54, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x43, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d, 0x48, 0x50, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x00, 0x33, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x84, 0x00, 0x00, 0x00, 0x6c, 0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0xf0, 0x00, 0x00, 0x00, 0x14, 0x62, 0x6b, 0x70, 0x74, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14, 0x72, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x18, 0x00, 0x00, 0x00, 0x14, 0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x2c, 0x00, 0x00, 0x00, 0x14, 0x62, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x14, 0x64, 0x6d, 0x6e, 0x64, 0x00, 0x00, 0x02, 0x54, 0x00, 0x00, 0x00, 0x70, 0x64, 0x6d, 0x64, 0x64, 0x00, 0x00, 0x02, 0xc4, 0x00, 0x00, 0x00, 0x88, 0x76, 0x75, 0x65, 0x64, 0x00, 0x00, 0x03, 0x4c, 0x00, 0x00, 0x00, 0x86, 0x76, 0x69, 0x65, 0x77, 0x00, 0x00, 0x03, 0xd4, 0x00, 0x00, 0x00, 0x24, 0x6c, 0x75, 0x6d, 0x69, 0x00, 0x00, 0x03, 0xf8, 0x00, 0x00, 0x00, 0x14, 0x6d, 0x65, 0x61, 0x73, 0x00, 0x00, 0x04, 0x0c, 0x00, 0x00, 0x00, 0x24, 0x74, 0x65, 0x63, 0x68, 0x00, 0x00, 0x04, 0x30, 0x00, 0x00, 0x00, 0x0c, 0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c, 0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c, 0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c, 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x28, 0x63, 0x29, 0x20, 0x31, 0x39, 0x39, 0x38, 0x20, 0x48, 0x65, 0x77, 0x6c, 0x65, 0x74, 0x74, 0x2d, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x6e, 0x79, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47, 0x42, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47, 0x42, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf3, 0x51, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x16, 0xcc, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6f, 0xa2, 0x00, 0x00, 0x38, 0xf5, 0x00, 0x00, 0x03, 0x90, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x99, 0x00, 0x00, 0xb7, 0x85, 0x00, 0x00, 0x18, 0xda, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0xa0, 0x00, 0x00, 0x0f, 0x84, 0x00, 0x00, 0xb6, 0xcf, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47, 0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x2d, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47, 0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x2d, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x69, 0x65, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xa4, 0xfe, 0x00, 0x14, 0x5f, 0x2e, 0x00, 0x10, 0xcf, 0x14, 0x00, 0x03, 0xed, 0xcc, 0x00, 0x04, 0x13, 0x0b, 0x00, 0x03, 0x5c, 0x9e, 0x00, 0x00, 0x00, 0x01, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x09, 0x56, 0x00, 0x50, 0x00, 0x00, 0x00, 0x57, 0x1f, 0xe7, 0x6d, 0x65, 0x61, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x8f, 0x00, 0x00, 0x00, 0x02, 0x73, 0x69, 0x67, 0x20, 0x00, 0x00, 0x00, 0x00, 0x43, 0x52, 0x54, 0x20, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x0f, 0x00, 0x14, 0x00, 0x19, 0x00, 0x1e, 0x00, 0x23, 0x00, 0x28, 0x00, 0x2d, 0x00, 0x32, 0x00, 0x37, 0x00, 0x3b, 0x00, 0x40, 0x00, 0x45, 0x00, 0x4a, 0x00, 0x4f, 0x00, 0x54, 0x00, 0x59, 0x00, 0x5e, 0x00, 0x63, 0x00, 0x68, 0x00, 0x6d, 0x00, 0x72, 0x00, 0x77, 0x00, 0x7c, 0x00, 0x81, 0x00, 0x86, 0x00, 0x8b, 0x00, 0x90, 0x00, 0x95, 0x00, 0x9a, 0x00, 0x9f, 0x00, 0xa4, 0x00, 0xa9, 0x00, 0xae, 0x00, 0xb2, 0x00, 0xb7, 0x00, 0xbc, 0x00, 0xc1, 0x00, 0xc6, 0x00, 0xcb, 0x00, 0xd0, 0x00, 0xd5, 0x00, 0xdb, 0x00, 0xe0, 0x00, 0xe5, 0x00, 0xeb, 0x00, 0xf0, 0x00, 0xf6, 0x00, 0xfb, 0x01, 0x01, 0x01, 0x07, 0x01, 0x0d, 0x01, 0x13, 0x01, 0x19, 0x01, 0x1f, 0x01, 0x25, 0x01, 0x2b, 0x01, 0x32, 0x01, 0x38, 0x01, 0x3e, 0x01, 0x45, 0x01, 0x4c, 0x01, 0x52, 0x01, 0x59, 0x01, 0x60, 0x01, 0x67, 0x01, 0x6e, 0x01, 0x75, 0x01, 0x7c, 0x01, 0x83, 0x01, 0x8b, 0x01, 0x92, 0x01, 0x9a, 0x01, 0xa1, 0x01, 0xa9, 0x01, 0xb1, 0x01, 0xb9, 0x01, 0xc1, 0x01, 0xc9, 0x01, 0xd1, 0x01, 0xd9, 0x01, 0xe1, 0x01, 0xe9, 0x01, 0xf2, 0x01, 0xfa, 0x02, 0x03, 0x02, 0x0c, 0x02, 0x14, 0x02, 0x1d, 0x02, 0x26, 0x02, 0x2f, 0x02, 0x38, 0x02, 0x41, 0x02, 0x4b, 0x02, 0x54, 0x02, 0x5d, 0x02, 0x67, 0x02, 0x71, 0x02, 0x7a, 0x02, 0x84, 0x02, 0x8e, 0x02, 0x98, 0x02, 0xa2, 0x02, 0xac, 0x02, 0xb6, 0x02, 0xc1, 0x02, 0xcb, 0x02, 0xd5, 0x02, 0xe0, 0x02, 0xeb, 0x02, 0xf5, 0x03, 0x00, 0x03, 0x0b, 0x03, 0x16, 0x03, 0x21, 0x03, 0x2d, 0x03, 0x38, 0x03, 0x43, 0x03, 0x4f, 0x03, 0x5a, 0x03, 0x66, 0x03, 0x72, 0x03, 0x7e, 0x03, 0x8a, 0x03, 0x96, 0x03, 0xa2, 0x03, 0xae, 0x03, 0xba, 0x03, 0xc7, 0x03, 0xd3, 0x03, 0xe0, 0x03, 0xec, 0x03, 0xf9, 0x04, 0x06, 0x04, 0x13, 0x04, 0x20, 0x04, 0x2d, 0x04, 0x3b, 0x04, 0x48, 0x04, 0x55, 0x04, 0x63, 0x04, 0x71, 0x04, 0x7e, 0x04, 0x8c, 0x04, 0x9a, 0x04, 0xa8, 0x04, 0xb6, 0x04, 0xc4, 0x04, 0xd3, 0x04, 0xe1, 0x04, 0xf0, 0x04, 0xfe, 0x05, 0x0d, 0x05, 0x1c, 0x05, 0x2b, 0x05, 0x3a, 0x05, 0x49, 0x05, 0x58, 0x05, 0x67, 0x05, 0x77, 0x05, 0x86, 0x05, 0x96, 0x05, 0xa6, 0x05, 0xb5, 0x05, 0xc5, 0x05, 0xd5, 0x05, 0xe5, 0x05, 0xf6, 0x06, 0x06, 0x06, 0x16, 0x06, 0x27, 0x06, 0x37, 0x06, 0x48, 0x06, 0x59, 0x06, 0x6a, 0x06, 0x7b, 0x06, 0x8c, 0x06, 0x9d, 0x06, 0xaf, 0x06, 0xc0, 0x06, 0xd1, 0x06, 0xe3, 0x06, 0xf5, 0x07, 0x07, 0x07, 0x19, 0x07, 0x2b, 0x07, 0x3d, 0x07, 0x4f, 0x07, 0x61, 0x07, 0x74, 0x07, 0x86, 0x07, 0x99, 0x07, 0xac, 0x07, 0xbf, 0x07, 0xd2, 0x07, 0xe5, 0x07, 0xf8, 0x08, 0x0b, 0x08, 0x1f, 0x08, 0x32, 0x08, 0x46, 0x08, 0x5a, 0x08, 0x6e, 0x08, 0x82, 0x08, 0x96, 0x08, 0xaa, 0x08, 0xbe, 0x08, 0xd2, 0x08, 0xe7, 0x08, 0xfb, 0x09, 0x10, 0x09, 0x25, 0x09, 0x3a, 0x09, 0x4f, 0x09, 0x64, 0x09, 0x79, 0x09, 0x8f, 0x09, 0xa4, 0x09, 0xba, 0x09, 0xcf, 0x09, 0xe5, 0x09, 0xfb, 0x0a, 0x11, 0x0a, 0x27, 0x0a, 0x3d, 0x0a, 0x54, 0x0a, 0x6a, 0x0a, 0x81, 0x0a, 0x98, 0x0a, 0xae, 0x0a, 0xc5, 0x0a, 0xdc, 0x0a, 0xf3, 0x0b, 0x0b, 0x0b, 0x22, 0x0b, 0x39, 0x0b, 0x51, 0x0b, 0x69, 0x0b, 0x80, 0x0b, 0x98, 0x0b, 0xb0, 0x0b, 0xc8, 0x0b, 0xe1, 0x0b, 0xf9, 0x0c, 0x12, 0x0c, 0x2a, 0x0c, 0x43, 0x0c, 0x5c, 0x0c, 0x75, 0x0c, 0x8e, 0x0c, 0xa7, 0x0c, 0xc0, 0x0c, 0xd9, 0x0c, 0xf3, 0x0d, 0x0d, 0x0d, 0x26, 0x0d, 0x40, 0x0d, 0x5a, 0x0d, 0x74, 0x0d, 0x8e, 0x0d, 0xa9, 0x0d, 0xc3, 0x0d, 0xde, 0x0d, 0xf8, 0x0e, 0x13, 0x0e, 0x2e, 0x0e, 0x49, 0x0e, 0x64, 0x0e, 0x7f, 0x0e, 0x9b, 0x0e, 0xb6, 0x0e, 0xd2, 0x0e, 0xee, 0x0f, 0x09, 0x0f, 0x25, 0x0f, 0x41, 0x0f, 0x5e, 0x0f, 0x7a, 0x0f, 0x96, 0x0f, 0xb3, 0x0f, 0xcf, 0x0f, 0xec, 0x10, 0x09, 0x10, 0x26, 0x10, 0x43, 0x10, 0x61, 0x10, 0x7e, 0x10, 0x9b, 0x10, 0xb9, 0x10, 0xd7, 0x10, 0xf5, 0x11, 0x13, 0x11, 0x31, 0x11, 0x4f, 0x11, 0x6d, 0x11, 0x8c, 0x11, 0xaa, 0x11, 0xc9, 0x11, 0xe8, 0x12, 0x07, 0x12, 0x26, 0x12, 0x45, 0x12, 0x64, 0x12, 0x84, 0x12, 0xa3, 0x12, 0xc3, 0x12, 0xe3, 0x13, 0x03, 0x13, 0x23, 0x13, 0x43, 0x13, 0x63, 0x13, 0x83, 0x13, 0xa4, 0x13, 0xc5, 0x13, 0xe5, 0x14, 0x06, 0x14, 0x27, 0x14, 0x49, 0x14, 0x6a, 0x14, 0x8b, 0x14, 0xad, 0x14, 0xce, 0x14, 0xf0, 0x15, 0x12, 0x15, 0x34, 0x15, 0x56, 0x15, 0x78, 0x15, 0x9b, 0x15, 0xbd, 0x15, 0xe0, 0x16, 0x03, 0x16, 0x26, 0x16, 0x49, 0x16, 0x6c, 0x16, 0x8f, 0x16, 0xb2, 0x16, 0xd6, 0x16, 0xfa, 0x17, 0x1d, 0x17, 0x41, 0x17, 0x65, 0x17, 0x89, 0x17, 0xae, 0x17, 0xd2, 0x17, 0xf7, 0x18, 0x1b, 0x18, 0x40, 0x18, 0x65, 0x18, 0x8a, 0x18, 0xaf, 0x18, 0xd5, 0x18, 0xfa, 0x19, 0x20, 0x19, 0x45, 0x19, 0x6b, 0x19, 0x91, 0x19, 0xb7, 0x19, 0xdd, 0x1a, 0x04, 0x1a, 0x2a, 0x1a, 0x51, 0x1a, 0x77, 0x1a, 0x9e, 0x1a, 0xc5, 0x1a, 0xec, 0x1b, 0x14, 0x1b, 0x3b, 0x1b, 0x63, 0x1b, 0x8a, 0x1b, 0xb2, 0x1b, 0xda, 0x1c, 0x02, 0x1c, 0x2a, 0x1c, 0x52, 0x1c, 0x7b, 0x1c, 0xa3, 0x1c, 0xcc, 0x1c, 0xf5, 0x1d, 0x1e, 0x1d, 0x47, 0x1d, 0x70, 0x1d, 0x99, 0x1d, 0xc3, 0x1d, 0xec, 0x1e, 0x16, 0x1e, 0x40, 0x1e, 0x6a, 0x1e, 0x94, 0x1e, 0xbe, 0x1e, 0xe9, 0x1f, 0x13, 0x1f, 0x3e, 0x1f, 0x69, 0x1f, 0x94, 0x1f, 0xbf, 0x1f, 0xea, 0x20, 0x15, 0x20, 0x41, 0x20, 0x6c, 0x20, 0x98, 0x20, 0xc4, 0x20, 0xf0, 0x21, 0x1c, 0x21, 0x48, 0x21, 0x75, 0x21, 0xa1, 0x21, 0xce, 0x21, 0xfb, 0x22, 0x27, 0x22, 0x55, 0x22, 0x82, 0x22, 0xaf, 0x22, 0xdd, 0x23, 0x0a, 0x23, 0x38, 0x23, 0x66, 0x23, 0x94, 0x23, 0xc2, 0x23, 0xf0, 0x24, 0x1f, 0x24, 0x4d, 0x24, 0x7c, 0x24, 0xab, 0x24, 0xda, 0x25, 0x09, 0x25, 0x38, 0x25, 0x68, 0x25, 0x97, 0x25, 0xc7, 0x25, 0xf7, 0x26, 0x27, 0x26, 0x57, 0x26, 0x87, 0x26, 0xb7, 0x26, 0xe8, 0x27, 0x18, 0x27, 0x49, 0x27, 0x7a, 0x27, 0xab, 0x27, 0xdc, 0x28, 0x0d, 0x28, 0x3f, 0x28, 0x71, 0x28, 0xa2, 0x28, 0xd4, 0x29, 0x06, 0x29, 0x38, 0x29, 0x6b, 0x29, 0x9d, 0x29, 0xd0, 0x2a, 0x02, 0x2a, 0x35, 0x2a, 0x68, 0x2a, 0x9b, 0x2a, 0xcf, 0x2b, 0x02, 0x2b, 0x36, 0x2b, 0x69, 0x2b, 0x9d, 0x2b, 0xd1, 0x2c, 0x05, 0x2c, 0x39, 0x2c, 0x6e, 0x2c, 0xa2, 0x2c, 0xd7, 0x2d, 0x0c, 0x2d, 0x41, 0x2d, 0x76, 0x2d, 0xab, 0x2d, 0xe1, 0x2e, 0x16, 0x2e, 0x4c, 0x2e, 0x82, 0x2e, 0xb7, 0x2e, 0xee, 0x2f, 0x24, 0x2f, 0x5a, 0x2f, 0x91, 0x2f, 0xc7, 0x2f, 0xfe, 0x30, 0x35, 0x30, 0x6c, 0x30, 0xa4, 0x30, 0xdb, 0x31, 0x12, 0x31, 0x4a, 0x31, 0x82, 0x31, 0xba, 0x31, 0xf2, 0x32, 0x2a, 0x32, 0x63, 0x32, 0x9b, 0x32, 0xd4, 0x33, 0x0d, 0x33, 0x46, 0x33, 0x7f, 0x33, 0xb8, 0x33, 0xf1, 0x34, 0x2b, 0x34, 0x65, 0x34, 0x9e, 0x34, 0xd8, 0x35, 0x13, 0x35, 0x4d, 0x35, 0x87, 0x35, 0xc2, 0x35, 0xfd, 0x36, 0x37, 0x36, 0x72, 0x36, 0xae, 0x36, 0xe9, 0x37, 0x24, 0x37, 0x60, 0x37, 0x9c, 0x37, 0xd7, 0x38, 0x14, 0x38, 0x50, 0x38, 0x8c, 0x38, 0xc8, 0x39, 0x05, 0x39, 0x42, 0x39, 0x7f, 0x39, 0xbc, 0x39, 0xf9, 0x3a, 0x36, 0x3a, 0x74, 0x3a, 0xb2, 0x3a, 0xef, 0x3b, 0x2d, 0x3b, 0x6b, 0x3b, 0xaa, 0x3b, 0xe8, 0x3c, 0x27, 0x3c, 0x65, 0x3c, 0xa4, 0x3c, 0xe3, 0x3d, 0x22, 0x3d, 0x61, 0x3d, 0xa1, 0x3d, 0xe0, 0x3e, 0x20, 0x3e, 0x60, 0x3e, 0xa0, 0x3e, 0xe0, 0x3f, 0x21, 0x3f, 0x61, 0x3f, 0xa2, 0x3f, 0xe2, 0x40, 0x23, 0x40, 0x64, 0x40, 0xa6, 0x40, 0xe7, 0x41, 0x29, 0x41, 0x6a, 0x41, 0xac, 0x41, 0xee, 0x42, 0x30, 0x42, 0x72, 0x42, 0xb5, 0x42, 0xf7, 0x43, 0x3a, 0x43, 0x7d, 0x43, 0xc0, 0x44, 0x03, 0x44, 0x47, 0x44, 0x8a, 0x44, 0xce, 0x45, 0x12, 0x45, 0x55, 0x45, 0x9a, 0x45, 0xde, 0x46, 0x22, 0x46, 0x67, 0x46, 0xab, 0x46, 0xf0, 0x47, 0x35, 0x47, 0x7b, 0x47, 0xc0, 0x48, 0x05, 0x48, 0x4b, 0x48, 0x91, 0x48, 0xd7, 0x49, 0x1d, 0x49, 0x63, 0x49, 0xa9, 0x49, 0xf0, 0x4a, 0x37, 0x4a, 0x7d, 0x4a, 0xc4, 0x4b, 0x0c, 0x4b, 0x53, 0x4b, 0x9a, 0x4b, 0xe2, 0x4c, 0x2a, 0x4c, 0x72, 0x4c, 0xba, 0x4d, 0x02, 0x4d, 0x4a, 0x4d, 0x93, 0x4d, 0xdc, 0x4e, 0x25, 0x4e, 0x6e, 0x4e, 0xb7, 0x4f, 0x00, 0x4f, 0x49, 0x4f, 0x93, 0x4f, 0xdd, 0x50, 0x27, 0x50, 0x71, 0x50, 0xbb, 0x51, 0x06, 0x51, 0x50, 0x51, 0x9b, 0x51, 0xe6, 0x52, 0x31, 0x52, 0x7c, 0x52, 0xc7, 0x53, 0x13, 0x53, 0x5f, 0x53, 0xaa, 0x53, 0xf6, 0x54, 0x42, 0x54, 0x8f, 0x54, 0xdb, 0x55, 0x28, 0x55, 0x75, 0x55, 0xc2, 0x56, 0x0f, 0x56, 0x5c, 0x56, 0xa9, 0x56, 0xf7, 0x57, 0x44, 0x57, 0x92, 0x57, 0xe0, 0x58, 0x2f, 0x58, 0x7d, 0x58, 0xcb, 0x59, 0x1a, 0x59, 0x69, 0x59, 0xb8, 0x5a, 0x07, 0x5a, 0x56, 0x5a, 0xa6, 0x5a, 0xf5, 0x5b, 0x45, 0x5b, 0x95, 0x5b, 0xe5, 0x5c, 0x35, 0x5c, 0x86, 0x5c, 0xd6, 0x5d, 0x27, 0x5d, 0x78, 0x5d, 0xc9, 0x5e, 0x1a, 0x5e, 0x6c, 0x5e, 0xbd, 0x5f, 0x0f, 0x5f, 0x61, 0x5f, 0xb3, 0x60, 0x05, 0x60, 0x57, 0x60, 0xaa, 0x60, 0xfc, 0x61, 0x4f, 0x61, 0xa2, 0x61, 0xf5, 0x62, 0x49, 0x62, 0x9c, 0x62, 0xf0, 0x63, 0x43, 0x63, 0x97, 0x63, 0xeb, 0x64, 0x40, 0x64, 0x94, 0x64, 0xe9, 0x65, 0x3d, 0x65, 0x92, 0x65, 0xe7, 0x66, 0x3d, 0x66, 0x92, 0x66, 0xe8, 0x67, 0x3d, 0x67, 0x93, 0x67, 0xe9, 0x68, 0x3f, 0x68, 0x96, 0x68, 0xec, 0x69, 0x43, 0x69, 0x9a, 0x69, 0xf1, 0x6a, 0x48, 0x6a, 0x9f, 0x6a, 0xf7, 0x6b, 0x4f, 0x6b, 0xa7, 0x6b, 0xff, 0x6c, 0x57, 0x6c, 0xaf, 0x6d, 0x08, 0x6d, 0x60, 0x6d, 0xb9, 0x6e, 0x12, 0x6e, 0x6b, 0x6e, 0xc4, 0x6f, 0x1e, 0x6f, 0x78, 0x6f, 0xd1, 0x70, 0x2b, 0x70, 0x86, 0x70, 0xe0, 0x71, 0x3a, 0x71, 0x95, 0x71, 0xf0, 0x72, 0x4b, 0x72, 0xa6, 0x73, 0x01, 0x73, 0x5d, 0x73, 0xb8, 0x74, 0x14, 0x74, 0x70, 0x74, 0xcc, 0x75, 0x28, 0x75, 0x85, 0x75, 0xe1, 0x76, 0x3e, 0x76, 0x9b, 0x76, 0xf8, 0x77, 0x56, 0x77, 0xb3, 0x78, 0x11, 0x78, 0x6e, 0x78, 0xcc, 0x79, 0x2a, 0x79, 0x89, 0x79, 0xe7, 0x7a, 0x46, 0x7a, 0xa5, 0x7b, 0x04, 0x7b, 0x63, 0x7b, 0xc2, 0x7c, 0x21, 0x7c, 0x81, 0x7c, 0xe1, 0x7d, 0x41, 0x7d, 0xa1, 0x7e, 0x01, 0x7e, 0x62, 0x7e, 0xc2, 0x7f, 0x23, 0x7f, 0x84, 0x7f, 0xe5, 0x80, 0x47, 0x80, 0xa8, 0x81, 0x0a, 0x81, 0x6b, 0x81, 0xcd, 0x82, 0x30, 0x82, 0x92, 0x82, 0xf4, 0x83, 0x57, 0x83, 0xba, 0x84, 0x1d, 0x84, 0x80, 0x84, 0xe3, 0x85, 0x47, 0x85, 0xab, 0x86, 0x0e, 0x86, 0x72, 0x86, 0xd7, 0x87, 0x3b, 0x87, 0x9f, 0x88, 0x04, 0x88, 0x69, 0x88, 0xce, 0x89, 0x33, 0x89, 0x99, 0x89, 0xfe, 0x8a, 0x64, 0x8a, 0xca, 0x8b, 0x30, 0x8b, 0x96, 0x8b, 0xfc, 0x8c, 0x63, 0x8c, 0xca, 0x8d, 0x31, 0x8d, 0x98, 0x8d, 0xff, 0x8e, 0x66, 0x8e, 0xce, 0x8f, 0x36, 0x8f, 0x9e, 0x90, 0x06, 0x90, 0x6e, 0x90, 0xd6, 0x91, 0x3f, 0x91, 0xa8, 0x92, 0x11, 0x92, 0x7a, 0x92, 0xe3, 0x93, 0x4d, 0x93, 0xb6, 0x94, 0x20, 0x94, 0x8a, 0x94, 0xf4, 0x95, 0x5f, 0x95, 0xc9, 0x96, 0x34, 0x96, 0x9f, 0x97, 0x0a, 0x97, 0x75, 0x97, 0xe0, 0x98, 0x4c, 0x98, 0xb8, 0x99, 0x24, 0x99, 0x90, 0x99, 0xfc, 0x9a, 0x68, 0x9a, 0xd5, 0x9b, 0x42, 0x9b, 0xaf, 0x9c, 0x1c, 0x9c, 0x89, 0x9c, 0xf7, 0x9d, 0x64, 0x9d, 0xd2, 0x9e, 0x40, 0x9e, 0xae, 0x9f, 0x1d, 0x9f, 0x8b, 0x9f, 0xfa, 0xa0, 0x69, 0xa0, 0xd8, 0xa1, 0x47, 0xa1, 0xb6, 0xa2, 0x26, 0xa2, 0x96, 0xa3, 0x06, 0xa3, 0x76, 0xa3, 0xe6, 0xa4, 0x56, 0xa4, 0xc7, 0xa5, 0x38, 0xa5, 0xa9, 0xa6, 0x1a, 0xa6, 0x8b, 0xa6, 0xfd, 0xa7, 0x6e, 0xa7, 0xe0, 0xa8, 0x52, 0xa8, 0xc4, 0xa9, 0x37, 0xa9, 0xa9, 0xaa, 0x1c, 0xaa, 0x8f, 0xab, 0x02, 0xab, 0x75, 0xab, 0xe9, 0xac, 0x5c, 0xac, 0xd0, 0xad, 0x44, 0xad, 0xb8, 0xae, 0x2d, 0xae, 0xa1, 0xaf, 0x16, 0xaf, 0x8b, 0xb0, 0x00, 0xb0, 0x75, 0xb0, 0xea, 0xb1, 0x60, 0xb1, 0xd6, 0xb2, 0x4b, 0xb2, 0xc2, 0xb3, 0x38, 0xb3, 0xae, 0xb4, 0x25, 0xb4, 0x9c, 0xb5, 0x13, 0xb5, 0x8a, 0xb6, 0x01, 0xb6, 0x79, 0xb6, 0xf0, 0xb7, 0x68, 0xb7, 0xe0, 0xb8, 0x59, 0xb8, 0xd1, 0xb9, 0x4a, 0xb9, 0xc2, 0xba, 0x3b, 0xba, 0xb5, 0xbb, 0x2e, 0xbb, 0xa7, 0xbc, 0x21, 0xbc, 0x9b, 0xbd, 0x15, 0xbd, 0x8f, 0xbe, 0x0a, 0xbe, 0x84, 0xbe, 0xff, 0xbf, 0x7a, 0xbf, 0xf5, 0xc0, 0x70, 0xc0, 0xec, 0xc1, 0x67, 0xc1, 0xe3, 0xc2, 0x5f, 0xc2, 0xdb, 0xc3, 0x58, 0xc3, 0xd4, 0xc4, 0x51, 0xc4, 0xce, 0xc5, 0x4b, 0xc5, 0xc8, 0xc6, 0x46, 0xc6, 0xc3, 0xc7, 0x41, 0xc7, 0xbf, 0xc8, 0x3d, 0xc8, 0xbc, 0xc9, 0x3a, 0xc9, 0xb9, 0xca, 0x38, 0xca, 0xb7, 0xcb, 0x36, 0xcb, 0xb6, 0xcc, 0x35, 0xcc, 0xb5, 0xcd, 0x35, 0xcd, 0xb5, 0xce, 0x36, 0xce, 0xb6, 0xcf, 0x37, 0xcf, 0xb8, 0xd0, 0x39, 0xd0, 0xba, 0xd1, 0x3c, 0xd1, 0xbe, 0xd2, 0x3f, 0xd2, 0xc1, 0xd3, 0x44, 0xd3, 0xc6, 0xd4, 0x49, 0xd4, 0xcb, 0xd5, 0x4e, 0xd5, 0xd1, 0xd6, 0x55, 0xd6, 0xd8, 0xd7, 0x5c, 0xd7, 0xe0, 0xd8, 0x64, 0xd8, 0xe8, 0xd9, 0x6c, 0xd9, 0xf1, 0xda, 0x76, 0xda, 0xfb, 0xdb, 0x80, 0xdc, 0x05, 0xdc, 0x8a, 0xdd, 0x10, 0xdd, 0x96, 0xde, 0x1c, 0xde, 0xa2, 0xdf, 0x29, 0xdf, 0xaf, 0xe0, 0x36, 0xe0, 0xbd, 0xe1, 0x44, 0xe1, 0xcc, 0xe2, 0x53, 0xe2, 0xdb, 0xe3, 0x63, 0xe3, 0xeb, 0xe4, 0x73, 0xe4, 0xfc, 0xe5, 0x84, 0xe6, 0x0d, 0xe6, 0x96, 0xe7, 0x1f, 0xe7, 0xa9, 0xe8, 0x32, 0xe8, 0xbc, 0xe9, 0x46, 0xe9, 0xd0, 0xea, 0x5b, 0xea, 0xe5, 0xeb, 0x70, 0xeb, 0xfb, 0xec, 0x86, 0xed, 0x11, 0xed, 0x9c, 0xee, 0x28, 0xee, 0xb4, 0xef, 0x40, 0xef, 0xcc, 0xf0, 0x58, 0xf0, 0xe5, 0xf1, 0x72, 0xf1, 0xff, 0xf2, 0x8c, 0xf3, 0x19, 0xf3, 0xa7, 0xf4, 0x34, 0xf4, 0xc2, 0xf5, 0x50, 0xf5, 0xde, 0xf6, 0x6d, 0xf6, 0xfb, 0xf7, 0x8a, 0xf8, 0x19, 0xf8, 0xa8, 0xf9, 0x38, 0xf9, 0xc7, 0xfa, 0x57, 0xfa, 0xe7, 0xfb, 0x77, 0xfc, 0x07, 0xfc, 0x98, 0xfd, 0x29, 0xfd, 0xba, 0xfe, 0x4b, 0xfe, 0xdc, 0xff, 0x6d, 0xff, 0xff }; char *description, **options, **profiles, **properties; const char *option, *property; DrawingWand *drawing_wand; ExceptionType severity; MagickWand *clone_wand, *magick_wand; PixelIterator *iterator; PixelWand *background, *border, *fill, **pixels; register ssize_t i; unsigned char *profile; unsigned int status; size_t columns, delay, length, number_options, number_profiles, number_properties, number_wands, rows; (void) argc; (void) argv; MagickWandGenesis(); magick_wand=NewMagickWand(); (void) MagickSetSize(magick_wand,640,480); (void) MagickGetSize(magick_wand,&columns,&rows); if ((columns != 640) || (rows != 480)) { (void) FormatLocaleFile(stderr,"Unexpected magick wand size\n"); exit(1); } (void) FormatLocaleFile(stdout,"Reading images...\n"); { char *p, path[MaxTextExtent]; path[0]=0; p=getenv("SRCDIR"); if (p != (char *) NULL) { (void) strcpy(path,p); if (path[strlen(path)-1] != '/') (void) strcat(path,"/"); } (void) strcat(path,"sequence.miff"); status=MagickReadImage(magick_wand,path); } if (status == MagickFalse) ThrowAPIException(magick_wand); if (MagickGetNumberImages(magick_wand) != 5) (void) FormatLocaleFile(stderr,"read %.20g images; expected 5\n", (double) MagickGetNumberImages(magick_wand)); (void) FormatLocaleFile(stdout,"Iterate forward...\n"); MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) (void) FormatLocaleFile(stdout,"index %.20g scene %.20g\n",(double) MagickGetIteratorIndex(magick_wand),(double) MagickGetImageScene(magick_wand)); (void) FormatLocaleFile(stdout,"Iterate reverse...\n"); while (MagickPreviousImage(magick_wand) != MagickFalse) (void) FormatLocaleFile(stdout,"index %.20g scene %.20g\n",(double) MagickGetIteratorIndex(magick_wand),(double) MagickGetImageScene(magick_wand)); (void) FormatLocaleFile(stdout,"Remove scene 1...\n"); (void) MagickSetIteratorIndex(magick_wand,1); clone_wand=MagickGetImage(magick_wand); status=MagickRemoveImage(magick_wand); if (status == MagickFalse) ThrowAPIException(magick_wand); MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) (void) FormatLocaleFile(stdout,"index %.20g scene %.20g\n",(double) MagickGetIteratorIndex(magick_wand),(double) MagickGetImageScene(magick_wand)); (void) FormatLocaleFile(stdout,"Insert scene 1 back in sequence...\n"); (void) MagickSetIteratorIndex(magick_wand,0); status=MagickAddImage(magick_wand,clone_wand); if (status == MagickFalse) ThrowAPIException(magick_wand); MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) (void) FormatLocaleFile(stdout,"index %.20g scene %.20g\n",(double) MagickGetIteratorIndex(magick_wand),(double) MagickGetImageScene(magick_wand)); (void) FormatLocaleFile(stdout,"Set scene 2 to scene 1...\n"); (void) MagickSetIteratorIndex(magick_wand,2); status=MagickSetImage(magick_wand,clone_wand); clone_wand=DestroyMagickWand(clone_wand); if (status == MagickFalse) ThrowAPIException(magick_wand); MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) (void) FormatLocaleFile(stdout,"index %.20g scene %.20g\n",(double) MagickGetIteratorIndex(magick_wand),(double) MagickGetImageScene(magick_wand)); (void) FormatLocaleFile(stdout,"Apply image processing options...\n"); status=MagickCropImage(magick_wand,60,60,10,10); if (status == MagickFalse) ThrowAPIException(magick_wand); MagickResetIterator(magick_wand); background=NewPixelWand(); status=PixelSetColor(background,"#000000"); if (status == MagickFalse) ThrowAPIException(magick_wand); status=MagickRotateImage(magick_wand,background,90.0); if (status == MagickFalse) ThrowAPIException(magick_wand); border=NewPixelWand(); (void) PixelSetColor(background,"green"); (void) PixelSetColor(border,"black"); status=MagickFloodfillPaintImage(magick_wand,CompositeChannels,background, 0.01*QuantumRange,border,0,0,MagickFalse); if (status == MagickFalse) ThrowAPIException(magick_wand); background=DestroyPixelWand(background); border=DestroyPixelWand(border); drawing_wand=NewDrawingWand(); (void) PushDrawingWand(drawing_wand); (void) DrawRotate(drawing_wand,45); (void) DrawSetFontSize(drawing_wand,18); fill=NewPixelWand(); (void) PixelSetColor(fill,"green"); (void) DrawSetFillColor(drawing_wand,fill); fill=DestroyPixelWand(fill); (void) DrawAnnotation(drawing_wand,15,5,(const unsigned char *) "Magick"); (void) PopDrawingWand(drawing_wand); (void) MagickSetIteratorIndex(magick_wand,1); status=MagickDrawImage(magick_wand,drawing_wand); if (status == MagickFalse) ThrowAPIException(magick_wand); status=MagickAnnotateImage(magick_wand,drawing_wand,70,5,90,"Image"); if (status == MagickFalse) ThrowAPIException(magick_wand); drawing_wand=DestroyDrawingWand(drawing_wand); { unsigned char pixels[27], primary_colors[27] = { 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 255, 0, 255, 255, 255, 0, 128, 128, 128, }; (void) MagickSetIteratorIndex(magick_wand,2); status=MagickImportImagePixels(magick_wand,10,10,3,3,"RGB",CharPixel, primary_colors); if (status == MagickFalse) ThrowAPIException(magick_wand); status=MagickExportImagePixels(magick_wand,10,10,3,3,"RGB",CharPixel, pixels); if (status == MagickFalse) ThrowAPIException(magick_wand); for (i=0; i < 9; i++) if (pixels[i] != primary_colors[i]) { (void) FormatLocaleFile(stderr, "Get pixels does not match set pixels\n"); exit(1); } } (void) MagickSetIteratorIndex(magick_wand,3); status=MagickResizeImage(magick_wand,50,50,UndefinedFilter,1.0); if (status == MagickFalse) ThrowAPIException(magick_wand); MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) { (void) MagickSetImageDepth(magick_wand,8); (void) MagickSetImageCompression(magick_wand,RLECompression); } MagickResetIterator(magick_wand); (void) MagickSetIteratorIndex(magick_wand,4); (void) FormatLocaleFile(stdout, "Utilitize pixel iterator to draw diagonal...\n"); iterator=NewPixelIterator(magick_wand); if (iterator == (PixelIterator *) NULL) ThrowAPIException(magick_wand); pixels=PixelGetNextIteratorRow(iterator,&number_wands); for (i=0; pixels != (PixelWand **) NULL; i++) { (void) PixelSetColor(pixels[i],"#224466"); (void) PixelSyncIterator(iterator); pixels=PixelGetNextIteratorRow(iterator,&number_wands); } (void) PixelSyncIterator(iterator); iterator=DestroyPixelIterator(iterator); (void) FormatLocaleFile(stdout,"Write to wandtest_out.miff...\n"); status=MagickWriteImages(magick_wand,"wandtest_out.miff",MagickTrue); if (status == MagickFalse) ThrowAPIException(magick_wand); (void) FormatLocaleFile(stdout, "Change image format from \"MIFF\" to \"GIF\"...\n"); status=MagickSetImageFormat(magick_wand,"GIF"); if (status == MagickFalse) ThrowAPIException(magick_wand); (void) FormatLocaleFile(stdout,"Set delay between frames to %d seconds...\n", WandDelay); status=MagickSetImageDelay(magick_wand,100*WandDelay); if (status == MagickFalse) ThrowAPIException(magick_wand); delay=MagickGetImageDelay(magick_wand); if (delay != (100*WandDelay)) { (void) FormatLocaleFile(stderr,"Get delay does not match set delay\n"); exit(1); } (void) FormatLocaleFile(stdout,"Write to wandtest_out_0.gif...\n"); status=MagickWriteImages(magick_wand,"wandtest_out.gif",MagickTrue); if (status == MagickFalse) ThrowAPIException(magick_wand); (void) FormatLocaleFile(stdout,"Set, list, get, and delete wand option...\n"); status=MagickSetOption(magick_wand,"wand:custom-option",CustomOption); if (status == MagickFalse) ThrowAPIException(magick_wand); option=MagickGetOption(magick_wand,"wand:custom-option"); if ((option == (const char *) NULL) || (strlen(option) != strlen(CustomOption)) || (memcmp(option,CustomOption,strlen(option)) != 0)) { (void) FormatLocaleFile(stderr,"Option does not match\n"); exit(1); } options=MagickGetOptions(magick_wand,"*",&number_options); if (options != (char **) NULL) { for (i=0; i < (ssize_t) number_options; i++) { (void) FormatLocaleFile(stdout," %s\n",options[i]); options[i]=(char *) MagickRelinquishMemory(options[i]); } options=(char **) MagickRelinquishMemory(options); } status=MagickDeleteOption(magick_wand,"wand:custom-option"); if (status == MagickFalse) ThrowAPIException(magick_wand); (void) FormatLocaleFile(stdout, "Set, list, get, and delete wand property...\n"); status=MagickSetImageProperty(magick_wand,"wand:custom-property", CustomProperty); if (status == MagickFalse) ThrowAPIException(magick_wand); property=MagickGetImageProperty(magick_wand,"wand:custom-property"); if ((property == (const char *) NULL) || (strlen(property) != strlen(CustomProperty)) || (memcmp(property,CustomProperty,strlen(property)) != 0)) { (void) FormatLocaleFile(stderr,"Property does not match\n"); exit(1); } properties=MagickGetImageProperties(magick_wand,"*",&number_properties); if (properties != (char **) NULL) { for (i=0; i < (ssize_t) number_properties; i++) { (void) FormatLocaleFile(stdout," %s\n",properties[i]); properties[i]=(char *) MagickRelinquishMemory(properties[i]); } properties=(char **) MagickRelinquishMemory(properties); } status=MagickDeleteImageProperty(magick_wand,"wand:custom-property"); if (status == MagickFalse) ThrowAPIException(magick_wand); (void) FormatLocaleFile(stdout, "Set, list, get, and remove sRGB color profile...\n"); status=MagickSetImageProfile(magick_wand,"sRGB",sRGBProfile, sizeof(sRGBProfile)); if (status == MagickFalse) ThrowAPIException(magick_wand); profile=(unsigned char *) MagickGetImageProfile(magick_wand,"sRGB",&length); if ((profile == (unsigned char *) NULL) || (length != sizeof(sRGBProfile)) || (memcmp(profile,sRGBProfile,length) != 0)) { (void) FormatLocaleFile(stderr,"Profile does not match\n"); exit(1); } profile=(unsigned char *) MagickRelinquishMemory(profile); profiles=MagickGetImageProfiles(magick_wand,"*",&number_profiles); if (profiles != (char **) NULL) { for (i=0; i < (ssize_t) number_profiles; i++) { (void) FormatLocaleFile(stdout," %s\n",profiles[i]); profiles[i]=(char *) MagickRelinquishMemory(profiles[i]); } profiles=(char **) MagickRelinquishMemory(profiles); } profile=(unsigned char *) MagickRemoveImageProfile(magick_wand,"sRGB", &length); if ((profile == (unsigned char *) NULL) || (length != sizeof(sRGBProfile)) || (memcmp(profile,sRGBProfile,length) != 0)) { (void) FormatLocaleFile(stderr,"Profile does not match\n"); exit(1); } profile=(unsigned char *) MagickRelinquishMemory(profile); magick_wand=DestroyMagickWand(magick_wand); (void) FormatLocaleFile(stdout,"Wand tests pass.\n"); return(0); }
unsigned char *get_thumbnail(char *full_filename, char *thumbnail_str, size_t *thumbnail_size, int is_rotate, int rotate_degree) { unsigned char *image_data = NULL; if (full_filename == NULL || thumbnail_str == NULL) return NULL; MagickBooleanType status; MagickWand *tmp_magick_wand = NULL; MagickWand *magick_wand = NULL; magick_wand = NewMagickWand(); status = MagickReadImage(magick_wand, full_filename); if (status == MagickFalse) { ThrowWandException(magick_wand); return NULL; } PixelWand *background = NULL; size_t height = MagickGetImageHeight(magick_wand); size_t old_height = height; size_t width = MagickGetImageWidth(magick_wand); size_t old_width = width; ssize_t i = 0, j = 0; int is_crop = 0; char is_gif_flag = 0; char is_jpeg_flag = 0; int do_quality = 0; char *fileformat = NULL; fileformat = MagickGetImageFormat(magick_wand); if (fileformat == NULL) { return NULL; } if (0 == strcasecmp(fileformat, image_format[GIFEXT])) { is_gif_flag = 1; } else if (0 == strcasecmp(fileformat, image_format[JPEGEXT])) { is_jpeg_flag = 1; } else if (0 == strcasecmp(fileformat, image_format[JPGEXT])) { is_jpeg_flag = 1; } fileformat = (char *)MagickRelinquishMemory(fileformat); //free(); if( 'C' == *thumbnail_str ||'c' == *thumbnail_str ) { is_crop = 1; } if(is_crop) { ParseMetaGeometry(thumbnail_str + 1, &i, &j, &width, &height); } else { ParseMetaGeometry(thumbnail_str, &i, &j, &width, &height); } if (old_width == width && height == old_height) { image_data = MagickGetImagesBlob(magick_wand, thumbnail_size); } else if (width <= 0 || height <= 0) { logError("%s%s:Geometry %s error\n", __FILE__, __func__, thumbnail_str); } else { /* * if type of the image is GIF, maybe have more than one frame, so do this different * from others */ if (is_gif_flag) { tmp_magick_wand = magick_wand; magick_wand = MagickCoalesceImages(tmp_magick_wand); tmp_magick_wand = DestroyMagickWand(tmp_magick_wand); } /* * if size of the image less than 800 * 600 and that's type is JPEG, then do * quality 100 OP */ if ((old_width < 800) && (old_height < 600) && is_jpeg_flag && is_crop != 1) { do_quality = 1; } MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) { if(do_quality) { MagickSetImageCompressionQuality(magick_wand, 100); MagickStripImage(magick_wand); } if(is_crop == 0) MagickThumbnailImage(magick_wand, width, height); else { logInfo("crop Image %ld, %ld", i, j); MagickCropImage(magick_wand, width, height, i, j); } if(is_rotate == 1) { background=NewPixelWand(); status=PixelSetColor(background,"#000000"); MagickRotateImage(magick_wand, background,(double)rotate_degree); background=DestroyPixelWand(background); } } image_data = MagickGetImagesBlob(magick_wand, thumbnail_size); } magick_wand = DestroyMagickWand(magick_wand); return image_data; }
unsigned char *covert_image(MagickWand *magick_wand, img_transition_info *image_transition_info, size_t *thumbnail_size) { unsigned char *image_data = NULL; MagickBooleanType status; // MagickWand *tmp_magick_wand = NULL; PixelWand *background = NULL; size_t height = MagickGetImageHeight(magick_wand); size_t old_height = height; size_t width = MagickGetImageWidth(magick_wand); size_t old_width = width; int is_crop = 0; int is_Crop = 0; int is_thumbnail = 0; ssize_t i = 0, j = 0; char is_gif_flag = 0; char is_jpeg_flag = 0; int do_quality = 0; char *fileformat = NULL; size_t cw = 0; //crop weight size_t ch = 0; //crop height size_t x_offset = 0; size_t y_offset = 0; fileformat = MagickGetImageFormat(magick_wand); if (fileformat == NULL) { return NULL; } if (0 == strcasecmp(fileformat, image_format[GIFEXT])) { is_gif_flag = 1; } else if (0 == strcasecmp(fileformat, image_format[JPEGEXT])) { is_jpeg_flag = 1; } else if (0 == strcasecmp(fileformat, image_format[JPGEXT])) { is_jpeg_flag = 1; } fileformat = (char *) MagickRelinquishMemory(fileformat); //free(); if ('c' == image_transition_info->transition_str[0]) { is_crop = 1; } else if ('C' == image_transition_info->transition_str[0]) { is_Crop = 1; } else { is_thumbnail = 1; } if (is_crop) { ParseMetaGeometry(image_transition_info->transition_str + 1, &i, &j, &width, &height); } else if (is_thumbnail) { ParseMetaGeometry(image_transition_info->transition_str, &i, &j, &width, &height); if (old_width == width && height == old_height) //���ߴ���ͬ���������� is_thumbnail = 0; } else if (is_Crop) { if (0 >= get_Crop_width_height( image_transition_info->transition_str + 1, &cw, &ch, &x_offset, &y_offset)) { logError("%s%s:Crop %s error\n", __FILE__, __func__, image_transition_info->transition_str + 1); return NULL; } #if 0 if(cw > width || ch > height) { image_data = MagickGetImagesBlob(magick_wand, thumbnail_size); magick_wand = DestroyMagickWand(magick_wand); return image_data; } #endif //�õ�height��width,�����Ӧ��x_offset,yoffset; get_Crop_offset_and_wh(cw, ch, &width, &height, &x_offset, &y_offset); } if (old_width == width && height == old_height && (is_Crop == 0) && (image_transition_info->is_rotate == 0) && (image_transition_info->is_quality == 0)) { image_data = MagickGetImagesBlob(magick_wand, thumbnail_size); } else if (width <= 0 || height <= 0) { logError("%s%s:Geometry %s error\n", __FILE__, __func__, image_transition_info->transition_str); } else { /* * if type of the image is GIF, maybe have more than one frame, so do this different * from others */ // if (is_gif_flag) { // tmp_magick_wand = magick_wand; // magick_wand = MagickCoalesceImages(tmp_magick_wand); // tmp_magick_wand = magick_wand; // magick_wand = MagickOptimizeImageLayers(tmp_magick_wand); // tmp_magick_wand = DestroyMagickWand(tmp_magick_wand); // } /* * if size of the image less than 800 * 600 and that's type is JPEG, then do * quality 100 OP */ if ((old_width < 800) && (old_height < 600) && is_jpeg_flag && is_crop != 1 && (image_transition_info->is_quality == 0)) { do_quality = 1; } background = NewPixelWand(); status = PixelSetColor(background, "#000000"); /* for gif MagickResetIterator(magick_wand); */ MagickWand *tmp_magick_wand = MagickGetImage(magick_wand); // while (MagickNextImage(tmp_magick_wand) != MagickFalse) { if (do_quality) { MagickSetImageCompressionQuality(tmp_magick_wand, 100); MagickStripImage(tmp_magick_wand); } if (is_thumbnail == 1) { MagickThumbnailImage(tmp_magick_wand, width, height); } else if (is_crop == 1) { MagickCropImage(tmp_magick_wand, width, height, i, j); } else if (is_Crop == 1) { MagickThumbnailImage(tmp_magick_wand, width, height); MagickCropImage(tmp_magick_wand, cw, ch, x_offset, y_offset); if (is_gif_flag) { // gif should thumbnail again MagickThumbnailImage(tmp_magick_wand, cw, ch); } } if (image_transition_info->is_rotate == 1) { MagickRotateImage(tmp_magick_wand, background, (double) (image_transition_info->degree)); } if (image_transition_info->is_quality) { MagickSetImageCompressionQuality(tmp_magick_wand, image_transition_info->quality); } MagickStripImage(tmp_magick_wand); // } background = DestroyPixelWand(background); image_data = MagickGetImagesBlob(tmp_magick_wand, thumbnail_size); tmp_magick_wand = DestroyMagickWand(tmp_magick_wand); // // if (is_gif_flag) { // magick_wand = DestroyMagickWand(magick_wand); // } } return image_data; }
unsigned char* free_thumbnail_memory( unsigned char *blob ) { return (unsigned char*)MagickRelinquishMemory( (void*)blob ); }
// output_data apr_status_t small_light_filter_imagemagick_output_data( ap_filter_t *f, apr_bucket_brigade *bb, void *v_ctx, apr_bucket *e) { ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, f->r, "small_light_filter_imagemagick_output_data"); request_rec *r = f->r; small_light_module_ctx_t* ctx = (small_light_module_ctx_t*)v_ctx; small_light_module_imagemagick_ctx_t *lctx = ctx->lctx; struct timeval t2, t21, t22, t23, t3; MagickBooleanType status = MagickFalse; // check data received. if (lctx->image == NULL) { ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "no data received."); r->status = HTTP_INTERNAL_SERVER_ERROR; return APR_EGENERAL; } // start image modifing. gettimeofday(&t2, NULL); small_light_image_size_t sz; small_light_calc_image_size(&sz, r, ctx, 10000.0, 10000.0); // init wand small_light_filter_imagemagick_output_data_init(); lctx->wand = NewMagickWand(); // prepare. if (sz.jpeghint_flg != 0) { char *jpeg_size_opt = (char *)apr_psprintf(r->pool, "%dx%d", (int)sz.dw, (int)sz.dh); MagickSetOption(lctx->wand, "jpeg:size", jpeg_size_opt); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "MagickSetOption(jpeg:size, %s)", jpeg_size_opt); } // load image. gettimeofday(&t21, NULL); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "MagickReadImageBlob"); status = MagickReadImageBlob(lctx->wand, (void *)lctx->image, lctx->image_len); if (status == MagickFalse) { small_light_filter_imagemagick_output_data_fini(ctx); ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "couldn't read image"); r->status = HTTP_INTERNAL_SERVER_ERROR; return APR_EGENERAL; } // calc size. gettimeofday(&t22, NULL); double iw = (double)MagickGetImageWidth(lctx->wand); double ih = (double)MagickGetImageHeight(lctx->wand); small_light_calc_image_size(&sz, r, ctx, iw, ih); // pass through. if (sz.pt_flg != 0) { small_light_filter_imagemagick_output_data_fini(ctx); apr_bucket *b = apr_bucket_pool_create(lctx->image, lctx->image_len, r->pool, ctx->bb->bucket_alloc); APR_BRIGADE_INSERT_TAIL(ctx->bb, b); APR_BRIGADE_INSERT_TAIL(ctx->bb, apr_bucket_eos_create(ctx->bb->bucket_alloc)); return ap_pass_brigade(f->next, ctx->bb); } // crop, scale. status = MagickTrue; if (sz.scale_flg != 0) { char *crop_geo = (char *)apr_psprintf(r->pool, "%f!x%f!+%f+%f", sz.sw, sz.sh, sz.sx, sz.sy); char *size_geo = (char *)apr_psprintf(r->pool, "%f!x%f!", sz.dw, sz.dh); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "MagickTransformImage(wand, ""%s"", ""%s"")", crop_geo, size_geo); MagickWand *trans_wand; trans_wand = MagickTransformImage(lctx->wand, crop_geo, size_geo); if (trans_wand == NULL || trans_wand == lctx->wand) { small_light_filter_imagemagick_output_data_fini(ctx); ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "MagickTransformImage failed"); r->status = HTTP_INTERNAL_SERVER_ERROR; return APR_EGENERAL; } DestroyMagickWand(lctx->wand); lctx->wand = trans_wand; } else { ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "no scale"); } // create canvas then draw image to the canvas. if (sz.cw > 0.0 && sz.ch > 0.0) { ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "NewMagickWand()"); MagickWand *canvas_wand = NewMagickWand(); PixelWand *canvas_color = NewPixelWand(); PixelSetRed(canvas_color, sz.cc.r / 255.0); PixelSetGreen(canvas_color, sz.cc.g / 255.0); PixelSetBlue(canvas_color, sz.cc.b / 255.0); PixelSetAlpha(canvas_color, sz.cc.a / 255.0); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "MagickNewImage(canvas_wand, %f, %f, bgcolor)", sz.cw, sz.ch); status = MagickNewImage(canvas_wand, sz.cw, sz.ch, canvas_color); DestroyPixelWand(canvas_color); if (status == MagickFalse) { small_light_filter_imagemagick_output_data_fini(ctx); ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "MagickNewImage(canvas_wand, %f, %f, bgcolor) failed", sz.cw, sz.ch); r->status = HTTP_INTERNAL_SERVER_ERROR; return APR_EGENERAL; } ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "MagickCompositeImage(canvas_wand, wand, AtopCompositeOp, %f, %f)", sz.dx, sz.dy); status = MagickCompositeImage(canvas_wand, lctx->wand, AtopCompositeOp, sz.dx, sz.dy); if (status == MagickFalse) { small_light_filter_imagemagick_output_data_fini(ctx); ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "MagickCompositeImage(canvas_wand, wand, AtopCompositeOp, %f, %f) failed", sz.dx, sz.dy); r->status = HTTP_INTERNAL_SERVER_ERROR; return APR_EGENERAL; } DestroyMagickWand(lctx->wand); lctx->wand = canvas_wand; } // effects. char *unsharp = (char *)apr_table_get(ctx->prm, "unsharp"); if (unsharp) { GeometryInfo geo; ParseGeometry(unsharp, &geo); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "MagickUnsharpMaskImage(wand, %f, %f, %f, %f)", geo.rho, geo.sigma, geo.xi, geo.psi); status = MagickUnsharpMaskImage(lctx->wand, geo.rho, geo.sigma, geo.xi, geo.psi); if (status == MagickFalse) { ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "unsharp failed"); } } char *sharpen = (char *)apr_table_get(ctx->prm, "sharpen"); if (sharpen) { GeometryInfo geo; ParseGeometry(sharpen, &geo); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "MagickSharpenImage(wand, %f, %f)", geo.rho, geo.sigma); status = MagickSharpenImage(lctx->wand, geo.rho, geo.sigma); if (status == MagickFalse) { ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "sharpen failed"); } } char *blur = (char *)apr_table_get(ctx->prm, "blur"); if (blur) { GeometryInfo geo; ParseGeometry(blur, &geo); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "MagickBlurImage(wand, %f, %f)", geo.rho, geo.sigma); status = MagickBlurImage(lctx->wand, geo.rho, geo.sigma); if (status == MagickFalse) { ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "blur failed"); } } // border. if (sz.bw > 0.0 || sz.bh > 0.0) { ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "draw border"); DrawingWand *border_wand = NewDrawingWand(); PixelWand *border_color; border_color = NewPixelWand(); PixelSetRed(border_color, sz.bc.r / 255.0); PixelSetGreen(border_color, sz.bc.g / 255.0); PixelSetBlue(border_color, sz.bc.b / 255.0); PixelSetAlpha(border_color, sz.bc.a / 255.0); DrawSetFillColor(border_wand, border_color); DrawSetStrokeColor(border_wand, border_color); DrawSetStrokeWidth(border_wand, 1); DrawRectangle(border_wand, 0, 0, sz.cw - 1, sz.bh - 1); DrawRectangle(border_wand, 0, 0, sz.bw - 1, sz.ch - 1); DrawRectangle(border_wand, 0, sz.ch - sz.bh, sz.cw - 1, sz.ch - 1); DrawRectangle(border_wand, sz.cw - sz.bw, 0, sz.cw - 1, sz.ch - 1); MagickDrawImage(lctx->wand, border_wand); DestroyPixelWand(border_color); DestroyDrawingWand(border_wand); } gettimeofday(&t23, NULL); // set params. double q = small_light_parse_double(r, (char *)apr_table_get(ctx->prm, "q")); if (q > 0.0) { ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "MagickSetImageComressionQualty(wand, %f)", q); MagickSetImageCompressionQuality(lctx->wand, q); } char *of = (char *)apr_table_get(ctx->prm, "of"); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "MagickSetFormat(wand, '%s')", of); MagickSetFormat(lctx->wand, of); // get small_lighted image as binary. unsigned char *canvas_buff; const char *sled_image; size_t sled_image_size; canvas_buff = MagickGetImageBlob(lctx->wand, &sled_image_size); sled_image = (const char *)apr_pmemdup(r->pool, canvas_buff, sled_image_size); ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "sled_image_size = %d", sled_image_size); // free buffer and wand. MagickRelinquishMemory(canvas_buff); small_light_filter_imagemagick_output_data_fini(ctx); // insert new bucket to bucket brigade. apr_bucket *b = apr_bucket_pool_create(sled_image, sled_image_size, r->pool, ctx->bb->bucket_alloc); APR_BRIGADE_INSERT_TAIL(ctx->bb, b); // insert eos to bucket brigade. APR_BRIGADE_INSERT_TAIL(ctx->bb, apr_bucket_eos_create(ctx->bb->bucket_alloc)); // set correct Content-Type and Content-Length. char *cont_type = apr_psprintf(r->pool, "image/%s", of); ap_set_content_type(r, cont_type); ap_set_content_length(r, sled_image_size); // end. gettimeofday(&t3, NULL); // http header. int info = small_light_parse_int(r, (char *)apr_table_get(ctx->prm, "info")); if (info != SMALL_LIGHT_INT_INVALID_VALUE && info != 0) { char *info = (char *)apr_psprintf(r->pool, "transfer=%ldms, modify image=%ldms (load=%ldms, scale=%ldms, save=%ldms)", small_light_timeval_diff(&ctx->t, &t2) / 1000L, small_light_timeval_diff(&t2, &t3) / 1000L, small_light_timeval_diff(&t21, &t22) / 1000L, small_light_timeval_diff(&t22, &t23) / 1000L, small_light_timeval_diff(&t23, &t3) / 1000L ); ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, "uri=%s, info=%s)", r->unparsed_uri, info); apr_table_setn(r->headers_out, "X-SmallLight-Description", info); } return ap_pass_brigade(f->next, ctx->bb); }
caddr_t bif_im_get_impl (caddr_t * qst, caddr_t * err, state_slot_t ** args, int is_file_in, int op, const char *bifname) { im_env_t env; char *strg_value = NULL; unsigned long ul_value = 0; caddr_t res = NULL; int is_string_res = (('A' == op) || ('F' == op) || ('I' == op)); int is_list_res = ('2' == op); int is_key_needed = ('A' == op); caddr_t key = is_key_needed ? bif_string_arg (qst, args, (is_file_in ? 1 : 2), bifname) : NULL; im_init (&env, qst, args, bifname); if (is_file_in) im_env_set_filenames (&env, 0, -1); else { im_env_set_input_blob (&env, 0); im_env_set_blob_ext (&env, (is_key_needed ? 3 : 2), -1); } im_read (&env); MagickResetIterator(env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { switch (op) { case 'A': strg_value = MagickGetImageAttribute (env.ime_magick_wand, key); break; case 'F': strg_value = MagickGetImageFormat (env.ime_magick_wand); break; case 'I': strg_value = MagickIdentifyImage (env.ime_magick_wand); break; case 'W': ul_value = MagickGetImageWidth (env.ime_magick_wand); break; case 'H': ul_value = MagickGetImageHeight (env.ime_magick_wand); break; case 'D': ul_value = MagickGetImageDepth (env.ime_magick_wand); break; case '2': ul_value = MagickGetImageWidth (env.ime_magick_wand); if (ul_value) { dk_free_tree (res); res = dk_alloc_box (2 * sizeof (caddr_t), DV_ARRAY_OF_POINTER); ((caddr_t *)res)[0] = box_num (ul_value); ((caddr_t *)res)[1] = box_num (MagickGetImageHeight (env.ime_magick_wand)); } break; } } if (is_string_res) { if (strg_value) { res = box_dv_short_string (strg_value); MagickRelinquishMemory (strg_value); } } else if (!is_list_res) { if (ul_value) res = box_num (ul_value); } if (NULL == res) res = NEW_DB_NULL; im_leave (&env); return res; }