int write_archive_from_mem(char *outname, MagickWand *wand)
{
int archiveSize = 0;
int pageNumber = 1;
struct archive *a;
struct archive_entry *entry;
a = archive_write_new();
archive_write_set_format_ustar(a);
archive_write_open_filename(a, outname);
char filename[13];
MagickResetIterator(wand);
MagickNextImage(wand); // Has to be called after MagickResetIterator to set the first picture as the current
do {
unsigned char *data;
size_t size;
data = MagickWriteImageBlob(wand, &size);
entry = archive_entry_new();
snprintf(filename, 13, "page_%d", pageNumber++);
archive_entry_set_pathname(entry, filename);
archive_entry_set_size(entry, size);
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_perm(entry, 0644);
archive_write_header(a, entry);
archiveSize += archive_write_data(a, data, size);
archive_entry_free(entry);
} while (MagickNextImage(wand));
archive_write_close(a);
archive_write_free(a);
return archiveSize;
}
unsigned char *GmImp::get_result(size_t *length)
{
unsigned int rsize;
rsize = MagickGetImageSize(this->wand);
return MagickWriteImageBlob(this->wand, length);
}
int parse (size_t size, unsigned char *data) {
int writtendata = 0;
MagickWand *input = NewMagickWand();
MagickWand *output = input;
convert_t *opts = (convert_t*) data;
convert_info_t info_data;
size -= sizeof(convert_t);
data += sizeof(convert_t);
int status = convert(input, &output, opts, data, size);
if (status < 0) {
destroy(input, output);
return status;
}
if (opts->format == INFO) {
to_convert_info(output, &info_data);
data = (unsigned char*) &info_data;
size = sizeof(convert_info_t);
writtendata = io_write(size, data);
} else {
if (opts->split) {
// If we split the file then we will make a tarball containing all the pages
char* filename;
filename = tmpnam (NULL);
size = write_archive_from_mem(filename, output);
writtendata = io_write_file_to_stdout(filename);
unlink(filename);
} else {
char *format = MagickGetImageFormat(output);
if(strcmp(format,"PNG") == 0 && opts->quality != 0){
struct bufferAndSize d = pngQuant(output);
writtendata = io_write(d.size, d.data);
free(d.data);
free(format);
}else{
data = MagickWriteImageBlob(output, &size);
writtendata = io_write(size, data);
free(data);
}
destroy(input, output);
}
}
return writtendata;
}
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);
}
// 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;
}
int parse (size_t size, unsigned char *data) {
int writtendata = 0;
MagickWand *input = NewMagickWand();
MagickWand *output = input;
convert_t *opts = (convert_t*) data;
convert_info_t info_data;
size -= sizeof(convert_t);
data += sizeof(convert_t);
int status = convert(input, &output, opts, data, size);
if (status < 0) {
destroy(input, output);
return status;
}
if (opts->format == INFO) {
to_convert_info(output, &info_data);
data = (unsigned char*) &info_data;
size = sizeof(convert_info_t);
writtendata = io_write(size, data);
} else {
if (opts->split) {
// If we split the file then we will make a tarball containing all the pages
char* filename;
filename = "/tmp/cmguiXXXXXX";
size = write_archive_from_mem(filename, output);
writtendata = io_write_file_to_stdout(filename);
unlink(filename);
} else {
data = MagickWriteImageBlob(output, &size);
writtendata = io_write(size, data);
}
}
//destroy(input, output);
return writtendata;
}
/**
* @brief get_img get image from disk mode through the request
*
* @param req the zimg request
* @param request the evhtp request
*
* @return 1 for OK, 2 for 304 needn't response buffer and -1 for failed
*/
int get_img(zimg_req_t *req, evhtp_request_t *request)
{
int result = -1;
char rsp_cache_key[CACHE_KEY_SIZE];
int fd = -1;
struct stat f_stat;
char *buff = NULL;
char *orig_buff = NULL;
MagickWand *im = NULL;
size_t len = 0;
bool to_save = true;
LOG_PRINT(LOG_DEBUG, "get_img() start processing zimg request...");
int lvl1 = str_hash(req->md5);
int lvl2 = str_hash(req->md5 + 3);
char whole_path[512];
snprintf(whole_path, 512, "%s/%d/%d/%s", settings.img_path, lvl1, lvl2, req->md5);
LOG_PRINT(LOG_DEBUG, "whole_path: %s", whole_path);
if(is_dir(whole_path) == -1)
{
LOG_PRINT(LOG_DEBUG, "Image %s is not existed!", req->md5);
goto err;
}
if(settings.script_on == 1 && req->type != NULL)
snprintf(rsp_cache_key, CACHE_KEY_SIZE, "%s:%s", req->md5, req->type);
else
{
if(req->proportion == 0 && req->width == 0 && req->height == 0)
str_lcpy(rsp_cache_key, req->md5, CACHE_KEY_SIZE);
else
gen_key(rsp_cache_key, req->md5, 9, req->width, req->height, req->proportion, req->gray, req->x, req->y, req->rotate, req->quality, req->fmt);
}
if(find_cache_bin(req->thr_arg, rsp_cache_key, &buff, &len) == 1)
{
LOG_PRINT(LOG_DEBUG, "Hit Cache[Key: %s].", rsp_cache_key);
to_save = false;
goto done;
}
LOG_PRINT(LOG_DEBUG, "Start to Find the Image...");
char orig_path[512];
snprintf(orig_path, 512, "%s/0*0", whole_path);
LOG_PRINT(LOG_DEBUG, "0rig File Path: %s", orig_path);
char rsp_path[512];
if(settings.script_on == 1 && req->type != NULL)
snprintf(rsp_path, 512, "%s/t_%s", whole_path, req->type);
else
{
char name[128];
snprintf(name, 128, "%d*%d_p%d_g%d_%d*%d_r%d_q%d.%s", req->width, req->height,
req->proportion,
req->gray,
req->x, req->y,
req->rotate,
req->quality,
req->fmt);
if(req->width == 0 && req->height == 0 && req->proportion == 0)
{
LOG_PRINT(LOG_DEBUG, "Return original image.");
strncpy(rsp_path, orig_path, 512);
}
else
{
snprintf(rsp_path, 512, "%s/%s", whole_path, name);
}
}
LOG_PRINT(LOG_DEBUG, "Got the rsp_path: %s", rsp_path);
if((fd = open(rsp_path, O_RDONLY)) == -1)
{
im = NewMagickWand();
if (im == NULL) goto err;
int ret;
if(find_cache_bin(req->thr_arg, req->md5, &orig_buff, &len) == 1)
{
LOG_PRINT(LOG_DEBUG, "Hit Orignal Image Cache[Key: %s].", req->md5);
ret = MagickReadImageBlob(im, (const unsigned char *)orig_buff, len);
if (ret != MagickTrue)
{
LOG_PRINT(LOG_DEBUG, "Open Original Image From Blob Failed! Begin to Open it From Disk.");
del_cache(req->thr_arg, req->md5);
ret = MagickReadImage(im, orig_path);
if (ret != MagickTrue)
{
LOG_PRINT(LOG_DEBUG, "Open Original Image From Disk Failed!");
goto err;
}
else
{
MagickSizeType size = MagickGetImageSize(im);
LOG_PRINT(LOG_DEBUG, "image size = %d", size);
if(size < CACHE_MAX_SIZE)
{
MagickResetIterator(im);
char *new_buff = (char *)MagickWriteImageBlob(im, &len);
if (new_buff == NULL) {
LOG_PRINT(LOG_DEBUG, "Webimg Get Original Blob Failed!");
goto err;
}
set_cache_bin(req->thr_arg, req->md5, new_buff, len);
free(new_buff);
}
}
}
}
else
{
LOG_PRINT(LOG_DEBUG, "Not Hit Original Image Cache. Begin to Open it.");
ret = MagickReadImage(im, orig_path);
if (ret != MagickTrue)
{
LOG_PRINT(LOG_DEBUG, "Open Original Image From Disk Failed! %d != %d", ret, MagickTrue);
LOG_PRINT(LOG_DEBUG, "Open Original Image From Disk Failed!");
goto err;
}
else
{
MagickSizeType size = MagickGetImageSize(im);
LOG_PRINT(LOG_DEBUG, "image size = %d", size);
if(size < CACHE_MAX_SIZE)
{
MagickResetIterator(im);
char *new_buff = (char *)MagickWriteImageBlob(im, &len);
if (new_buff == NULL) {
LOG_PRINT(LOG_DEBUG, "Webimg Get Original Blob Failed!");
goto err;
}
set_cache_bin(req->thr_arg, req->md5, new_buff, len);
free(new_buff);
}
}
}
if(settings.script_on == 1 && req->type != NULL)
ret = lua_convert(im, req);
else
ret = convert(im, req);
if(ret == -1) goto err;
if(ret == 0) to_save = false;
buff = (char *)MagickWriteImageBlob(im, &len);
if (buff == NULL) {
LOG_PRINT(LOG_DEBUG, "Webimg Get Blob Failed!");
goto err;
}
}
else
{
to_save = false;
fstat(fd, &f_stat);
size_t rlen = 0;
len = f_stat.st_size;
if(len <= 0)
{
LOG_PRINT(LOG_DEBUG, "File[%s] is Empty.", rsp_path);
goto err;
}
if((buff = (char *)malloc(len)) == NULL)
{
LOG_PRINT(LOG_DEBUG, "buff Malloc Failed!");
goto err;
}
LOG_PRINT(LOG_DEBUG, "img_size = %d", len);
if((rlen = read(fd, buff, len)) == -1)
{
LOG_PRINT(LOG_DEBUG, "File[%s] Read Failed: %s", rsp_path, strerror(errno));
goto err;
}
else if(rlen < len)
{
LOG_PRINT(LOG_DEBUG, "File[%s] Read Not Compeletly.", rsp_path);
goto err;
}
}
//LOG_PRINT(LOG_INFO, "New Image[%s]", rsp_path);
int save_new = 0;
if(to_save == true)
{
if(req->sv == 1 || settings.save_new == 1 || (settings.save_new == 2 && req->type != NULL))
{
save_new = 1;
}
}
if(save_new == 1)
{
LOG_PRINT(LOG_DEBUG, "Image[%s] is Not Existed. Begin to Save it.", rsp_path);
if(new_img(buff, len, rsp_path) == -1)
{
LOG_PRINT(LOG_DEBUG, "New Image[%s] Save Failed!", rsp_path);
LOG_PRINT(LOG_WARNING, "fail save %s", rsp_path);
}
}
else
LOG_PRINT(LOG_DEBUG, "Image [%s] Needn't to Storage.", rsp_path);
if(len < CACHE_MAX_SIZE)
{
set_cache_bin(req->thr_arg, rsp_cache_key, buff, len);
}
done:
if(settings.etag == 1)
{
result = zimg_etag_set(request, buff, len);
if(result == 2)
goto err;
}
result = evbuffer_add(request->buffer_out, buff, len);
if(result != -1)
{
result = 1;
}
err:
if(fd != -1)
close(fd);
if(im != NULL)
DestroyMagickWand(im);
free(buff);
free(orig_buff);
return result;
}
