Image *crop_masked_final_image(Image *org_img, Image *mask_img) { unsigned int x = 0; unsigned int y = 0; int width = (int)org_img->columns; int height = (int)org_img->rows; PixelPacket *px; PixelPacket *mask_px; ExceptionInfo exception; GetExceptionInfo(&exception); px = GetImagePixels(org_img, 0, 0, org_img->columns, org_img->rows); mask_px = GetImagePixels(mask_img, 0, 0, mask_img->columns, mask_img->rows); while (y < height) { x = 0; while (x < width) { if (mask_px[(width * y) + x].red == WHITE) { px[(width * y) + x].green = px[(width * y) + x].blue = px[(width * y) + x].red = BLACK; } x++; } y++; } DestroyImage(mask_img); return (org_img); }
Image *get_threshold_image(Image *img, c_threshold *c) { Image *threshold_img; int size_x, size_y; int i = 0; int j = 0; char *string_img = malloc(img->rows * img->columns * sizeof(*string_img)); char *temp_string_img; PixelPacket *px; ExceptionInfo exception; GetExceptionInfo(&exception); px = GetImagePixels(img, 0, 0, img->columns, img->rows); size_x = (int)img->columns; size_y = (int)img->rows; while (i < size_y) { j=0; while (j < size_x) { string_img[(size_x * i) + j] = (char)px[(size_x * i) + j].green; j++; } i++; } temp_string_img = otsu_th(size_x, size_y, string_img, c); threshold_img = ConstituteImage(size_x, size_y, "I", CharPixel, temp_string_img, &exception); free(temp_string_img); free(string_img); DestroyImage(img); SyncImagePixels(threshold_img); return (threshold_img); }
void appendImageBytesToRaw(int fd, char * file) { Image *img = get_image_from_path(file); unsigned char *pixel_map = NULL; size_t pixel_map_size = img->columns * img->rows * sizeof(*pixel_map); pixel_map = malloc(pixel_map_size); unsigned int x = 0; unsigned int y = 0; int width = (int)img->columns; int height = (int)img->rows; PixelPacket *px; ExceptionInfo exception; GetExceptionInfo(&exception); px = GetImagePixels(img, 0, 0, img->columns, img->rows); while (y < height) { x = 0; while (x < width) { pixel_map[(width * y) + x] = (char)px[(width * y) + x].green; x++; } y++; } write(fd, pixel_map, pixel_map_size); free(pixel_map); DestroyImage(img); }
void ImageDraw::transferPixels( void* image ) { Image* imImage = static_cast< Image* >( image ); PixelPacket* q = NULL; int quantumFactor = imImage->depth -8; for ( int y = 0 ; y < (int)m_height ; y++ ) { q = GetImagePixels( imImage, 0, y, m_width, 1 ); if ( q == NULL ) { break; } unsigned char red = 0; unsigned char green = 0; unsigned char blue = 0; for ( int x = 0 ; x < (int)m_width ; x++ ) { getPixel( x, y, red, green, blue ); PixelPacket col; col.red = int(red) << quantumFactor; col.green = int(green) << quantumFactor; col.blue = int(blue) << quantumFactor; // col.opacity = x; *q=col; q++; } if ( ! SyncImagePixels( imImage ) ) { break; } } }
static int logo_filter_video(TCModuleInstance *self, TCFrameVideo *frame) { LogoPrivateData *pd = NULL; WorkItem W = { NULL, 0, 0.0 }; TC_MODULE_SELF_CHECK(self, "filter"); TC_MODULE_SELF_CHECK(frame, "filter"); pd = self->userdata; if (frame->id < pd->start || frame->id > pd->end) { /* out of the interval, so skip processing */ return TC_OK; } set_fade(&W, frame->id, pd); set_delay(pd); W.pixels = GetImagePixels(pd->images, 0, 0, pd->images->columns, pd->images->rows); return pd->render(pd, &W, frame); }
Image *get_blur_maked(Image *img, c_image *c) { Image *maked_img; static unsigned short color = 0; unsigned int x = 0; unsigned int y = 0; unsigned char *pixel_map = malloc(img->columns * img->rows * sizeof(*pixel_map)); c->label_map = malloc(img->columns * img->rows * sizeof(*c->label_map)); int width = (int)img->columns; int height = (int)img->rows; PixelPacket *px; ExceptionInfo exception; GetExceptionInfo(&exception); px = GetImagePixels(img, 0, 0, img->columns, img->rows); while (y < height) { x = 0; while (x < width) { pixel_map[(width * y) + x] = (char)px[(width * y) + x].green; x++; } y++; } y = 0; while (y < height){ x = 0; while (x < width){ if (pixel_map[(width * y) + x] != WHITE){ c->label_map[(width * y) + x] = 1; pixel_map[(width * y) + x] = get_neighborpixcel(pixel_map, x, y, width, height, color, c); } else{ c->label_map[(width * y) + x] = 0; } if(color >= 255){ color = 0; } x++; } y++; } maked_img = ConstituteImage(width, height, "I", CharPixel, pixel_map, &exception); free(c->label_map); free(pixel_map); DestroyImage(img); SyncImagePixels(maked_img); return (maked_img); }
//Фильтр "Гамма-коррекция" //Параметры: // hDC DC назначения // lW Ширина DC // lH Высота DC // dblGamma Степень гаммы. Допустимые значения: от 0.1 до 1.9 // pRC Указатель на структуру RECT, определяющую область изображения для изменения // hWndCallback Окно уведомлений о ходе работы (опционально) //Возвращаемое значение: TRUE в случае успеха, FALSE в случае ошибки BOOL GammaCorrection(HDC hDC, ULONG lW, ULONG lH, double dblGamma, LPRECT pRC, HWND hWndCallback) { LPBYTE pPixels = NULL; ULONG lBytesCnt = 0; LPBITMAPINFO pBMI = NULL; ULONG lColor, lR, lG, lB; LONG i, j; volatile ONPROGRESSPARAMS ONPP = {}; if (!GetImagePixels(hDC, lW, lH, &pPixels, &lBytesCnt, &pBMI)) { if (pPixels) delete[] pPixels; if (pBMI) delete pBMI; return FALSE; } for (j = pRC->top; j < pRC->bottom; j++) { for (i = pRC->left; i < pRC->right; i++) { lColor = GetPixel(pPixels, pBMI, i, j); lR = R_BGRA(lColor); lG = G_BGRA(lColor); lB = B_BGRA(lColor); lR = (ULONG)CheckBounds((LONG)((255.0 * pow((double)lR / 255.0, 1.0 / dblGamma)) + 0.5), (LONG)0, (LONG)255); lG = (ULONG)CheckBounds((LONG)((255.0 * pow((double)lG / 255.0, 1.0 / dblGamma)) + 0.5), (LONG)0, (LONG)255); lB = (ULONG)CheckBounds((LONG)((255.0 * pow((double)lB / 255.0, 1.0 / dblGamma)) + 0.5), (LONG)0, (LONG)255); SetPixel(pPixels, pBMI, i, j, BGR(lB, lG, lR)); } if (hWndCallback) { ONPP.dwPercents = (DWORD)(((double)j / (double)pRC->bottom) * 100); SendMessage(hWndCallback, WM_GRAPHICSEVENT, MAKEWPARAM(EVENT_ON_PROGRESS, 0), (LPARAM)&ONPP); } } SetImagePixels(hDC, lW, lH, pPixels, pBMI); delete[] pPixels; delete pBMI; return TRUE; }
static int render_logo_rgb(LogoPrivateData *pd, const WorkItem *W, TCFrameVideo *frame) { int row, col; unsigned long r_off = 0, g_off = 1, b_off = 2; float img_coeff, vid_coeff; /* Note: GraphicsMagick defines opacity = 0 as fully visible, and * opacity = MaxRGB as fully transparent. */ Quantum opacity; uint8_t *video_buf = NULL; PixelPacket *pixels = GetImagePixels(pd->images, 0, 0, pd->images->columns, pd->images->rows); if (pd->rgbswap) { r_off = 2; b_off = 0; } for (row = 0; row < pd->magick.image->rows; row++) { video_buf = frame->video_buf + 3 * ((row + pd->posy) * pd->vob->ex_v_width + pd->posx); for (col = 0; col < pd->magick.image->columns; col++) { opacity = pixels->opacity; if (W->do_fade) opacity += (Quantum)((MaxRGB - opacity) * W->fade_coeff); if (opacity == 0) { *(video_buf + r_off) = ScaleQuantumToChar(pixels->red); *(video_buf + g_off) = ScaleQuantumToChar(pixels->green); *(video_buf + b_off) = ScaleQuantumToChar(pixels->blue); } else if (opacity < MaxRGB) { uint8_t opacity_byte = ScaleQuantumToChar(opacity); img_coeff = pd->img_coeff_lookup[opacity_byte]; vid_coeff = pd->vid_coeff_lookup[opacity_byte]; *(video_buf + r_off) = (uint8_t)((*(video_buf + r_off)) * vid_coeff) + (uint8_t)(ScaleQuantumToChar(pixels->red) * img_coeff); *(video_buf + g_off) = (uint8_t)((*(video_buf + g_off)) * vid_coeff) + (uint8_t)(ScaleQuantumToChar(pixels->green) * img_coeff); *(video_buf + b_off) = (uint8_t)((*(video_buf + b_off)) * vid_coeff) + (uint8_t)(ScaleQuantumToChar(pixels->blue) * img_coeff); } video_buf += 3; pixels++; } } return TC_OK; }
static void inline PlasmaPixel(Image *image,double x,double y) { register PixelPacket *q; q=GetImagePixels(image,(long) ceil(x-0.5),(long) ceil(y-0.5),1,1); if (q == (PixelPacket *) NULL) return; q->red=ScaleAnyToQuantum(GetRandomValue(),1.0); q->green=ScaleAnyToQuantum(GetRandomValue(),1.0); q->blue=ScaleAnyToQuantum(GetRandomValue(),1.0); (void) SyncImagePixels(image); }
static inline void PlasmaPixel(Image *image,double x,double y) { register PixelPacket *q; q=GetImagePixels(image,(long) ceil(x-0.5),(long) ceil(y-0.5),1,1); if (q == (PixelPacket *) NULL) return; q->red=ScaleAnyToQuantum((unsigned long) (65535.0*GetRandomValue()+0.5),16UL); q->green=ScaleAnyToQuantum((unsigned long) (65535.0*GetRandomValue()+0.5),16UL); q->blue=ScaleAnyToQuantum((unsigned long) (65535.0*GetRandomValue()+0.5),16UL); (void) SyncImagePixels(image); }
/** * flogo_convert_image: Converts a single ImageMagick RGB image into a format * usable by transcode. * * Parameters: tcvhandle: Opaque libtcvideo handle * src: An ImageMagick handle (the source image) * dst: A pointer to the output buffer * ifmt: The output format (see aclib/imgconvert.h) * do_rgbswap: zero for no swap, nonzero to swap red and blue * pixel positions * Return value: 1 on success, 0 on failure * Preconditions: tcvhandle != null, was returned by a call to tcv_init() * src is a valid ImageMagick RGB image handle * dst buffer is large enough to hold the result of the * requested conversion * Postconditions: dst get overwritten with the result of the conversion */ static int flogo_convert_image(TCVHandle tcvhandle, Image *src, uint8_t *dst, ImageFormat ifmt, int do_rgbswap) { PixelPacket *pixel_packet; uint8_t *dst_ptr = dst; int row, col; int height = src->rows; int width = src->columns; int ret; unsigned long r_off, g_off, b_off; if (!do_rgbswap) { r_off = 0; b_off = 2; } else { r_off = 2; b_off = 0; } g_off = 1; pixel_packet = GetImagePixels(src, 0, 0, width, height); for (row = 0; row < height; row++) { for (col = 0; col < width; col++) { *(dst_ptr + r_off) = (uint8_t)ScaleQuantumToChar(pixel_packet->red); *(dst_ptr + g_off) = (uint8_t)ScaleQuantumToChar(pixel_packet->green); *(dst_ptr + b_off) = (uint8_t)ScaleQuantumToChar(pixel_packet->blue); dst_ptr += 3; pixel_packet++; } } ret = tcv_convert(tcvhandle, dst, dst, width, height, IMG_RGB24, ifmt); if (ret == 0) { tc_log_error(MOD_NAME, "RGB->YUV conversion failed"); return 0; } return 1; }
Image *crop_area_selected(Image *img) { Image *final_images; unsigned char *pixel_map = malloc(img->columns * img->rows * sizeof(*pixel_map)); unsigned int x = 0; unsigned int y = 0; int width = (int)img->columns; int height = (int)img->rows; PixelPacket *px; ExceptionInfo exception; GetExceptionInfo(&exception); px = GetImagePixels(img, 0, 0, img->columns, img->rows); while (y < height) { x = 0; while (x < width) { pixel_map[(width * y) + x] = (char)px[(width * y) + x].green; x++; } y++; } y = 0; while (y < height){ x = 0; while (x < width){ if (pixel_map[(width * y) + x] == BLACK){ if (check_srounding(pixel_map, x, y, width, height) == TRUE){ pixel_map[(width * y) + x] = OUTLINE; } } if (pixel_map[(width * y) + x] !=FILL_COLOR && pixel_map[(width * y) + x] != OUTLINE) pixel_map[(width * y) + x] = WHITE; x++; } y++; } final_images = ConstituteImage(width, height, "I", CharPixel, pixel_map, &exception); free(pixel_map); DestroyImage(img); return (final_images); }
static PixelPacket * get_pixels( Image *image, int left, int top, int width, int height ) { PixelPacket *pixels; #ifdef HAVE_GETVIRTUALPIXELS if( !(pixels = (PixelPacket *) GetVirtualPixels( image, left, top, width, height, &image->exception )) ) #else if( !(pixels = GetImagePixels( image, left, top, width, height )) ) #endif return( NULL ); /* Can't happen if red/green/blue are doubles. */ #ifndef UseHDRI /* Unpack palette. */ if( image->storage_class == PseudoClass ) { #ifdef HAVE_GETVIRTUALPIXELS IndexPacket *indexes = (IndexPacket *) GetVirtualIndexQueue( image ); #else IndexPacket *indexes = GetIndexes( image ); #endif int i; for( i = 0; i < width * height; i++ ) { IndexPacket x = indexes[i]; if( x < image->colors ) { pixels[i].red = image->colormap[x].red; pixels[i].green = image->colormap[x].green; pixels[i].blue = image->colormap[x].blue; } } } #endif /*UseHDRI*/ return( pixels ); }
int *create_histogram(Image *img) { int i = 0; int *histogram = malloc(256 * sizeof(*histogram)); PixelPacket *px; int size; px = GetImagePixels(img, 0, 0, img->columns, img->rows); // memset(histogram, 0, 255); while (i < 255) histogram[i++] = 0; size = img->columns * img->rows; i = 0; while (i < size) { histogram[(int)px[i].blue] += 1; i++; } return (histogram); }
Image *transparent_image(Image *img) { int i = 0, j = 0, size_x, size_y; char *string_img = malloc(img->rows * img->columns * sizeof(*string_img)); PixelPacket *px; char *pixel_value = NULL; ExceptionInfo exception; GetExceptionInfo(&exception); px = GetImagePixels(img, 0, 0, img->columns, img->rows); size_x = (int)img->columns; size_y = (int)img->rows; while (i < size_y) { j = 0 ; while (j < size_x) { pixel_value[(size_x * i) + j]= px[(size_x * i) + j].green; printf("%c",px[i].green); } } free(string_img); return (img); }
static void XShearImage(Image *image,const MagickRealType degrees, const unsigned long width,const unsigned long height,const long x_offset, long y_offset) { #define XShearImageTag "XShear/Image" enum {LEFT, RIGHT} direction; IndexPacket *indexes, *shear_indexes; long step, y; MagickBooleanType status; MagickPixelPacket background, pixel, source, destination; MagickRealType area, displacement; register long i; register PixelPacket *p, *q; assert(image != (Image *) NULL); assert(image->signature == MagickSignature); if (image->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); y_offset--; for (y=0; y < (long) height; y++) { y_offset++; displacement=degrees*(MagickRealType) (y-height/2.0); if (displacement == 0.0) continue; if (displacement > 0.0) direction=RIGHT; else { displacement*=(-1.0); direction=LEFT; } step=(long) floor((double) displacement); area=(MagickRealType) (displacement-step); step++; GetMagickPixelPacket(image,&background); SetMagickPixelPacket(image,&image->background_color,(IndexPacket *) NULL, &background); if (image->colorspace == CMYKColorspace) ConvertRGBToCMYK(&background); pixel=background; GetMagickPixelPacket(image,&source); GetMagickPixelPacket(image,&destination); switch (direction) { case LEFT: { /* Transfer pixels left-to-right. */ if (step > x_offset) break; p=GetImagePixels(image,0,y_offset,image->columns,1); if (p == (PixelPacket *) NULL) break; p+=x_offset; indexes=GetIndexes(image); indexes+=x_offset; q=p-step; shear_indexes=indexes-step; for (i=0; i < (long) width; i++) { if ((x_offset+i) < step) { SetMagickPixelPacket(image,++p,++indexes,&pixel); q++; shear_indexes++; continue; } SetMagickPixelPacket(image,p,indexes,&source); MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&source, (MagickRealType) p->opacity,area,&destination); SetPixelPacket(image,&destination,q++,shear_indexes++); SetMagickPixelPacket(image,p++,indexes++,&pixel); } MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&background, (MagickRealType) background.opacity,area,&destination); SetPixelPacket(image,&destination,q++,shear_indexes++); for (i=0; i < (step-1); i++) SetPixelPacket(image,&background,q++,shear_indexes++); break; } case RIGHT: { /* Transfer pixels right-to-left. */ p=GetImagePixels(image,0,y_offset,image->columns,1); if (p == (PixelPacket *) NULL) break; p+=x_offset+width; indexes=GetIndexes(image); indexes+=x_offset+width; q=p+step; shear_indexes=indexes+step; for (i=0; i < (long) width; i++) { p--; indexes--; q--; shear_indexes--; if ((unsigned long) (x_offset+width+step-i) >= image->columns) continue; SetMagickPixelPacket(image,p,indexes,&source); MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&source, (MagickRealType) p->opacity,area,&destination); SetPixelPacket(image,&destination,q,shear_indexes); SetMagickPixelPacket(image,p,indexes,&pixel); } MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&background, (MagickRealType) background.opacity,area,&destination); SetPixelPacket(image,&destination,--q,--shear_indexes); for (i=0; i < (step-1); i++) SetPixelPacket(image,&background,--q,--shear_indexes); break; } } if (SyncImagePixels(image) == MagickFalse) break; if ((image->progress_monitor != (MagickProgressMonitor) NULL) && (QuantumTick(y,height) != MagickFalse)) { status=image->progress_monitor(XShearImageTag,y,height, image->client_data); if (status == MagickFalse) break; } } }
static Image *ReadPlasmaImage(const ImageInfo *image_info, ExceptionInfo *exception) { #define PlasmaImageTag "Plasma/Image" Image *image; ImageInfo *read_info; long y; MagickBooleanType status; register long x; register PixelPacket *q; register unsigned long i; SegmentInfo segment_info; unsigned long depth, max_depth; /* Recursively apply plasma to the image. */ read_info=CloneImageInfo(image_info); SetImageInfoBlob(read_info,(void *) NULL,0); (void) FormatMagickString(read_info->filename,MaxTextExtent, "gradient:%s",image_info->filename); image=ReadImage(read_info,exception); read_info=DestroyImageInfo(read_info); if (image == (Image *) NULL) return((Image *) NULL); image->storage_class=DirectClass; for (y=0; y < (long) image->rows; y++) { q=GetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; for (x=0; x < (long) image->columns; x++) { q->opacity=(Quantum) (QuantumRange/2); q++; } if (SyncImagePixels(image) == MagickFalse) break; } segment_info.x1=0; segment_info.y1=0; segment_info.x2=(double) image->columns-1; segment_info.y2=(double) image->rows-1; if (LocaleCompare(image_info->filename,"fractal") == 0) { /* Seed pixels before recursion. */ PlasmaPixel(image,segment_info.x1,segment_info.y1); PlasmaPixel(image,segment_info.x1,(segment_info.y1+segment_info.y2)/2); PlasmaPixel(image,segment_info.x1,segment_info.y2); PlasmaPixel(image,(segment_info.x1+segment_info.x2)/2,segment_info.y1); PlasmaPixel(image,(segment_info.x1+segment_info.x2)/2, (segment_info.y1+segment_info.y2)/2); PlasmaPixel(image,(segment_info.x1+segment_info.x2)/2,segment_info.y2); PlasmaPixel(image,segment_info.x2,segment_info.y1); PlasmaPixel(image,segment_info.x2,(segment_info.y1+segment_info.y2)/2); PlasmaPixel(image,segment_info.x2,segment_info.y2); } i=(unsigned long) MagickMax(image->columns,image->rows)/2; for (max_depth=0; i != 0; max_depth++) i>>=1; for (depth=1; ; depth++) { if (PlasmaImage(image,&segment_info,0,depth) != MagickFalse) break; if ((image->progress_monitor != (MagickProgressMonitor) NULL) && (QuantumTick((MagickOffsetType) depth,max_depth) != MagickFalse)) { status=image->progress_monitor(PlasmaImageTag,(MagickOffsetType) depth, max_depth,image->client_data); if (status == MagickFalse) break; } } (void) SetImageOpacity(image,OpaqueOpacity); return(GetFirstImageInList(image)); }
int tc_filter(frame_list_t *ptr_, char *options) { vframe_list_t *ptr = (vframe_list_t *)ptr_; int instance=ptr->filter_id; //---------------------------------- // // filter get config // //---------------------------------- if(ptr->tag & TC_FILTER_GET_CONFIG && options) { char buf[255]; optstr_filter_desc (options, MOD_NAME, MOD_CAP, MOD_VERSION, MOD_AUTHOR, "VRYOM", "1"); tc_snprintf (buf, sizeof(buf), "%u-%u", data[instance]->start, data[instance]->end); optstr_param (options, "range", "Frame Range", "%d-%d", buf, "0", "oo", "0", "oo"); tc_snprintf (buf, sizeof(buf), "%dx%d", data[instance]->xpos, data[instance]->ypos); optstr_param (options, "pos", "Position of logo", "%dx%d", buf, "0", "width", "0", "height"); tc_snprintf (buf, sizeof(buf), "%dx%d", data[instance]->width, data[instance]->height); optstr_param (options, "size", "Size of logo", "%dx%d", buf, "0", "width", "0", "height"); tc_snprintf (buf, sizeof(buf), "%d", data[instance]->mode); optstr_param (options, "mode", "Filter Mode (0=none,1=solid,2=xy,3=shape)", "%d", buf, "0", "3"); tc_snprintf (buf, sizeof(buf), "%d", data[instance]->border); optstr_param (options, "border", "Visible Border", "", buf); tc_snprintf (buf, sizeof(buf), "%d", data[instance]->dump); optstr_param (options, "dump", "Dump filterarea to file", "", buf); tc_snprintf (buf, sizeof(buf), "%d", data[instance]->xweight); optstr_param (options, "xweight","X-Y Weight(0%-100%)", "%d", buf, "0", "100"); tc_snprintf (buf, sizeof(buf), "%x%x%x", data[instance]->rcolor, data[instance]->gcolor, data[instance]->bcolor); optstr_param (options, "fill", "Solid Fill Color(RGB)", "%2x%2x%2x", buf, "00", "FF", "00", "FF", "00", "FF"); tc_snprintf (buf, sizeof(buf), "%s", data[instance]->file); optstr_param (options, "file", "Image with alpha/shape information", "%s", buf); return 0; } //---------------------------------- // // filter init // //---------------------------------- if(ptr->tag & TC_FILTER_INIT) { if((vob = tc_get_vob())==NULL) return(-1); if((data[instance] = tc_malloc (sizeof(logoaway_data))) == NULL) { tc_log_error(MOD_NAME, "can't allocate filter data"); return (-1); } data[instance]->start = 0; data[instance]->end = (unsigned int)-1; data[instance]->xpos = -1; data[instance]->ypos = -1; data[instance]->width = -1; data[instance]->height = -1; data[instance]->mode = 0; data[instance]->border = 0; data[instance]->xweight = 50; data[instance]->yweight = 50; data[instance]->rcolor = 0; data[instance]->gcolor = 0; data[instance]->bcolor = 0; data[instance]->ycolor = 16; data[instance]->ucolor = 128; data[instance]->vcolor = 128; data[instance]->alpha = 0; data[instance]->dump = 0; // filter init ok. if(verbose) tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP); if(options!=NULL) { optstr_get (options, "range", "%d-%d", &data[instance]->start, &data[instance]->end); optstr_get (options, "pos", "%dx%d", &data[instance]->xpos, &data[instance]->ypos); optstr_get (options, "size", "%dx%d", &data[instance]->width, &data[instance]->height); data[instance]->width += data[instance]->xpos; data[instance]->height += data[instance]->ypos; optstr_get (options, "mode", "%d", &data[instance]->mode); if (optstr_lookup (options, "border") != NULL) data[instance]->border = 1; if (optstr_lookup (options, "help") != NULL) help_optstr(); optstr_get (options, "xweight", "%d", &data[instance]->xweight); data[instance]->yweight = 100 - data[instance]->xweight; optstr_get (options, "fill", "%2x%2x%2x", &data[instance]->rcolor, &data[instance]->gcolor, &data[instance]->bcolor); data[instance]->ycolor = (0.257 * data[instance]->rcolor) + (0.504 * data[instance]->gcolor) + (0.098 * data[instance]->bcolor) + 16; data[instance]->ucolor = (0.439 * data[instance]->rcolor) - (0.368 * data[instance]->gcolor) - (0.071 * data[instance]->bcolor) + 128; data[instance]->vcolor = -(0.148 * data[instance]->rcolor) - (0.291 * data[instance]->gcolor) + (0.439 * data[instance]->bcolor) + 128; if (optstr_get (options, "file", "%[^:]", data[instance]->file) >= 0) data[instance]->alpha = 1; if (optstr_lookup (options, "dump") != NULL) data[instance]->dump = 1; } if(verbose) tc_log_info(MOD_NAME, "instance(%d) options=%s", instance, options); if(verbose > 1) { tc_log_info (MOD_NAME, " LogoAway Filter Settings:"); tc_log_info (MOD_NAME, " pos = %dx%d", data[instance]->xpos, data[instance]->ypos); tc_log_info (MOD_NAME, " size = %dx%d", data[instance]->width-data[instance]->xpos, data[instance]->height-data[instance]->ypos); tc_log_info (MOD_NAME, " mode = %d(%s)", data[instance]->mode, modes[data[instance]->mode]); tc_log_info (MOD_NAME, " border = %d", data[instance]->border); tc_log_info (MOD_NAME, " x-y weight = %d:%d", data[instance]->xweight, data[instance]->yweight); tc_log_info (MOD_NAME, " fill color = %2X%2X%2X", data[instance]->rcolor, data[instance]->gcolor, data[instance]->bcolor); if(data[instance]->alpha) tc_log_info (MOD_NAME, " file = %s", data[instance]->file); if(data[instance]->dump) tc_log_info (MOD_NAME, " dump = %d", data[instance]->dump); } if( (data[instance]->xpos > vob->im_v_width) || (data[instance]->ypos > vob->im_v_height) || (data[instance]->xpos < 0) || (data[instance]->ypos < 0) ) { tc_log_error(MOD_NAME, "invalid position"); return(-1); } if( (data[instance]->width > vob->im_v_width) || (data[instance]->height > vob->im_v_height) || (data[instance]->width-data[instance]->xpos < 0) || (data[instance]->height-data[instance]->ypos < 0) ) { tc_log_error(MOD_NAME, "invalid size"); return(-1); } if( (data[instance]->xweight > 100) || (data[instance]->xweight < 0) ) { tc_log_error(MOD_NAME, "invalid x weight"); return(-1); } if( (data[instance]->mode < 0) || (data[instance]->mode > 3) ) { tc_log_error(MOD_NAME, "invalid mode"); return(-1); } if( (data[instance]->mode == 3) && (data[instance]->alpha == 0) ) { tc_log_error(MOD_NAME, "alpha/shape file needed for SHAPE-mode"); return(-1); } if((data[instance]->alpha) || (data[instance]->dump)) { InitializeMagick(""); GetExceptionInfo(&data[instance]->exception_info); if(data[instance]->alpha) { data[instance]->image_info = CloneImageInfo((ImageInfo *) NULL); strlcpy(data[instance]->image_info->filename, data[instance]->file, MaxTextExtent); data[instance]->image = ReadImage(data[instance]->image_info, &data[instance]->exception_info); if (data[instance]->image == (Image *) NULL) { tc_log_error(MOD_NAME, "\n"); MagickWarning (data[instance]->exception_info.severity, data[instance]->exception_info.reason, data[instance]->exception_info.description); return(-1); } if ((data[instance]->image->columns != (data[instance]->width-data[instance]->xpos)) || (data[instance]->image->rows != (data[instance]->height-data[instance]->ypos))) { tc_log_error(MOD_NAME, "\"%s\" has incorrect size", data[instance]->file); return(-1); } data[instance]->pixel_packet = GetImagePixels(data[instance]->image, 0, 0, data[instance]->image->columns, data[instance]->image->rows); } if(data[instance]->dump) { if((data[instance]->dump_buf = tc_malloc ((data[instance]->width-data[instance]->xpos)*(data[instance]->height-data[instance]->ypos)*3)) == NULL) tc_log_error(MOD_NAME, "out of memory"); data[instance]->dumpimage_info = CloneImageInfo((ImageInfo *) NULL); } } return(0); } //---------------------------------- // // filter close // //---------------------------------- if(ptr->tag & TC_FILTER_CLOSE) { if (data[instance]->image != (Image *)NULL) { DestroyImage(data[instance]->image); DestroyImageInfo(data[instance]->image_info); } if (data[instance]->dumpimage != (Image *)NULL) { DestroyImage(data[instance]->dumpimage); DestroyImageInfo(data[instance]->dumpimage_info); DestroyConstitute(); } DestroyExceptionInfo(&data[instance]->exception_info); DestroyMagick(); if(data[instance]->dump_buf) free(data[instance]->dump_buf); if(data[instance]) free(data[instance]); data[instance] = NULL; return(0); } //---------------------------------- // // filter frame routine // //---------------------------------- if(ptr->tag & TC_PRE_M_PROCESS && ptr->tag & TC_VIDEO && !(ptr->attributes & TC_FRAME_IS_SKIPPED)) { if (ptr->id < data[instance]->start || ptr->id > data[instance]->end) return (0); if(vob->im_v_codec==TC_CODEC_RGB24) { work_with_rgb_frame(ptr->video_buf, vob->im_v_width, vob->im_v_height, instance); } else { work_with_yuv_frame(ptr->video_buf, vob->im_v_width, vob->im_v_height, instance); } } return(0); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % R e a d S T E G A N O I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ReadSTEGANOImage() reads a steganographic image hidden within another % image type. It allocates the memory necessary for the new Image structure % and returns a pointer to the new image. % % The format of the ReadSTEGANOImage method is: % % Image *ReadSTEGANOImage(const ImageInfo *image_info, % ExceptionInfo *exception) % % A description of each parameter follows: % % o image_info: The image info. % % o exception: return any errors or warnings in this structure. % */ static Image *ReadSTEGANOImage(const ImageInfo *image_info, ExceptionInfo *exception) { #define GetBit(alpha,i) (((unsigned long) (alpha) >> (unsigned long) \ (i)) & 0x01) #define SetBit(alpha,i,set) (alpha)=(Quantum) ((set) != 0 ? (unsigned long) \ (alpha) | (1UL << (unsigned long) (i)) : (unsigned long) (alpha) & \ ~(1UL << (unsigned long) (i))) Image *image, *watermark; ImageInfo *read_info; long c, i, j, k, y; MagickBooleanType status; PixelPacket pixel; register IndexPacket *indexes; register long x; register PixelPacket *q; /* Initialize Image structure. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); if (image_info->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", image_info->filename); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); image=AllocateImage(image_info); if ((image->columns == 0) || (image->rows == 0)) ThrowReaderException(OptionError,"MustSpecifyImageSize"); read_info=CloneImageInfo(image_info); SetImageInfoBlob(read_info,(void *) NULL,0); *read_info->magick='\0'; watermark=ReadImage(read_info,exception); read_info=DestroyImageInfo(read_info); if (watermark == (Image *) NULL) return((Image *) NULL); watermark->depth=MAGICKCORE_QUANTUM_DEPTH; if (AllocateImageColormap(image,MaxColormapSize) == MagickFalse) ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed"); if (image_info->ping != MagickFalse) { CloseBlob(image); return(GetFirstImageInList(image)); } /* Get hidden watermark from low-order bits of image. */ c=0; i=0; j=0; k=image->offset; for (i=MAGICKCORE_QUANTUM_DEPTH-1; (i >= 0) && (j < MAGICKCORE_QUANTUM_DEPTH); i--) { for (y=0; (y < (long) image->rows) && (j < MAGICKCORE_QUANTUM_DEPTH); y++) { for (x=0; (x < (long) image->columns) && (j < MAGICKCORE_QUANTUM_DEPTH); x++) { pixel=AcquireOnePixel(watermark,k % (long) watermark->columns, k/(long) watermark->columns,exception); q=GetImagePixels(image,x,y,1,1); if (q == (PixelPacket *) NULL) break; indexes=GetIndexes(image); switch (c) { case 0: { SetBit(*indexes,i,GetBit(pixel.red,j)); break; } case 1: { SetBit(*indexes,i,GetBit(pixel.green,j)); break; } case 2: { SetBit(*indexes,i,GetBit(pixel.blue,j)); break; } } if (SyncImagePixels(image) == MagickFalse) break; c++; if (c == 3) c=0; k++; if (k == (long) (watermark->columns*watermark->columns)) k=0; if (k == image->offset) j++; } } if ((image->progress_monitor != (MagickProgressMonitor) NULL) && (QuantumTick(i,MAGICKCORE_QUANTUM_DEPTH) != MagickFalse)) { status=image->progress_monitor(LoadImagesTag,i,MAGICKCORE_QUANTUM_DEPTH, image->client_data); if (status == MagickFalse) break; } } watermark=DestroyImage(watermark); (void) SyncImage(image); return(GetFirstImageInList(image)); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % R e a d X C I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ReadXCImage creates a constant image and initializes it to the % X server color as specified by the filename. It allocates the memory % necessary for the new Image structure and returns a pointer to the new % image. % % The format of the ReadXCImage method is: % % Image *ReadXCImage(const ImageInfo *image_info,ExceptionInfo *exception) % % A description of each parameter follows: % % o image: The image. % % o image_info: the image info. % % o exception: return any errors or warnings in this structure. % */ static Image *ReadXCImage(const ImageInfo *image_info,ExceptionInfo *exception) { Image *image; IndexPacket *indexes; MagickBooleanType status; MagickPixelPacket color; long y; register long x; register PixelPacket *q; /* Initialize Image structure. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); if (image_info->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", image_info->filename); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); image=AllocateImage(image_info); if (image->columns == 0) image->columns=1; if (image->rows == 0) image->rows=1; (void) CopyMagickString(image->filename,image_info->filename,MaxTextExtent); status=QueryMagickColor((char *) image_info->filename,&color,exception); if (status == MagickFalse) { image=DestroyImage(image); return((Image *) NULL); } image->colorspace=color.colorspace; image->matte=color.matte; if ((image->colorspace == RGBColorspace) && (image->matte == MagickFalse)) { if (AllocateImageColormap(image,1) == MagickFalse) ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed"); (void) QueryColorDatabase((char *) image_info->filename, &image->background_color,exception); image->colormap[0]=image->background_color; color.index=0.0; } if (SetImageExtent(image,0,0) == MagickFalse) { InheritException(exception,&image->exception); return(DestroyImageList(image)); } for (y=0; y < (long) image->rows; y++) { q=GetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; indexes=GetIndexes(image); for (x=0; x < (long) image->columns; x++) { q->red=RoundToQuantum(color.red); q->green=RoundToQuantum(color.green); q->blue=RoundToQuantum(color.blue); if (image->matte) q->opacity=RoundToQuantum(color.opacity); if ((image->storage_class == PseudoClass) || (image->colorspace == CMYKColorspace)) indexes[x]=(IndexPacket) RoundToQuantum(color.index); q++; } if (SyncImagePixels(image) == MagickFalse) break; } return(GetFirstImageInList(image)); }
int tc_filter(frame_list_t *ptr_, char *options) { vframe_list_t *ptr = (vframe_list_t *)ptr_; vob_t *vob = NULL; int instance = ptr->filter_id; MyFilterData *mfd = mfd_all[instance]; if (mfd != NULL) { vob = mfd->vob; } //---------------------------------- // // filter init // //---------------------------------- if (ptr->tag & TC_FILTER_GET_CONFIG) { optstr_filter_desc(options, MOD_NAME, MOD_CAP, MOD_VERSION, MOD_AUTHOR, "VRYO", "1"); // buf, name, comment, format, val, from, to optstr_param(options, "file", "Image filename", "%s", "logo.png"); optstr_param(options, "posdef", "Position (0=None, 1=TopL, 2=TopR, 3=BotL, 4=BotR, 5=Center)", "%d", "0", "0", "5"); optstr_param(options, "pos", "Position (0-width x 0-height)", "%dx%d", "0x0", "0", "width", "0", "height"); optstr_param(options, "range", "Restrict rendering to framerange", "%u-%u", "0-0", "0", "oo", "0", "oo"); optstr_param(options, "fade", "Fade image in/out (# of frames)", "%u-%u", "0-0", "0", "oo", "0", "oo"); // bools optstr_param(options, "ignoredelay", "Ignore delay specified in animations", "", "0"); optstr_param(options, "rgbswap", "Swap red/blue colors", "", "0"); optstr_param(options, "grayout", "YUV only: don't write Cb and Cr, makes a nice effect", "", "0"); optstr_param(options, "hqconv", "YUV only: do high quality rgb->yuv img conversion", "", "0"); optstr_param(options, "flip", "Mirror image", "", "0"); return 0; } if (ptr->tag & TC_FILTER_INIT) { Image *timg; Image *nimg; ImageInfo *image_info; ExceptionInfo exception_info; int rgb_off = 0; vob_t *tmpvob; tmpvob = tc_get_vob(); if (tmpvob == NULL) return -1; mfd_all[instance] = tc_zalloc(sizeof(MyFilterData)); if (mfd_all[instance] == NULL) return -1; mfd = mfd_all[instance]; strlcpy(mfd->file, "logo.png", PATH_MAX); mfd->end = (unsigned int)-1; mfd->vob = tmpvob; vob = mfd->vob; if (options != NULL) { if (verbose) tc_log_info(MOD_NAME, "options=%s", options); optstr_get(options, "file", "%[^:]", mfd->file); optstr_get(options, "posdef", "%d", (int *)&mfd->pos); optstr_get(options, "pos", "%dx%d", &mfd->posx, &mfd->posy); optstr_get(options, "range", "%u-%u", &mfd->start, &mfd->end); optstr_get(options, "fade", "%u-%u", &mfd->fadein, &mfd->fadeout); if (optstr_lookup(options, "ignoredelay") != NULL) mfd->ignoredelay = !mfd->ignoredelay; if (optstr_lookup(options, "flip") != NULL) mfd->flip = !mfd->flip; if (optstr_lookup(options, "rgbswap") != NULL) mfd->rgbswap = !mfd->rgbswap; if (optstr_lookup(options, "grayout") != NULL) mfd->grayout = !mfd->grayout; if (optstr_lookup(options, "hqconv") != NULL) mfd->hqconv = !mfd->hqconv; if (optstr_lookup (options, "help") != NULL) flogo_help_optstr(); } if (verbose > 1) { tc_log_info(MOD_NAME, " Logo renderer Settings:"); tc_log_info(MOD_NAME, " file = %s", mfd->file); tc_log_info(MOD_NAME, " posdef = %d", mfd->pos); tc_log_info(MOD_NAME, " pos = %dx%d", mfd->posx, mfd->posy); tc_log_info(MOD_NAME, " range = %u-%u", mfd->start, mfd->end); tc_log_info(MOD_NAME, " fade = %u-%u", mfd->fadein, mfd->fadeout); tc_log_info(MOD_NAME, " flip = %d", mfd->flip); tc_log_info(MOD_NAME, " ignoredelay = %d", mfd->ignoredelay); tc_log_info(MOD_NAME, " rgbswap = %d", mfd->rgbswap); tc_log_info(MOD_NAME, " grayout = %d", mfd->grayout); tc_log_info(MOD_NAME, " hqconv = %d", mfd->hqconv); } /* Transcode serializes module execution, so this does not need a * semaphore. */ magick_usecount++; if (!IsMagickInstantiated()) { InitializeMagick(""); } GetExceptionInfo(&exception_info); image_info = CloneImageInfo((ImageInfo *) NULL); strlcpy(image_info->filename, mfd->file, MaxTextExtent); mfd->image = ReadImage(image_info, &exception_info); if (mfd->image == (Image *) NULL) { MagickWarning(exception_info.severity, exception_info.reason, exception_info.description); strlcpy(mfd->file, "/dev/null", PATH_MAX); return 0; } DestroyImageInfo(image_info); if (mfd->image->columns > vob->ex_v_width || mfd->image->rows > vob->ex_v_height ) { tc_log_error(MOD_NAME, "\"%s\" is too large", mfd->file); return -1; } if (vob->im_v_codec == TC_CODEC_YUV420P) { if ((mfd->image->columns & 1) || (mfd->image->rows & 1)) { tc_log_error(MOD_NAME, "\"%s\" has odd sizes", mfd->file); return -1; } } mfd->images = (Image *)GetFirstImageInList(mfd->image); nimg = NewImageList(); while (mfd->images != (Image *)NULL) { if (mfd->flip || flip) { timg = FlipImage(mfd->images, &exception_info); if (timg == (Image *) NULL) { MagickError(exception_info.severity, exception_info.reason, exception_info.description); return -1; } AppendImageToList(&nimg, timg); } mfd->images = GetNextImageInList(mfd->images); mfd->nr_of_images++; } // check for memleaks; //DestroyImageList(image); if (mfd->flip || flip) { mfd->image = nimg; } /* initial delay. real delay = 1/100 sec * delay */ mfd->cur_delay = mfd->image->delay*vob->fps/100; if (verbose & TC_DEBUG) tc_log_info(MOD_NAME, "Nr: %d Delay: %d mfd->image->del %lu|", mfd->nr_of_images, mfd->cur_delay, mfd->image->delay); if (vob->im_v_codec == TC_CODEC_YUV420P) { /* convert Magick RGB image format to YUV */ /* todo: convert the magick image if it's not rgb! (e.g. cmyk) */ Image *image; uint8_t *yuv_hqbuf = NULL; /* Round up for odd-size images */ unsigned long width = mfd->image->columns; unsigned long height = mfd->image->rows; int do_rgbswap = (rgbswap || mfd->rgbswap); int i; /* Allocate buffers for the YUV420P frames. mfd->nr_of_images * will be 1 unless this is an animated GIF or MNG. * This buffer needs to be large enough to store a temporary * 24-bit RGB image (extracted from the ImageMagick handle). */ mfd->yuv = flogo_yuvbuf_alloc(width*height * 3, mfd->nr_of_images); if (mfd->yuv == NULL) { tc_log_error(MOD_NAME, "(%d) out of memory\n", __LINE__); return -1; } if (mfd->hqconv) { /* One temporary buffer, to hold full Y, U, and V planes. */ yuv_hqbuf = tc_malloc(width*height * 3); if (yuv_hqbuf == NULL) { tc_log_error(MOD_NAME, "(%d) out of memory\n", __LINE__); return -1; } } mfd->tcvhandle = tcv_init(); if (mfd->tcvhandle == NULL) { tc_log_error(MOD_NAME, "image conversion init failed"); return -1; } image = GetFirstImageInList(mfd->image); for (i = 0; i < mfd->nr_of_images; i++) { if (!mfd->hqconv) { flogo_convert_image(mfd->tcvhandle, image, mfd->yuv[i], IMG_YUV420P, do_rgbswap); } else { flogo_convert_image(mfd->tcvhandle, image, yuv_hqbuf, IMG_YUV444P, do_rgbswap); // Copy over Y data from the 444 image ac_memcpy(mfd->yuv[i], yuv_hqbuf, width * height); // Resize U plane by 1/2 in each dimension, into the // mfd YUV buffer tcv_zoom(mfd->tcvhandle, yuv_hqbuf + (width * height), mfd->yuv[i] + (width * height), width, height, 1, width / 2, height / 2, TCV_ZOOM_LANCZOS3 ); // Do the same with the V plane tcv_zoom(mfd->tcvhandle, yuv_hqbuf + 2*width*height, mfd->yuv[i] + width*height + (width/2)*(height/2), width, height, 1, width / 2, height / 2, TCV_ZOOM_LANCZOS3 ); } image = GetNextImageInList(image); } if (mfd->hqconv) tc_free(yuv_hqbuf); tcv_free(mfd->tcvhandle); } else { /* for RGB format is origin bottom left */ /* for RGB, rgbswap is done in the frame routine */ rgb_off = vob->ex_v_height - mfd->image->rows; mfd->posy = rgb_off - mfd->posy; } switch (mfd->pos) { case NONE: /* 0 */ break; case TOP_LEFT: mfd->posx = 0; mfd->posy = rgb_off; break; case TOP_RIGHT: mfd->posx = vob->ex_v_width - mfd->image->columns; break; case BOT_LEFT: mfd->posy = vob->ex_v_height - mfd->image->rows - rgb_off; break; case BOT_RIGHT: mfd->posx = vob->ex_v_width - mfd->image->columns; mfd->posy = vob->ex_v_height - mfd->image->rows - rgb_off; break; case CENTER: mfd->posx = (vob->ex_v_width - mfd->image->columns)/2; mfd->posy = (vob->ex_v_height- mfd->image->rows)/2; /* align to not cause color disruption */ if (mfd->posx & 1) mfd->posx++; if (mfd->posy & 1) mfd->posy++; break; } if (mfd->posy < 0 || mfd->posx < 0 || (mfd->posx + mfd->image->columns) > vob->ex_v_width || (mfd->posy + mfd->image->rows) > vob->ex_v_height) { tc_log_error(MOD_NAME, "invalid position"); return -1; } /* for running through image sequence */ mfd->images = mfd->image; /* Set up image/video coefficient lookup tables */ if (img_coeff_lookup[0] < 0) { int i; float maxrgbval = (float)MaxRGB; // from ImageMagick for (i = 0; i <= MAX_UINT8_VAL; i++) { float x = (float)ScaleCharToQuantum(i); /* Alternatively: * img_coeff = (maxrgbval - x) / maxrgbval; * vid_coeff = x / maxrgbval; */ img_coeff_lookup[i] = 1.0 - (x / maxrgbval); vid_coeff_lookup[i] = 1.0 - img_coeff_lookup[i]; } } // filter init ok. if (verbose) tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP); return 0; } //---------------------------------- // // filter close // //---------------------------------- if (ptr->tag & TC_FILTER_CLOSE) { if (mfd) { flogo_yuvbuf_free(mfd->yuv, mfd->nr_of_images); mfd->yuv = NULL; if (mfd->image) { DestroyImage(mfd->image); } tc_free(mfd); mfd = NULL; mfd_all[instance] = NULL; } magick_usecount--; if (magick_usecount == 0 && IsMagickInstantiated()) { DestroyMagick(); } return 0; } /* filter close */ //---------------------------------- // // filter frame routine // //---------------------------------- // tag variable indicates, if we are called before // transcodes internal video/audo frame processing routines // or after and determines video/audio context if ((ptr->tag & TC_POST_M_PROCESS) && (ptr->tag & TC_VIDEO) && !(ptr->attributes & TC_FRAME_IS_SKIPPED) ) { PixelPacket *pixel_packet; uint8_t *video_buf; int do_fade = 0; float fade_coeff = 0.0; float img_coeff, vid_coeff; /* Note: ImageMagick defines opacity = 0 as fully visible, and * opacity = MaxRGB as fully transparent. */ Quantum opacity; int row, col; if (ptr->id < mfd->start || ptr->id > mfd->end) return 0; if (strcmp(mfd->file, "/dev/null") == 0) return 0; if (ptr->id - mfd->start < mfd->fadein) { // fading-in fade_coeff = (float)(mfd->start - ptr->id + mfd->fadein) / (float)(mfd->fadein); do_fade = 1; } else if (mfd->end - ptr->id < mfd->fadeout) { // fading-out fade_coeff = (float)(ptr->id - mfd->end + mfd->fadeout) / (float)(mfd->fadeout); do_fade = 1; } mfd->cur_delay--; if (mfd->cur_delay < 0 || mfd->ignoredelay) { int seq; mfd->cur_seq = (mfd->cur_seq + 1) % mfd->nr_of_images; mfd->images = mfd->image; for (seq=0; seq<mfd->cur_seq; seq++) mfd->images = mfd->images->next; mfd->cur_delay = mfd->images->delay * vob->fps/100; } pixel_packet = GetImagePixels(mfd->images, 0, 0, mfd->images->columns, mfd->images->rows); if (vob->im_v_codec == TC_CODEC_RGB24) { unsigned long r_off, g_off, b_off; if (!(rgbswap || mfd->rgbswap)) { r_off = 0; b_off = 2; } else { r_off = 2; b_off = 0; } g_off = 1; for (row = 0; row < mfd->image->rows; row++) { video_buf = ptr->video_buf + 3 * ((row + mfd->posy) * vob->ex_v_width + mfd->posx); for (col = 0; col < mfd->image->columns; col++) { opacity = pixel_packet->opacity; if (do_fade) opacity += (Quantum)((MaxRGB - opacity) * fade_coeff); if (opacity == 0) { *(video_buf + r_off) = ScaleQuantumToChar(pixel_packet->red); *(video_buf + g_off) = ScaleQuantumToChar(pixel_packet->green); *(video_buf + b_off) = ScaleQuantumToChar(pixel_packet->blue); } else if (opacity < MaxRGB) { unsigned char opacity_uchar = ScaleQuantumToChar(opacity); img_coeff = img_coeff_lookup[opacity_uchar]; vid_coeff = vid_coeff_lookup[opacity_uchar]; *(video_buf + r_off) = (uint8_t)((*(video_buf + r_off)) * vid_coeff) + (uint8_t)(ScaleQuantumToChar(pixel_packet->red) * img_coeff); *(video_buf + g_off) = (uint8_t)((*(video_buf + g_off)) * vid_coeff) + (uint8_t)(ScaleQuantumToChar(pixel_packet->green) * img_coeff); *(video_buf + b_off) = (uint8_t)((*(video_buf + b_off)) * vid_coeff) + (uint8_t)(ScaleQuantumToChar(pixel_packet->blue) * img_coeff); } video_buf += 3; pixel_packet++; } } } else { /* !RGB */ unsigned long vid_size = vob->ex_v_width * vob->ex_v_height; unsigned long img_size = mfd->images->columns * mfd->images->rows; uint8_t *img_pixel_Y, *img_pixel_U, *img_pixel_V; uint8_t *vid_pixel_Y, *vid_pixel_U, *vid_pixel_V; img_pixel_Y = mfd->yuv[mfd->cur_seq]; img_pixel_U = img_pixel_Y + img_size; img_pixel_V = img_pixel_U + img_size/4; for (row = 0; row < mfd->images->rows; row++) { vid_pixel_Y = ptr->video_buf + (row + mfd->posy)*mfd->vob->ex_v_width + mfd->posx; vid_pixel_U = ptr->video_buf + vid_size + (row/2 + mfd->posy/2)*(mfd->vob->ex_v_width/2) + mfd->posx/2; vid_pixel_V = vid_pixel_U + vid_size/4; for (col = 0; col < mfd->images->columns; col++) { int do_UV_pixels = (mfd->grayout == 0 && !(row % 2) && !(col % 2)) ? 1 : 0; opacity = pixel_packet->opacity; if (do_fade) opacity += (Quantum)((MaxRGB - opacity) * fade_coeff); if (opacity == 0) { *vid_pixel_Y = *img_pixel_Y; if (do_UV_pixels) { *vid_pixel_U = *img_pixel_U; *vid_pixel_V = *img_pixel_V; } } else if (opacity < MaxRGB) { unsigned char opacity_uchar = ScaleQuantumToChar(opacity); img_coeff = img_coeff_lookup[opacity_uchar]; vid_coeff = vid_coeff_lookup[opacity_uchar]; *vid_pixel_Y = (uint8_t)(*vid_pixel_Y * vid_coeff) + (uint8_t)(*img_pixel_Y * img_coeff); if (do_UV_pixels) { *vid_pixel_U = (uint8_t)(*vid_pixel_U * vid_coeff) + (uint8_t)(*img_pixel_U * img_coeff); *vid_pixel_V = (uint8_t)(*vid_pixel_V * vid_coeff) + (uint8_t)(*img_pixel_V * img_coeff); } } vid_pixel_Y++; img_pixel_Y++; if (do_UV_pixels) { vid_pixel_U++; img_pixel_U++; vid_pixel_V++; img_pixel_V++; } pixel_packet++; } } } } return 0; }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % R e a d R G B I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ReadRGBImage() reads an image of raw red, green, and blue samples and % returns it. It allocates the memory necessary for the new Image structure % and returns a pointer to the new image. % % The format of the ReadRGBImage method is: % % Image *ReadRGBImage(const ImageInfo *image_info,ExceptionInfo *exception) % % A description of each parameter follows: % % o image_info: The image info. % % o exception: return any errors or warnings in this structure. % */ static Image *ReadRGBImage(const ImageInfo *image_info,ExceptionInfo *exception) { Image *image; long y; MagickBooleanType status; MagickOffsetType offset; QuantumInfo quantum_info; register long i; register PixelPacket *q; ssize_t count; size_t packet_size; unsigned char *pixels; unsigned long width; assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); if (image_info->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", image_info->filename); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); image=AllocateImage(image_info); if ((image->columns == 0) || (image->rows == 0)) ThrowReaderException(OptionError,"MustSpecifyImageSize"); if (image_info->interlace != PartitionInterlace) { /* Open image file. */ status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == MagickFalse) { image=DestroyImageList(image); return((Image *) NULL); } for (i=0; i < image->offset; i++) if (ReadBlobByte(image) == EOF) { ThrowFileException(exception,CorruptImageError, "UnexpectedEndOfFile",image->filename); break; } } /* Allocate memory for a pixels. */ packet_size=(size_t) ((3*image->depth+7)/8); if ((LocaleCompare(image_info->magick,"RGBA") == 0) || (LocaleCompare(image_info->magick,"RGBO") == 0)) { packet_size+=(image->depth+7)/8; image->matte=MagickTrue; } pixels=(unsigned char *) AcquireQuantumMemory(image->extract_info.width, packet_size*sizeof(*pixels)); if (pixels == (unsigned char *) NULL) ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed"); if (image_info->number_scenes != 0) while (image->scene < image_info->scene) { /* Skip to next image. */ image->scene++; for (y=0; y < (long) image->rows; y++) { count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } } offset=(MagickOffsetType) (packet_size*image->extract_info.x); do { /* Convert raster image to pixel packets. */ GetQuantumInfo(image_info,&quantum_info); if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0)) if (image->scene >= (image_info->scene+image_info->number_scenes-1)) break; if (SetImageExtent(image,0,0) == MagickFalse) { InheritException(exception,&image->exception); return(DestroyImageList(image)); } switch (image_info->interlace) { case NoInterlace: default: { /* No interlacing: RGBRGBRGBRGBRGBRGB... */ for (y=0; y < image->extract_info.y; y++) { count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } for (y=0; y < (long) image->rows; y++) { if ((y > 0) || (GetPreviousImageInList(image) == (Image *) NULL)) { count=ReadBlob(image,packet_size*image->extract_info.width, pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } q=SetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; if (image->matte == MagickFalse) (void) ExportQuantumPixels(image,&quantum_info,RGBQuantum, pixels+offset); else if (LocaleCompare(image_info->magick,"RGBA") == 0) (void) ExportQuantumPixels(image,&quantum_info,RGBAQuantum, pixels+offset); else (void) ExportQuantumPixels(image,&quantum_info,RGBOQuantum, pixels+offset); if (SyncImagePixels(image) == MagickFalse) break; if (image->previous == (Image *) NULL) if ((image->progress_monitor != (MagickProgressMonitor) NULL) && (QuantumTick(y,image->rows) != MagickFalse)) { status=image->progress_monitor(LoadImageTag,y,image->rows, image->client_data); if (status == MagickFalse) break; } } width=image->extract_info.height-image->rows-image->extract_info.y; for (i=0; i < (long) width; i++) { count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } break; } case LineInterlace: { /* Line interlacing: RRR...GGG...BBB...RRR...GGG...BBB... */ packet_size=(size_t) ((image->depth+7)/8); for (y=0; y < image->extract_info.y; y++) { count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } for (y=0; y < (long) image->rows; y++) { if ((y > 0) || (GetPreviousImageInList(image) == (Image *) NULL)) { count=ReadBlob(image,packet_size*image->extract_info.width, pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } q=SetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; (void) ExportQuantumPixels(image,&quantum_info,RedQuantum, pixels+offset); count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; (void) ExportQuantumPixels(image,&quantum_info,GreenQuantum, pixels+offset); count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; (void) ExportQuantumPixels(image,&quantum_info,BlueQuantum, pixels+offset); if (image->matte != MagickFalse) { count=ReadBlob(image,packet_size*image->extract_info.width, pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; if (LocaleCompare(image_info->magick,"RGBA") == 0) (void) ExportQuantumPixels(image,&quantum_info,AlphaQuantum, pixels+offset); else (void) ExportQuantumPixels(image,&quantum_info,OpacityQuantum, pixels+offset); } if (SyncImagePixels(image) == MagickFalse) break; if (image->previous == (Image *) NULL) if ((image->progress_monitor != (MagickProgressMonitor) NULL) && (QuantumTick(y,image->rows) != MagickFalse)) { status=image->progress_monitor(LoadImageTag,y,image->rows, image->client_data); if (status == MagickFalse) break; } } width=image->extract_info.height-image->rows-image->extract_info.y; for (i=0; i < (long) width; i++) { count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } break; } case PlaneInterlace: case PartitionInterlace: { unsigned long span; /* Plane interlacing: RRRRRR...GGGGGG...BBBBBB... */ if (image_info->interlace == PartitionInterlace) { AppendImageFormat("R",image->filename); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == MagickFalse) { image=DestroyImageList(image); return((Image *) NULL); } } packet_size=(size_t) ((image->depth+7)/8); for (y=0; y < image->extract_info.y; y++) { count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } i=0; span=image->rows*(image->matte != MagickFalse ? 4 : 3); for (y=0; y < (long) image->rows; y++) { if ((y > 0) || (GetPreviousImageInList(image) == (Image *) NULL)) { count=ReadBlob(image,packet_size*image->extract_info.width, pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } q=SetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; (void) ExportQuantumPixels(image,&quantum_info,RedQuantum, pixels+offset); if (SyncImagePixels(image) == MagickFalse) break; if (image->previous == (Image *) NULL) if ((image->progress_monitor != (MagickProgressMonitor) NULL) && (QuantumTick(i,span) != MagickFalse)) { status=image->progress_monitor(LoadImageTag,i,span, image->client_data); if (status == MagickFalse) break; } i++; } width=image->extract_info.height-image->rows-image->extract_info.y; for (i=0; i < (long) width; i++) { count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } if (image_info->interlace == PartitionInterlace) { CloseBlob(image); AppendImageFormat("G",image->filename); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == MagickFalse) { image=DestroyImageList(image); return((Image *) NULL); } } for (y=0; y < image->extract_info.y; y++) { count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } for (y=0; y < (long) image->rows; y++) { count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; q=GetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; (void) ExportQuantumPixels(image,&quantum_info,GreenQuantum, pixels+offset); if (SyncImagePixels(image) == MagickFalse) break; if (image->previous == (Image *) NULL) if ((image->progress_monitor != (MagickProgressMonitor) NULL) && (QuantumTick(i,span) != MagickFalse)) { status=image->progress_monitor(LoadImageTag,i,span, image->client_data); if (status == MagickFalse) break; } i++; } width=image->extract_info.height-image->rows-image->extract_info.y; for (i=0; i < (long) width; i++) { count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } if (image_info->interlace == PartitionInterlace) { CloseBlob(image); AppendImageFormat("B",image->filename); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == MagickFalse) { image=DestroyImageList(image); return((Image *) NULL); } } for (y=0; y < image->extract_info.y; y++) { count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } for (y=0; y < (long) image->rows; y++) { count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; q=GetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; (void) ExportQuantumPixels(image,&quantum_info,BlueQuantum, pixels+offset); if (SyncImagePixels(image) == MagickFalse) break; if (image->previous == (Image *) NULL) if ((image->progress_monitor != (MagickProgressMonitor) NULL) && (QuantumTick(i,span) != MagickFalse)) { status=image->progress_monitor(LoadImageTag,i,span, image->client_data); if (status == MagickFalse) break; } i++; } width=image->extract_info.height-image->rows-image->extract_info.y; for (i=0; i < (long) width; i++) { count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } if (image->matte != MagickFalse) { /* Read matte channel. */ if (image_info->interlace == PartitionInterlace) { CloseBlob(image); AppendImageFormat("A",image->filename); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == MagickFalse) { image=DestroyImageList(image); return((Image *) NULL); } } for (y=0; y < image->extract_info.y; y++) { count=ReadBlob(image,packet_size*image->extract_info.width, pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } for (y=0; y < (long) image->rows; y++) { count=ReadBlob(image,packet_size*image->extract_info.width, pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; q=GetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; if (LocaleCompare(image_info->magick,"RGBA") == 0) (void) ExportQuantumPixels(image,&quantum_info,AlphaQuantum, pixels+offset); else (void) ExportQuantumPixels(image,&quantum_info,OpacityQuantum, pixels+offset); if (SyncImagePixels(image) == MagickFalse) break; if (image->previous == (Image *) NULL) if ((image->progress_monitor != (MagickProgressMonitor) NULL) && (QuantumTick(i,span) != MagickFalse)) { status=image->progress_monitor(LoadImageTag,i,span, image->client_data); if (status == MagickFalse) break; } i++; } width=image->extract_info.height-image->rows-image->extract_info.y; for (i=0; i < (long) width; i++) { count=ReadBlob(image,packet_size*image->extract_info.width, pixels); if (count != (ssize_t) (packet_size*image->extract_info.width)) break; } } if (image_info->interlace == PartitionInterlace) (void) CopyMagickString(image->filename,image_info->filename, MaxTextExtent); break; } } if (y < (long) image->rows) { ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile", image->filename); break; } /* Proceed to next image. */ if (image_info->number_scenes != 0) if (image->scene >= (image_info->scene+image_info->number_scenes-1)) break; if (image_info->interlace == PartitionInterlace) break; count=ReadBlob(image,packet_size*image->extract_info.width,pixels); if (count == (ssize_t) (packet_size*image->extract_info.width)) { /* Allocate next image structure. */ AllocateNextImage(image_info,image); if (GetNextImageInList(image) == (Image *) NULL) { image=DestroyImageList(image); return((Image *) NULL); } image=SyncNextImageInList(image); if (image->progress_monitor != (MagickProgressMonitor) NULL) { status=image->progress_monitor(LoadImagesTag,TellBlob(image), GetBlobSize(image),image->client_data); if (status == MagickFalse) break; } } } while ((size_t) count == (packet_size*image->extract_info.width)); pixels=(unsigned char *) RelinquishMagickMemory(pixels); CloseBlob(image); return(GetFirstImageInList(image)); }
static int render_logo_yuv(LogoPrivateData *pd, const WorkItem *W, TCFrameVideo *frame) { unsigned long vid_size = pd->vob->ex_v_width * pd->vob->ex_v_height; unsigned long img_size = pd->images->columns * pd->images->rows; uint8_t *img_pixel_Y, *img_pixel_U, *img_pixel_V; uint8_t *vid_pixel_Y, *vid_pixel_U, *vid_pixel_V; float img_coeff, vid_coeff; /* Note: GraphicsMagick defines opacity = 0 as fully visible, and * opacity = MaxRGB as fully transparent. */ Quantum opacity; int row, col; PixelPacket *pixels = GetImagePixels(pd->images, 0, 0, pd->images->columns, pd->images->rows); /* FIXME: yet another independent reimplementation of * the YUV planes pointer assignement. */ img_pixel_Y = pd->yuv[pd->cur_seq]; img_pixel_U = img_pixel_Y + img_size; img_pixel_V = img_pixel_U + img_size/4; for (row = 0; row < pd->images->rows; row++) { vid_pixel_Y = frame->video_buf + (row + pd->posy)*pd->vob->ex_v_width + pd->posx; vid_pixel_U = frame->video_buf + vid_size + (row/2 + pd->posy/2)*(pd->vob->ex_v_width/2) + pd->posx/2; vid_pixel_V = vid_pixel_U + vid_size/4; for (col = 0; col < pd->images->columns; col++) { int do_UV_pixels = (pd->grayout == 0 && !(row % 2) && !(col % 2)) ? 1 : 0; opacity = pixels->opacity; if (W->do_fade) opacity += (Quantum)((MaxRGB - opacity) * W->fade_coeff); if (opacity == 0) { *vid_pixel_Y = *img_pixel_Y; if (do_UV_pixels) { *vid_pixel_U = *img_pixel_U; *vid_pixel_V = *img_pixel_V; } } else if (opacity < MaxRGB) { unsigned char opacity_byte = ScaleQuantumToChar(opacity); img_coeff = pd->img_coeff_lookup[opacity_byte]; vid_coeff = pd->vid_coeff_lookup[opacity_byte]; *vid_pixel_Y = (uint8_t)(*vid_pixel_Y * vid_coeff) + (uint8_t)(*img_pixel_Y * img_coeff); if (do_UV_pixels) { *vid_pixel_U = (uint8_t)(*vid_pixel_U * vid_coeff) + (uint8_t)(*img_pixel_U * img_coeff); *vid_pixel_V = (uint8_t)(*vid_pixel_V * vid_coeff) + (uint8_t)(*img_pixel_V * img_coeff); } } vid_pixel_Y++; img_pixel_Y++; if (do_UV_pixels) { vid_pixel_U++; img_pixel_U++; vid_pixel_V++; img_pixel_V++; } pixels++; } } return TC_OK; }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % + Y S h e a r I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % YShearImage shears the image in the Y direction with a shear angle of % 'degrees'. Positive angles shear counter-clockwise (right-hand rule), and % negative angles shear clockwise. Angles are measured relative to a % horizontal X-axis. Y shears will increase the height of an image creating % 'empty' triangles on the top and bottom of the source image. % % The format of the YShearImage method is: % % void YShearImage(Image *image,const MagickRealType degrees, % const unsigned long width,const unsigned long height,long x_offset, % const long y_offset) % % A description of each parameter follows. % % o image: the image. % % o degrees: A MagickRealType representing the shearing angle along the Y % axis. % % o width, height, x_offset, y_offset: Defines a region of the image % to shear. % */ static void YShearImage(Image *image,const MagickRealType degrees, const unsigned long width,const unsigned long height,long x_offset, const long y_offset) { #define YShearImageTag "YShear/Image" enum {UP, DOWN} direction; IndexPacket *indexes, *shear_indexes; long step, y; MagickBooleanType status; MagickPixelPacket background, pixel, source, destination; MagickRealType area, displacement; register PixelPacket *p, *q; register long i; assert(image != (Image *) NULL); x_offset--; for (y=0; y < (long) width; y++) { x_offset++; displacement=degrees*(MagickRealType) (y-width/2.0); if (displacement == 0.0) continue; if (displacement > 0.0) direction=DOWN; else { displacement*=(-1.0); direction=UP; } step=(long) floor((double) displacement); area=(MagickRealType) (displacement-step); step++; GetMagickPixelPacket(image,&background); SetMagickPixelPacket(image,&image->background_color,(IndexPacket *) NULL, &background); if (image->colorspace == CMYKColorspace) ConvertRGBToCMYK(&background); pixel=background; GetMagickPixelPacket(image,&source); GetMagickPixelPacket(image,&destination); switch (direction) { case UP: { /* Transfer pixels top-to-bottom. */ if (step > y_offset) break; p=GetImagePixels(image,x_offset,0,1,image->rows); if (p == (PixelPacket *) NULL) break; p+=y_offset; indexes=GetIndexes(image); indexes+=y_offset; q=p-step; shear_indexes=indexes-step; for (i=0; i < (long) height; i++) { if ((y_offset+i) < step) { SetMagickPixelPacket(image,++p,++indexes,&pixel); q++; shear_indexes++; continue; } SetMagickPixelPacket(image,p,indexes,&source); MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&source, (MagickRealType) p->opacity,area,&destination); SetPixelPacket(image,&destination,q++,shear_indexes++); SetMagickPixelPacket(image,p++,indexes++,&pixel); } MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&background, (MagickRealType) background.opacity,area,&destination); SetPixelPacket(image,&destination,q++,shear_indexes++); for (i=0; i < (step-1); i++) SetPixelPacket(image,&background,q++,shear_indexes++); break; } case DOWN: { /* Transfer pixels bottom-to-top. */ p=GetImagePixels(image,x_offset,0,1,image->rows); if (p == (PixelPacket *) NULL) break; p+=y_offset+height; indexes=GetIndexes(image); indexes+=y_offset+height; q=p+step; shear_indexes=indexes+step; for (i=0; i < (long) height; i++) { p--; indexes--; q--; shear_indexes--; if ((unsigned long) (y_offset+height+step-i) >= image->rows) continue; SetMagickPixelPacket(image,p,indexes,&source); MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&source, (MagickRealType) p->opacity,area,&destination); SetPixelPacket(image,&destination,q,shear_indexes); SetMagickPixelPacket(image,p,indexes,&pixel); } MagickCompositeBlend(&pixel,(MagickRealType) pixel.opacity,&background, (MagickRealType) background.opacity,area,&destination); SetPixelPacket(image,&destination,--q,--shear_indexes); for (i=0; i < (step-1); i++) SetPixelPacket(image,&background,--q,--shear_indexes); break; } } if (SyncImagePixels(image) == MagickFalse) break; if ((image->progress_monitor != (MagickProgressMonitor) NULL) && (QuantumTick(y,width) != MagickFalse)) { status=image->progress_monitor(XShearImageTag,y,width, image->client_data); if (status == MagickFalse) break; } } }
/*---------------------------------------------------------- * int_imread: * interface for imread function. * should provide [RGB]=imread(name) * [Index,Map]=imread(name) at Scilab level * * TO-DO * - return on errors, even if exeption is NULL * * $Revision: 1.2 $ $Date: 2009-03-29 21:34:48 $ *----------------------------------------------------------*/ SipExport int int_imread(char *fname) { /* Interface variables */ HyperMat *Img; int m1, n1,l1, /* for name input argument */ m2, n2, /* for index output argument */ minlhs=1, maxlhs=2, minrhs=1, maxrhs=1, i; double *l2; /* Other variables */ unsigned long imgsize; /* ImageMagick variables */ ExceptionInfo exception; Image *image; ImageInfo *image_info; PixelPacket *pix; ImageType imgtype; bool stat; CheckRhs(minrhs,maxrhs) ; CheckLhs(minlhs,maxlhs) ; /* Get name (#1) */ GetRhsVar(1, "c", &m1, &n1, &l1); /* Initialize the image info structure and read an image. */ InitializeMagick(NULL); GetExceptionInfo(&exception); image_info=CloneImageInfo((ImageInfo *) NULL); (void) strncpy(image_info->filename,cstk(l1),MaxTextExtent); image=ReadImage(image_info,&exception); if (image == (Image *) NULL) { /* clean up */ if(exception.reason != NULL) { char errmsg[50]; for (i=0; i<49; i++) errmsg[i]=' '; errmsg[49]='\0'; strncpy(errmsg,SipGetLocaleExceptionMessage(exception.severity,exception.reason),50); DestroyImageInfo(image_info); DestroyExceptionInfo(&exception); DestroyMagick(); sip_error(errmsg); } DestroyImageInfo(image_info); DestroyExceptionInfo(&exception); DestroyMagick(); sip_error("unknown reason"); } m2 = image->rows; n2 = image->columns; if (sip_verbose == SIP_WORDY) sciprint("Size:\t%ld rows X %ld columns\n\r", m2, n2); imgsize = m2 * n2; pix=GetImagePixels(image, 0, 0, n2, m2); if(pix == (PixelPacket *) NULL) SIP_MAGICK_ERROR; switch(image->storage_class) { case DirectClass: { imgtype = GetImageType(image, &exception); if(imgtype == BilevelType) { stat = magick_binary_image_to_double_array(fname,pix,&l2, m2, n2); if (!stat) return false; CreateVarFromPtr(2, "d",&m2,&n2,&l2); free(l2); } else { stat= magick_truecolor_image_to_double_hypermat(fname,pix,&Img,m2,n2); if (!stat) return false; CreateHMat(2,Img); free_sci_tru_img(&Img); } m1 = n1 = 0; CreateVar(3,"d",&m1,&n1,&l1); break; } case PseudoClass: { stat= magick_index_map_to_sci_dbl(fname,image,2); if (!stat) return false; break; } default: sip_error("unknown color class"); break; } LhsVar(1) = 2; LhsVar(2) = 3; /* Terminate Imagemagick */ DestroyImageInfo(image_info); DestroyImage(image); DestroyExceptionInfo(&exception); DestroyMagick(); return true; }
int tc_filter(frame_list_t *ptr_, char *options) { vframe_list_t *ptr = (vframe_list_t *)ptr_; int instance = ptr->filter_id; Image *pattern, *resized, *orig = 0; ImageInfo *image_info; PixelPacket *pixel_packet; pixelsMask *pixel_last; ExceptionInfo exception_info; if(ptr->tag & TC_FILTER_GET_CONFIG) { char buf[128]; optstr_filter_desc(options, MOD_NAME, MOD_CAP, MOD_VERSION, MOD_AUTHOR, "VRYMO", "1"); tc_snprintf(buf, 128, "/dev/null"); optstr_param(options, "pattern", "Pattern image file path", "%s", buf); tc_snprintf(buf, 128, "results.dat"); optstr_param(options, "results", "Results file path" , "%s", buf); tc_snprintf(buf, 128, "%f", compare[instance]->delta); optstr_param(options, "delta", "Delta error", "%f",buf,"0.0", "100.0"); return 0; } //---------------------------------- // // filter init // //---------------------------------- if(ptr->tag & TC_FILTER_INIT) { unsigned int t,r,index; pixelsMask *temp; compare[instance] = tc_malloc(sizeof(compareData)); if(compare[instance] == NULL) return (-1); compare[instance]->vob = tc_get_vob(); if(compare[instance]->vob ==NULL) return(-1); compare[instance]->delta=DELTA_COLOR; compare[instance]->step=1; compare[instance]->width=0; compare[instance]->height=0; compare[instance]->frames = 0; compare[instance]->pixel_mask = NULL; pixel_last = NULL; compare[instance]->width = compare[instance]->vob->ex_v_width; compare[instance]->height = compare[instance]->vob->ex_v_height; if (options != NULL) { char pattern_name[PATH_MAX]; char results_name[PATH_MAX]; memset(pattern_name,0,PATH_MAX); memset(results_name,0,PATH_MAX); if(verbose) tc_log_info(MOD_NAME, "options=%s", options); optstr_get(options, "pattern", "%[^:]", pattern_name); optstr_get(options, "results", "%[^:]", results_name); optstr_get(options, "delta", "%f", &compare[instance]->delta); if (verbose > 1) { tc_log_info(MOD_NAME, "Compare Image Settings:"); tc_log_info(MOD_NAME, " pattern = %s\n", pattern_name); tc_log_info(MOD_NAME, " results = %s\n", results_name); tc_log_info(MOD_NAME, " delta = %f\n", compare[instance]->delta); } if (strlen(results_name) == 0) { // Ponemos el nombre del fichero al original con extension dat strlcpy(results_name, "/tmp/compare.dat", sizeof(results_name)); } if (!(compare[instance]->results = fopen(results_name, "w"))) { tc_log_perror(MOD_NAME, "could not open file for writing"); } InitializeMagick(""); if (verbose > 1) tc_log_info(MOD_NAME, "Magick Initialized successfully"); GetExceptionInfo(&exception_info); image_info = CloneImageInfo ((ImageInfo *) NULL); strlcpy(image_info->filename, pattern_name, MaxTextExtent); if (verbose > 1) tc_log_info(MOD_NAME, "Trying to open image"); orig = ReadImage(image_info, &exception_info); if (orig == (Image *) NULL) { MagickWarning(exception_info.severity, exception_info.reason, exception_info.description); strlcpy(pattern_name, "/dev/null", sizeof(pattern_name)); }else{ if (verbose > 1) tc_log_info(MOD_NAME, "Image loaded successfully"); } } else{ tc_log_perror(MOD_NAME, "Not image provided"); } if (options != NULL) if (optstr_lookup (options, "help")) { help_optstr(); } fprintf(compare[instance]->results,"#fps:%f\n",compare[instance]->vob->fps); if (orig != NULL){ // Flip and resize if (compare[instance]->vob->im_v_codec == CODEC_YUV) TransformRGBImage(orig,YCbCrColorspace); if (verbose > 1) tc_log_info(MOD_NAME, "Resizing the Image"); resized = ResizeImage(orig, compare[instance]->width, compare[instance]->height, GaussianFilter, 1, &exception_info); if (verbose > 1) tc_log_info(MOD_NAME, "Flipping the Image"); pattern = FlipImage(resized, &exception_info); if (pattern == (Image *) NULL) { MagickError (exception_info.severity, exception_info.reason, exception_info.description); } // Filling the matrix with the pixels values not // alpha if (verbose > 1) tc_log_info(MOD_NAME, "GetImagePixels"); pixel_packet = GetImagePixels(pattern,0,0, pattern->columns, pattern->rows); if (verbose > 1) tc_log_info(MOD_NAME, "Filling the Image matrix"); for (t = 0; t < pattern->rows; t++) for (r = 0; r < pattern->columns; r++){ index = t*pattern->columns + r; if (pixel_packet[index].opacity == 0){ temp=tc_malloc(sizeof(struct pixelsMask)); temp->row=t; temp->col=r; temp->r = (uint8_t)ScaleQuantumToChar(pixel_packet[index].red); temp->g = (uint8_t)ScaleQuantumToChar(pixel_packet[index].green); temp->b = (uint8_t)ScaleQuantumToChar(pixel_packet[index].blue); temp->next=NULL; if (pixel_last == NULL){ pixel_last = temp; compare[instance]->pixel_mask = temp; }else{ pixel_last->next = temp; pixel_last = temp; } } } if (verbose) tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP); } return(0); } //---------------------------------- // // filter close // //---------------------------------- if(ptr->tag & TC_FILTER_CLOSE) { if (compare[instance] != NULL) { fclose(compare[instance]->results); free(compare[instance]); } DestroyMagick(); compare[instance]=NULL; return(0); } /* filter close */ //---------------------------------- // // filter frame routine // //---------------------------------- // tag variable indicates, if we are called before // transcodes internal video/audio frame processing routines // or after and determines video/audio context if((ptr->tag & TC_POST_M_PROCESS) && (ptr->tag & TC_VIDEO)) { // For now I only support RGB color space pixelsMask *item = NULL; double sr,sg,sb; double avg_dr,avg_dg,avg_db; if (compare[instance]->vob->im_v_codec == CODEC_RGB){ int r,g,b,c; double width_long; if (compare[instance]->pixel_mask != NULL) { item = compare[instance]->pixel_mask; c = 0; sr = 0.0; sg = 0.0; sb = 0.0; width_long = compare[instance]->width*3; while(item){ r = item->row*width_long + item->col*3; g = item->row*width_long + item->col*3 + 1; b = item->row*width_long + item->col*3 + 2; // diff between points // Interchange RGB values if necesary sr = sr + (double)abs((unsigned char)ptr->video_buf[r] - item->r); sg = sg + (double)abs((unsigned char)ptr->video_buf[g] - item->g); sb = sb + (double)abs((unsigned char)ptr->video_buf[b] - item->b); item = item->next; c++; } avg_dr = sr/(double)c; avg_dg = sg/(double)c; avg_db = sb/(double)c; if ((avg_dr < compare[instance]->delta) && (avg_dg < compare[instance]->delta) && (avg_db < compare[instance]->delta)) fprintf(compare[instance]->results,"1"); else fprintf(compare[instance]->results,"n"); fflush(compare[instance]->results); } compare[instance]->frames++; return(0); }else{ // The colospace is YUV // FIXME: Doesn't works, I need to code all this part // again int Y,Cr,Cb,c; if (compare[instance]->pixel_mask != NULL) { item = compare[instance]->pixel_mask; c = 0; sr = 0.0; sg = 0.0; sb = 0.0; while(item){ Y = item->row*compare[instance]->width + item->col; Cb = compare[instance]->height*compare[instance]->width + (int)((item->row*compare[instance]->width + item->col)/4); Cr = compare[instance]->height*compare[instance]->width + (int)((compare[instance]->height*compare[instance]->width)/4) + (int)((item->row*compare[instance]->width + item->col)/4); // diff between points // Interchange RGB values if necesary sr = sr + (double)abs((unsigned char)ptr->video_buf[Y] - item->r); sg = sg + (double)abs((unsigned char)ptr->video_buf[Cb] - item->g); sb = sb + (double)abs((unsigned char)ptr->video_buf[Cr] - item->b); item = item->next; c++; } avg_dr = sr/(double)c; avg_dg = sg/(double)c; avg_db = sb/(double)c; if ((avg_dr < compare[instance]->delta) && (avg_dg < compare[instance]->delta) && (avg_db < compare[instance]->delta)) fprintf(compare[instance]->results,"1"); else fprintf(compare[instance]->results,"n"); } compare[instance]->frames++; return(0); } } return(0); }
static Image *ReadJP2Image(const ImageInfo *image_info, ExceptionInfo *exception) { Image *image; long y; jas_image_t *jp2_image; jas_matrix_t *pixels; jas_stream_t *jp2_stream; register long x; register PixelPacket *q; int component, components[4], number_components; Quantum *channel_lut[4]; unsigned int status; /* Open image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); image=AllocateImage(image_info); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == False) ThrowReaderException(FileOpenError,UnableToOpenFile,image); /* Obtain a JP2 Stream. */ jp2_stream=JP2StreamManager(image); if (jp2_stream == (jas_stream_t *) NULL) ThrowReaderException(DelegateError,UnableToManageJP2Stream,image); jp2_image=jas_image_decode(jp2_stream,-1,0); if (jp2_image == (jas_image_t *) NULL) { (void) jas_stream_close(jp2_stream); ThrowReaderException(DelegateError,UnableToDecodeImageFile,image); } /* Validate that we can handle the image and obtain component indexes. */ switch (jas_clrspc_fam(jas_image_clrspc(jp2_image))) { case JAS_CLRSPC_FAM_RGB: { if (((components[0]= jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R))) < 0) || ((components[1]= jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G))) < 0) || ((components[2]= jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B))) < 0)) { (void) jas_stream_close(jp2_stream); jas_image_destroy(jp2_image); ThrowReaderException(CorruptImageError,MissingImageChannel,image); } number_components=3; (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Image is in RGB colorspace family"); (void) LogMagickEvent(CoderEvent,GetMagickModule(), "RED is in channel %d, GREEN is in channel %d, BLUE is in channel %d", components[0],components[1],components[2]); if((components[3]=jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_OPACITY))) > 0) { image->matte=MagickTrue; (void) LogMagickEvent(CoderEvent,GetMagickModule(), "OPACITY is in channel %d",components[3]); number_components++; } break; } case JAS_CLRSPC_FAM_GRAY: { if ((components[0]= jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y))) < 0) { (void) jas_stream_close(jp2_stream); jas_image_destroy(jp2_image); ThrowReaderException(CorruptImageError,MissingImageChannel,image); } (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Image is in GRAY colorspace family"); (void) LogMagickEvent(CoderEvent,GetMagickModule(), "GRAY is in channel %d",components[0]); number_components=1; break; } case JAS_CLRSPC_FAM_YCBCR: { components[0]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_Y); components[1]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_CB); components[2]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_CR); if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0)) { (void) jas_stream_close(jp2_stream); jas_image_destroy(jp2_image); ThrowReaderException(CorruptImageError,MissingImageChannel,image); } number_components=3; components[3]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_OPACITY); if (components[3] > 0) { image->matte=True; number_components++; } image->colorspace=YCbCrColorspace; (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Image is in YCBCR colorspace family"); break; } default: { (void) jas_stream_close(jp2_stream); jas_image_destroy(jp2_image); ThrowReaderException(CoderError,ColorspaceModelIsNotSupported,image); } } image->columns=jas_image_width(jp2_image); image->rows=jas_image_height(jp2_image); (void) LogMagickEvent(CoderEvent,GetMagickModule(), "columns=%lu rows=%lu components=%d",image->columns,image->rows, number_components); for (component=0; component < number_components; component++) { if(((unsigned long) jas_image_cmptwidth(jp2_image,components[component]) != image->columns) || ((unsigned long) jas_image_cmptheight(jp2_image,components[component]) != image->rows) || (jas_image_cmpttlx(jp2_image, components[component]) != 0) || (jas_image_cmpttly(jp2_image, components[component]) != 0) || (jas_image_cmpthstep(jp2_image, components[component]) != 1) || (jas_image_cmptvstep(jp2_image, components[component]) != 1) || (jas_image_cmptsgnd(jp2_image, components[component]) != false)) { (void) jas_stream_close(jp2_stream); jas_image_destroy(jp2_image); ThrowReaderException(CoderError,IrregularChannelGeometryNotSupported,image); } } image->matte=number_components > 3; for (component=0; component < number_components; component++) { unsigned int component_depth; component_depth=jas_image_cmptprec(jp2_image,components[component]); (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Component[%d] depth is %u",component,component_depth); if (0 == component) image->depth=component_depth; else image->depth=Max(image->depth,component_depth); } (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Image depth is %u",image->depth); if (image_info->ping) { (void) jas_stream_close(jp2_stream); jas_image_destroy(jp2_image); return(image); } /* Allocate Jasper pixels. */ pixels=jas_matrix_create(1,(unsigned int) image->columns); if (pixels == (jas_matrix_t *) NULL) { jas_image_destroy(jp2_image); ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image); } /* Allocate and populate channel LUTs */ for (component=0; component < (long) number_components; component++) { unsigned long component_depth, i, max_value; double scale_to_quantum; component_depth=jas_image_cmptprec(jp2_image,components[component]); max_value=MaxValueGivenBits(component_depth); scale_to_quantum=MaxRGBDouble/max_value; (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Channel %d scale is %g", component, scale_to_quantum); channel_lut[component]=MagickAllocateArray(Quantum *,max_value+1,sizeof(Quantum)); if (channel_lut[component] == (Quantum *) NULL) { for ( --component; component >= 0; --component) MagickFreeMemory(channel_lut[component]); jas_matrix_destroy(pixels); jas_image_destroy(jp2_image); ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image); } for(i=0; i <= max_value; i++) (channel_lut[component])[i]=scale_to_quantum*i+0.5; } /* Convert JPEG 2000 pixels. */ for (y=0; y < (long) image->rows; y++) { q=GetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; if (1 == number_components) { /* Grayscale */ (void) jas_image_readcmpt(jp2_image,(short) components[0],0, (unsigned int) y, (unsigned int) image->columns,1,pixels); for (x=0; x < (long) image->columns; x++) { q->red=q->green=q->blue=(channel_lut[0])[jas_matrix_getv(pixels,x)]; q->opacity=OpaqueOpacity; q++; } } else { /* Red */ (void) jas_image_readcmpt(jp2_image,(short) components[0],0, (unsigned int) y, (unsigned int) image->columns,1,pixels); for (x=0; x < (long) image->columns; x++) q[x].red=(channel_lut[0])[jas_matrix_getv(pixels,x)]; /* Green */ (void) jas_image_readcmpt(jp2_image,(short) components[1],0, (unsigned int) y, (unsigned int) image->columns,1,pixels); for (x=0; x < (long) image->columns; x++) q[x].green=(channel_lut[1])[jas_matrix_getv(pixels,x)]; /* Blue */ (void) jas_image_readcmpt(jp2_image,(short) components[2],0, (unsigned int) y, (unsigned int) image->columns,1,pixels); for (x=0; x < (long) image->columns; x++) q[x].blue=(channel_lut[2])[jas_matrix_getv(pixels,x)]; /* Opacity */ if (number_components > 3) { (void) jas_image_readcmpt(jp2_image,(short) components[3],0, (unsigned int) y, (unsigned int) image->columns,1,pixels); for (x=0; x < (long) image->columns; x++) q[x].opacity=MaxRGB-(channel_lut[3])[jas_matrix_getv(pixels,x)]; } else { for (x=0; x < (long) image->columns; x++) q[x].opacity=OpaqueOpacity; } } if (!SyncImagePixels(image)) break; if (image->previous == (Image *) NULL) if (QuantumTick(y,image->rows)) if (!MagickMonitorFormatted(y,image->rows,exception,LoadImageText, image->filename, image->columns,image->rows)) break; } if (number_components == 1) image->is_grayscale=MagickTrue; { /* Obtain ICC ICM color profile */ jas_cmprof_t *cm_profile; /* Obtain a pointer to the existing jas_cmprof_t profile handle. */ cm_profile=jas_image_cmprof(jp2_image); if (cm_profile != (jas_cmprof_t *) NULL) { jas_iccprof_t *icc_profile; /* Obtain a copy of the jas_iccprof_t ICC profile handle */ icc_profile=jas_iccprof_createfromcmprof(cm_profile); /* or maybe just icc_profile=cm_profile->iccprof */ if (icc_profile != (jas_iccprof_t *) NULL) { jas_stream_t *icc_stream; icc_stream=jas_stream_memopen(NULL,0); if ((icc_stream != (jas_stream_t *) NULL) && (jas_iccprof_save(icc_profile,icc_stream) == 0) && (jas_stream_flush(icc_stream) == 0)) { jas_stream_memobj_t *blob; blob=(jas_stream_memobj_t *) icc_stream->obj_; if (image->logging) (void) LogMagickEvent(CoderEvent,GetMagickModule(), "ICC profile: %lu bytes",(unsigned long) blob->len_); SetImageProfile(image,"ICM",blob->buf_,blob->len_); (void) jas_stream_close(icc_stream); jas_iccprof_destroy(icc_profile); } } } } for (component=0; component < (long) number_components; component++) MagickFreeMemory(channel_lut[component]); jas_matrix_destroy(pixels); (void) jas_stream_close(jp2_stream); jas_image_destroy(jp2_image); return(image); }
void draw_tiger_map (Widget w, char *filenm, int destination_pixmap, int nocache) { // For future implementation of a "refresh cached map" option char file[MAX_FILENAME]; // Complete path/name of image file char short_filenm[MAX_FILENAME]; FILE *f; // Filehandle of image file char fileimg[MAX_FILENAME]; // Ascii name of image file, read from GEO file char tigertmp[MAX_FILENAME*2]; // Used for putting together the tigermap query int width, height; tiepoint tp[2]; // Calibration points for map, read in from .geo file register long map_c_T, map_c_L; // map delta NW edge coordinates, DNN: these should be signed register long tp_c_dx, tp_c_dy; // tiepoint coordinate differences unsigned long c_x_min, c_y_min;// top left coordinates of map inside screen unsigned long c_y_max; // bottom right coordinates of map inside screen double c_x; // Xastir coordinates 1/100 sec, 0 = 180°W double c_y; // Xastir coordinates 1/100 sec, 0 = 90°N long map_y_0; // map pixel pointer prior to TM adjustment register long map_x, map_y; // map pixel pointers, DNN: this was a float, chg to long long map_x_min, map_x_max; // map boundaries for in screen part of map long map_y_min, map_y_max; // long map_x_ctr; // half map width in pixel long map_y_ctr; // half map height in pixel int map_seen = 0; int map_act; int map_done; long map_c_yc; // map center, vert coordinate long map_c_xc; // map center, hor coordinate double map_c_dx, map_c_dy; // map coordinates increment (pixel width) double c_dx; // adjusted map pixel width long scr_x, scr_y; // screen pixel plot positions long scr_xp, scr_yp; // previous screen plot positions int scr_dx, scr_dy; // increments in screen plot positions long scr_x_mc; // map center in screen units long scr_c_xr; long scale_xa; // adjusted for topo maps double scale_x_nm; // nm per Xastir coordinate unit long scale_x0; // at widest map area char local_filename[MAX_FILENAME]; ExceptionInfo exception; Image *image; ImageInfo *image_info; PixelPacket *pixel_pack; PixelPacket temp_pack; IndexPacket *index_pack; int l; XColor my_colors[256]; double left, right, top, bottom, map_width, map_height; double lat_center = 0; double long_center = 0; char map_it[MAX_FILENAME]; char tmpstr[100]; int geo_image_width; // Image width from GEO file int geo_image_height; // Image height from GEO file // initialize this local_filename[0]='\0'; // Create a shorter filename for display (one that fits the // status line more closely). Subtract the length of the // "Indexing " and/or "Loading " strings as well. if (strlen(filenm) > (41 - 9)) { int avail = 41 - 11; int new_len = strlen(filenm) - avail; xastir_snprintf(short_filenm, sizeof(short_filenm), "..%s", &filenm[new_len]); } else { xastir_snprintf(short_filenm, sizeof(short_filenm), "%s", filenm); } xastir_snprintf(map_it, sizeof(map_it), langcode ("BBARSTA028"), short_filenm); statusline(map_it,0); // Loading ... // Check whether we're indexing or drawing the map if ( (destination_pixmap == INDEX_CHECK_TIMESTAMPS) || (destination_pixmap == INDEX_NO_TIMESTAMPS) ) { // We're indexing only. Save the extents in the index. // Force the extents to the edges of the earth for the // index file. index_update_xastir(filenm, // Filename only 64800000l, // Bottom 0l, // Top 0l, // Left 129600000l, // Right 0); // Default Map Level // Update statusline xastir_snprintf(map_it, sizeof(map_it), langcode ("BBARSTA039"), short_filenm); statusline(map_it,0); // Loading/Indexing ... return; // Done indexing this file } // Tiepoint for upper left screen corner // tp[0].img_x = 0; // Pixel Coordinates tp[0].img_y = 0; // Pixel Coordinates tp[0].x_long = NW_corner_longitude; // Xastir Coordinates tp[0].y_lat = NW_corner_latitude; // Xastir Coordinates // Tiepoint for lower right screen corner // tp[1].img_x = screen_width - 1; // Pixel Coordinates tp[1].img_y = screen_height - 1; // Pixel Coordinates tp[1].x_long = SE_corner_longitude; // Xastir Coordinates tp[1].y_lat = SE_corner_latitude; // Xastir Coordinates left = (double)((NW_corner_longitude - 64800000l )/360000.0); // Lat/long Coordinates top = (double)(-((NW_corner_latitude - 32400000l )/360000.0)); // Lat/long Coordinates right = (double)((SE_corner_longitude - 64800000l)/360000.0);//Lat/long Coordinates bottom = (double)(-((SE_corner_latitude - 32400000l)/360000.0));//Lat/long Coordinates map_width = right - left; // Lat/long Coordinates map_height = top - bottom; // Lat/long Coordinates geo_image_width = screen_width; geo_image_height = screen_height; long_center = (left + right)/2.0l; lat_center = (top + bottom)/2.0l; // Example query to the census map server.... /* xastir_snprintf(fileimg, sizeof(fileimg), "\'http://tiger.census.gov/cgi-bin/mapper/map.gif?on=CITIES&on=GRID&on=counties&on=majroads&on=places&&on=interstate&on=states&on=ushwy&on=statehwy&lat=%f\046lon=%f\046wid=%f\046ht=%f\046iwd=%i\046iht=%i\'",\ lat_center, long_center, map_width, map_height, tp[1].img_x + 1, tp[1].img_y + 1); */ xastir_snprintf(tigertmp, sizeof(tigertmp), "http://tiger.census.gov/cgi-bin/mapper/map.gif?"); if (tiger_show_grid) strncat(tigertmp, "&on=GRID", sizeof(tigertmp) - 1 - strlen(tigertmp)); else strncat(tigertmp, "&off=GRID", sizeof(tigertmp) - 1 - strlen(tigertmp)); if (tiger_show_counties) strncat(tigertmp, "&on=counties", sizeof(tigertmp) - 1 - strlen(tigertmp)); else strncat(tigertmp, "&off=counties", sizeof(tigertmp) - 1 - strlen(tigertmp)); if (tiger_show_cities) strncat(tigertmp, "&on=CITIES", sizeof(tigertmp) - 1 - strlen(tigertmp)); else strncat(tigertmp, "&off=CITIES", sizeof(tigertmp) - 1 - strlen(tigertmp)); if (tiger_show_places) strncat(tigertmp, "&on=places", sizeof(tigertmp) - 1 - strlen(tigertmp)); else strncat(tigertmp, "&off=places", sizeof(tigertmp) - 1 - strlen(tigertmp)); if (tiger_show_majroads) strncat(tigertmp, "&on=majroads", sizeof(tigertmp) - 1 - strlen(tigertmp)); else strncat(tigertmp, "&off=majroads", sizeof(tigertmp) - 1 - strlen(tigertmp)); if (tiger_show_streets) strncat(tigertmp, "&on=streets", sizeof(tigertmp) - 1 - strlen(tigertmp)); // Don't turn streets off since this will automagically show up as you zoom in. if (tiger_show_railroad) strncat(tigertmp, "&on=railroad", sizeof(tigertmp) - 1 - strlen(tigertmp)); else strncat(tigertmp, "&off=railroad", sizeof(tigertmp) - 1 - strlen(tigertmp)); if (tiger_show_states) strncat(tigertmp, "&on=states", sizeof(tigertmp) - 1 - strlen(tigertmp)); else strncat(tigertmp, "&off=states", sizeof(tigertmp) - 1 - strlen(tigertmp)); if (tiger_show_interstate) strncat(tigertmp, "&on=interstate", sizeof(tigertmp) - 1 - strlen(tigertmp)); else strncat(tigertmp, "&off=interstate", sizeof(tigertmp) - 1 - strlen(tigertmp)); if (tiger_show_ushwy) strncat(tigertmp, "&on=ushwy", sizeof(tigertmp) - 1 - strlen(tigertmp)); else strncat(tigertmp, "&off=ushwy", sizeof(tigertmp) - 1 - strlen(tigertmp)); if (tiger_show_statehwy) strncat(tigertmp, "&on=statehwy", sizeof(tigertmp) - 1 - strlen(tigertmp)); else strncat(tigertmp, "&off=statehwy", sizeof(tigertmp) - 1 - strlen(tigertmp)); if (tiger_show_water) strncat(tigertmp, "&on=water", sizeof(tigertmp) - 1 - strlen(tigertmp)); else strncat(tigertmp, "&off=water", sizeof(tigertmp) - 1 - strlen(tigertmp)); if (tiger_show_lakes) strncat(tigertmp, "&on=shorelin", sizeof(tigertmp) - 1 - strlen(tigertmp)); else strncat(tigertmp, "&off=shorelin", sizeof(tigertmp) - 1 - strlen(tigertmp)); if (tiger_show_misc) strncat(tigertmp, "&on=miscell", sizeof(tigertmp) - 1 - strlen(tigertmp)); else strncat(tigertmp, "&off=miscell", sizeof(tigertmp) - 1 - strlen(tigertmp)); xastir_snprintf(tmpstr, sizeof(tmpstr), "&lat=%f\046lon=%f\046", lat_center, long_center); strncat (tigertmp, tmpstr, sizeof(tigertmp) - 1 - strlen(tigertmp)); xastir_snprintf(tmpstr, sizeof(tmpstr), "wid=%f\046ht=%f\046", map_width, map_height); strncat (tigertmp, tmpstr, sizeof(tigertmp) - 1 - strlen(tigertmp)); xastir_snprintf(tmpstr, sizeof(tmpstr), "iwd=%i\046iht=%i", tp[1].img_x + 1, tp[1].img_y + 1); strncat (tigertmp, tmpstr, sizeof(tigertmp) - 1 - strlen(tigertmp)); xastir_snprintf(fileimg, sizeof(fileimg), "%s", tigertmp); if (debug_level & 512) { fprintf(stderr,"left side is %f\n", left); fprintf(stderr,"right side is %f\n", right); fprintf(stderr,"top is %f\n", top); fprintf(stderr,"bottom is %f\n", bottom); fprintf(stderr,"lat center is %f\n", lat_center); fprintf(stderr,"long center is %f\n", long_center); fprintf(stderr,"screen width is %li\n", screen_width); fprintf(stderr,"screen height is %li\n", screen_height); fprintf(stderr,"map width is %f\n", map_width); fprintf(stderr,"map height is %f\n", map_height); fprintf(stderr,"fileimg is %s\n", fileimg); fprintf(stderr,"ftp or http file: %s\n", fileimg); } // Hopefully this will eventually allow us to get maps in the background // while (sometimeout !=0 && local_filename[0]==NULL){ if (local_filename[0]=='\0' ){ if (debug_level & 512 ) { fprintf(stderr,"tiger_local_file=<%s>\n",local_filename); } HandlePendingEvents(app_context); if (interrupt_drawing_now) { // Update to screen (void)XCopyArea(XtDisplay(da), pixmap, XtWindow(da), gc, 0, 0, (unsigned int)screen_width, (unsigned int)screen_height, 0, 0); return; } get_tiger_local_file(local_filename,fileimg); } // whackadoodle // Tell ImageMagick where to find it xastir_snprintf(file, sizeof(file), "%s", local_filename); GetExceptionInfo(&exception); image_info=CloneImageInfo((ImageInfo *) NULL); xastir_snprintf(image_info->filename, sizeof(image_info->filename), "%s", file); if (debug_level & 512) { fprintf(stderr,"Copied %s into image info.\n", file); fprintf(stderr,"image_info got: %s\n", image_info->filename); fprintf(stderr,"Entered ImageMagick code.\n"); fprintf(stderr,"Attempting to open: %s\n", image_info->filename); } // We do a test read first to see if the file exists, so we // don't kill Xastir in the ReadImage routine. f = fopen (image_info->filename, "r"); if (f == NULL) { if (debug_level & 512) fprintf(stderr,"File could not be read\n"); #ifdef USE_MAP_CACHE // clear from cache if bad if (map_cache_del(fileimg)) { if (debug_level & 512) { fprintf(stderr,"Couldn't delete unreadable map from cache\n"); } } #endif if (image_info) DestroyImageInfo(image_info); DestroyExceptionInfo(&exception); return; } (void)fclose (f); image = ReadImage(image_info, &exception); if (image == (Image *) NULL) { MagickWarning(exception.severity, exception.reason, exception.description); //fprintf(stderr,"MagickWarning\n"); #ifdef USE_MAP_CACHE // clear from cache if bad if (map_cache_del(fileimg)) { if (debug_level & 512) { fprintf(stderr,"Couldn't delete map from cache\n"); } } #endif if (image_info) DestroyImageInfo(image_info); DestroyExceptionInfo(&exception); return; } if (debug_level & 512) fprintf(stderr,"Color depth is %i \n", (int)image->depth); if (image->colorspace != RGBColorspace) { fprintf(stderr,"TBD: I don't think we can deal with colorspace != RGB"); if (image) DestroyImage(image); if (image_info) DestroyImageInfo(image_info); DestroyExceptionInfo(&exception); return; } width = image->columns; height = image->rows; // Code to mute the image so it's not as bright. /* if (raster_map_intensity < 1.0) { char tempstr[30]; if (debug_level & 512) fprintf(stderr,"level=%s\n", tempstr); xastir_snprintf(tempstr, sizeof(tempstr), "%d, 100, 100", (int)(raster_map_intensity * 100.0)); ModulateImage(image, tempstr); } */ // If were are drawing to a low bpp display (typically < 8bpp) // try to reduce the number of colors in an image. // This may take some time, so it would be best to do ahead of // time if it is a static image. #if (MagickLibVersion < 0x0540) if (visual_type == NOT_TRUE_NOR_DIRECT && GetNumberColors(image, NULL) > 128) { #else // MagickLib >= 540 if (visual_type == NOT_TRUE_NOR_DIRECT && GetNumberColors(image, NULL, &exception) > 128) { #endif // MagickLib Version if (image->storage_class == PseudoClass) { #if (MagickLibVersion < 0x0549) CompressColormap(image); // Remove duplicate colors #else // MagickLib >= 0x0549 CompressImageColormap(image); // Remove duplicate colors #endif // MagickLibVersion < 0x0549 } // Quantize down to 128 will go here... } pixel_pack = GetImagePixels(image, 0, 0, image->columns, image->rows); if (!pixel_pack) { fprintf(stderr,"pixel_pack == NULL!!!"); if (image) DestroyImage(image); if (image_info) DestroyImageInfo(image_info); DestroyExceptionInfo(&exception); return; } index_pack = GetIndexes(image); if (image->storage_class == PseudoClass && !index_pack) { fprintf(stderr,"PseudoClass && index_pack == NULL!!!"); if (image) DestroyImage(image); if (image_info) DestroyImageInfo(image_info); DestroyExceptionInfo(&exception); return; } if (image->storage_class == PseudoClass && image->colors <= 256) { for (l = 0; l < (int)image->colors; l++) { // Need to check how to do this for ANY image, as ImageMagick can read in all sorts // of image files temp_pack = image->colormap[l]; if (debug_level & 512) fprintf(stderr,"Colormap color is %i %i %i \n", temp_pack.red, temp_pack.green, temp_pack.blue); // Here's a tricky bit: PixelPacket entries are defined as Quantum's. Quantum // is defined in /usr/include/magick/image.h as either an unsigned short or an // unsigned char, depending on what "configure" decided when ImageMagick was installed. // We can determine which by looking at MaxRGB or QuantumDepth. // if (QuantumDepth == 16) { // Defined in /usr/include/magick/image.h if (debug_level & 512) fprintf(stderr,"Color quantum is [0..65535]\n"); my_colors[l].red = temp_pack.red * raster_map_intensity; my_colors[l].green = temp_pack.green * raster_map_intensity; my_colors[l].blue = temp_pack.blue * raster_map_intensity; } else { // QuantumDepth = 8 if (debug_level & 512) fprintf(stderr,"Color quantum is [0..255]\n"); my_colors[l].red = (temp_pack.red << 8) * raster_map_intensity; my_colors[l].green = (temp_pack.green << 8) * raster_map_intensity; my_colors[l].blue = (temp_pack.blue << 8) * raster_map_intensity; } // Get the color allocated on < 8bpp displays. pixel color is written to my_colors.pixel if (visual_type == NOT_TRUE_NOR_DIRECT) { // XFreeColors(XtDisplay(w), cmap, &(my_colors[l].pixel),1,0); XAllocColor(XtDisplay(w), cmap, &my_colors[l]); } else { pack_pixel_bits(my_colors[l].red, my_colors[l].green, my_colors[l].blue, &my_colors[l].pixel); } if (debug_level & 512) fprintf(stderr,"Color allocated is %li %i %i %i \n", my_colors[l].pixel, my_colors[l].red, my_colors[l].blue, my_colors[l].green); } } /* * Here are the corners of our viewport, using the Xastir * coordinate system. Notice that Y is upside down: * * left edge of view = NW_corner_longitude * right edge of view = SE_corner_longitude * top edge of view = NW_corner_latitude * bottom edge of view = SE_corner_latitude * * The corners of our map will soon be (after translating the * tiepoints to the corners if they're not already there): * * left edge of map = tp[0].x_long in Xastir format * right edge of map = tp[1].x_long * top edge of map = tp[0].y_lat * bottom edge of map = tp[1].y_lat * */ map_c_L = tp[0].x_long - NW_corner_longitude; // map left coordinate map_c_T = tp[0].y_lat - NW_corner_latitude; // map top coordinate tp_c_dx = (long)(tp[1].x_long - tp[0].x_long);// Width between tiepoints tp_c_dy = (long)(tp[1].y_lat - tp[0].y_lat); // Height between tiepoints // Check for tiepoints being in wrong relation to one another if (tp_c_dx < 0) tp_c_dx = -tp_c_dx; // New width between tiepoints if (tp_c_dy < 0) tp_c_dy = -tp_c_dy; // New height between tiepoints // Calculate step size per pixel map_c_dx = ((double) tp_c_dx / abs(tp[1].img_x - tp[0].img_x)); map_c_dy = ((double) tp_c_dy / abs(tp[1].img_y - tp[0].img_y)); // Scaled screen step size for use with XFillRectangle below scr_dx = (int) (map_c_dx / scale_x) + 1; scr_dy = (int) (map_c_dy / scale_y) + 1; // calculate top left map corner from tiepoints if (tp[0].img_x != 0) { tp[0].x_long -= (tp[0].img_x * map_c_dx); // map left edge longitude map_c_L = tp[0].x_long - NW_corner_longitude; // delta ?? tp[0].img_x = 0; if (debug_level & 512) fprintf(stderr,"Translated tiepoint_0 x: %d\t%lu\n", tp[0].img_x, tp[0].x_long); } if (tp[0].img_y != 0) { tp[0].y_lat -= (tp[0].img_y * map_c_dy); // map top edge latitude map_c_T = tp[0].y_lat - NW_corner_latitude; tp[0].img_y = 0; if (debug_level & 512) fprintf(stderr,"Translated tiepoint_0 y: %d\t%lu\n", tp[0].img_y, tp[0].y_lat); } // calculate bottom right map corner from tiepoints // map size is geo_image_width / geo_image_height if (tp[1].img_x != (geo_image_width - 1) ) { tp[1].img_x = geo_image_width - 1; tp[1].x_long = tp[0].x_long + (tp[1].img_x * map_c_dx); // right if (debug_level & 512) fprintf(stderr,"Translated tiepoint_1 x: %d\t%lu\n", tp[1].img_x, tp[1].x_long); } if (tp[1].img_y != (geo_image_height - 1) ) { tp[1].img_y = geo_image_height - 1; tp[1].y_lat = tp[0].y_lat + (tp[1].img_y * map_c_dy); // bottom if (debug_level & 512) fprintf(stderr,"Translated tiepoint_1 y: %d\t%lu\n", tp[1].img_y, tp[1].y_lat); } if (debug_level & 512) { fprintf(stderr,"X tiepoint width: %ld\n", tp_c_dx); fprintf(stderr,"Y tiepoint width: %ld\n", tp_c_dy); fprintf(stderr,"Loading imagemap: %s\n", file); fprintf(stderr,"\nImage: %s\n", file); fprintf(stderr,"Image size %d %d\n", geo_image_width, geo_image_height); fprintf(stderr,"XX: %ld YY:%ld Sx %f %d Sy %f %d\n", map_c_L, map_c_T, map_c_dx,(int) (map_c_dx / scale_x), map_c_dy, (int) (map_c_dy / scale_y)); fprintf(stderr,"Image size %d %d\n", width, height); #if (MagickLibVersion < 0x0540) fprintf(stderr,"Unique colors = %d\n", GetNumberColors(image, NULL)); #else // MagickLib < 540 fprintf(stderr,"Unique colors = %ld\n", GetNumberColors(image, NULL, &exception)); #endif // MagickLib < 540 fprintf(stderr,"XX: %ld YY:%ld Sx %f %d Sy %f %d\n", map_c_L, map_c_T, map_c_dx,(int) (map_c_dx / scale_x), map_c_dy, (int) (map_c_dy / scale_y)); fprintf(stderr,"image matte is %i\n", image->matte); } // debug_level & 512 // draw the image from the file out to the map screen // Get the border values for the X and Y for loops used // for the XFillRectangle call later. map_c_yc = (tp[0].y_lat + tp[1].y_lat) / 2; // vert center of map as reference map_y_ctr = (long)(height / 2 +0.499); scale_x0 = get_x_scale(0,map_c_yc,scale_y); // reference scaling at vert map center map_c_xc = (tp[0].x_long + tp[1].x_long) / 2; // hor center of map as reference map_x_ctr = (long)(width / 2 +0.499); scr_x_mc = (map_c_xc - NW_corner_longitude) / scale_x; // screen coordinates of map center // calculate map pixel range in y direction that falls into screen area c_y_max = 0ul; map_y_min = map_y_max = 0l; for (map_y_0 = 0, c_y = tp[0].y_lat; map_y_0 < (long)height; map_y_0++, c_y += map_c_dy) { scr_y = (c_y - NW_corner_latitude) / scale_y; // current screen position if (scr_y > 0) { if (scr_y < screen_height) { map_y_max = map_y_0; // update last map pixel in y c_y_max = (unsigned long)c_y;// bottom map inside screen coordinate } else break; // done, reached bottom screen border } else { // pixel is above screen map_y_min = map_y_0; // update first map pixel in y } } c_y_min = (unsigned long)(tp[0].y_lat + map_y_min * map_c_dy); // top map inside screen coordinate map_x_min = map_x_max = 0l; for (map_x = 0, c_x = tp[0].x_long; map_x < (long)width; map_x++, c_x += map_c_dx) { scr_x = (c_x - NW_corner_longitude)/ scale_x; // current screen position if (scr_x > 0) { if (scr_x < screen_width) map_x_max = map_x; // update last map pixel in x else break; // done, reached right screen border } else { // pixel is left from screen map_x_min = map_x; // update first map pixel in x } } c_x_min = (unsigned long)(tp[0].x_long + map_x_min * map_c_dx); // left map inside screen coordinate scr_yp = -1; scr_c_xr = SE_corner_longitude; c_dx = map_c_dx; // map pixel width scale_xa = scale_x0; // the compiler likes it ;-) map_done = 0; map_act = 0; map_seen = 0; scr_y = screen_height - 1; // loop over map pixel rows for (map_y_0 = map_y_min, c_y = (double)c_y_min; (map_y_0 <= map_y_max); map_y_0++, c_y += map_c_dy) { HandlePendingEvents(app_context); if (interrupt_drawing_now) { if (image) DestroyImage(image); if (image_info) DestroyImageInfo(image_info); // Update to screen (void)XCopyArea(XtDisplay(da), pixmap, XtWindow(da), gc, 0, 0, (unsigned int)screen_width, (unsigned int)screen_height, 0, 0); DestroyExceptionInfo(&exception); return; } scr_y = (c_y - NW_corner_latitude) / scale_y; if (scr_y != scr_yp) { // don't do a row twice scr_yp = scr_y; // remember as previous y scr_xp = -1; // loop over map pixel columns map_act = 0; scale_x_nm = calc_dscale_x(0,(long)c_y) / 1852.0; // nm per Xastir coordinate for (map_x = map_x_min, c_x = (double)c_x_min; map_x <= map_x_max; map_x++, c_x += c_dx) { scr_x = (c_x - NW_corner_longitude) / scale_x; if (scr_x != scr_xp) { // don't do a pixel twice scr_xp = scr_x; // remember as previous x map_y = map_y_0; if (map_y >= 0 && map_y <= tp[1].img_y) { // check map boundaries in y direction map_seen = 1; map_act = 1; // detects blank screen rows (end of map) // now copy a pixel from the map image to the screen l = map_x + map_y * image->columns; if (image->storage_class == PseudoClass) { XSetForeground(XtDisplay(w), gc, my_colors[index_pack[l]].pixel); } else { // It is not safe to assume that the red/green/blue // elements of pixel_pack of type Quantum are the // same as the red/green/blue of an XColor! if (QuantumDepth==16) { my_colors[0].red=pixel_pack[l].red; my_colors[0].green=pixel_pack[l].green; my_colors[0].blue=pixel_pack[l].blue; } else { // QuantumDepth=8 // shift the bits of the 8-bit quantity so that // they become the high bigs of my_colors.* my_colors[0].red=pixel_pack[l].red<<8; my_colors[0].green=pixel_pack[l].green<<8; my_colors[0].blue=pixel_pack[l].blue<<8; } // NOW my_colors has the right r,g,b range for // pack_pixel_bits pack_pixel_bits(my_colors[0].red * raster_map_intensity, my_colors[0].green * raster_map_intensity, my_colors[0].blue * raster_map_intensity, &my_colors[0].pixel); XSetForeground(XtDisplay(w), gc, my_colors[0].pixel); } (void)XFillRectangle (XtDisplay (w),pixmap,gc,scr_x,scr_y,scr_dx,scr_dy); } // check map boundaries in y direction } } // loop over map pixel columns if (map_seen && !map_act) map_done = 1; } } // loop over map pixel rows if (image) DestroyImage(image); if (image_info) DestroyImageInfo(image_info); DestroyExceptionInfo(&exception); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % R e a d C M Y K I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method ReadCMYKImage reads an image of raw cyan, magenta, yellow, and black % samples and returns it. It allocates the memory necessary for the new % Image structure and returns a pointer to the new image. % % The format of the ReadCMYKImage method is: % % Image *ReadCMYKImage(const ImageInfo *image_info, % ExceptionInfo *exception) % % A description of each parameter follows: % % o image: Method ReadCMYKImage returns a pointer to the image after % reading. A null image is returned if there is a memory shortage or % if the image cannot be read. % % o image_info: Specifies a pointer to a ImageInfo structure. % % o exception: return any errors or warnings in this structure. % % */ static Image *ReadCMYKImage(const ImageInfo *image_info, ExceptionInfo *exception) { Image *image; long y; register long i, x; register PixelPacket *q; size_t count; unsigned char *scanline; unsigned int status; unsigned int packet_size, quantum_size; ImportPixelAreaOptions import_options; assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); image=AllocateImage(image_info); if ((image->columns == 0) || (image->rows == 0)) ThrowReaderException(OptionError,MustSpecifyImageSize,image); if (image_info->interlace != PartitionInterlace) { /* Open image file. */ status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == False) ThrowReaderException(FileOpenError,UnableToOpenFile,image); for (i=0; i < image->offset; i++) { if (EOF == ReadBlobByte(image)) ThrowException(exception,CorruptImageError,UnexpectedEndOfFile, image->filename); } } if (image->logging) (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Tile %lux%lu%+ld%+ld", image->tile_info.width,image->tile_info.height, image->tile_info.x,image->tile_info.y); /* Allocate memory for a scanline. */ if (image->depth <= 8) quantum_size=8; else if (image->depth <= 16) quantum_size=16; else quantum_size=32; packet_size=(quantum_size*4)/8; if (LocaleCompare(image_info->magick,"CMYKA") == 0) { image->matte=True; packet_size=(quantum_size*5)/8; } scanline=MagickAllocateArray(unsigned char *, packet_size,image->tile_info.width); if (scanline == (unsigned char *) NULL) ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image); /* Initialize import options. */ ImportPixelAreaOptionsInit(&import_options); if (image_info->endian != UndefinedEndian) import_options.endian=image_info->endian; if (image->logging) (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Depth %u bits, Endian %s, Interlace %s", quantum_size, EndianTypeToString(import_options.endian), InterlaceTypeToString(image_info->interlace)); /* Support starting at intermediate image frame. */ if (image_info->subrange != 0) while (image->scene < image_info->subimage) { /* Skip to next image. */ image->scene++; for (y=0; y < (long) image->rows; y++) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); } x=(long) (packet_size*image->tile_info.x); do { /* Convert raster image to pixel packets. */ image->colorspace=CMYKColorspace; if (image_info->ping && (image_info->subrange != 0)) if (image->scene >= (image_info->subimage+image_info->subrange-1)) break; switch (image_info->interlace) { case NoInterlace: default: { /* No interlacing: CMYKCMYKCMYKCMYKCMYKCMYK... */ for (y=0; y < image->tile_info.y; y++) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); for (y=0; y < (long) image->rows; y++) { if ((y > 0) || (image->previous == (Image *) NULL)) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); q=SetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; if (!image->matte) (void) ImportImagePixelArea(image,CMYKQuantum,quantum_size,scanline+x, &import_options,0); else (void) ImportImagePixelArea(image,CMYKAQuantum,quantum_size,scanline+x, &import_options,0); if (!SyncImagePixels(image)) break; if (image->previous == (Image *) NULL) if (QuantumTick(y,image->rows)) if (!MagickMonitorFormatted(y,image->rows,exception, LoadImageText,image->filename, image->columns,image->rows)) break; } count=image->tile_info.height-image->rows-image->tile_info.y; for (i=0; i < (long) count; i++) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); break; } case LineInterlace: { /* Line interlacing: CCC...MMM...YYY...KKK...CCC...MMM...YYY...KKK... */ packet_size=(quantum_size)/8; for (y=0; y < image->tile_info.y; y++) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); for (y=0; y < (long) image->rows; y++) { if ((y > 0) || (image->previous == (Image *) NULL)) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); q=SetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; (void) ImportImagePixelArea(image,CyanQuantum,quantum_size,scanline+x, &import_options,0); (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); (void) ImportImagePixelArea(image,MagentaQuantum,quantum_size,scanline+x, &import_options,0); (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); (void) ImportImagePixelArea(image,YellowQuantum,quantum_size,scanline+x, &import_options,0); (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); (void) ImportImagePixelArea(image,BlackQuantum,quantum_size,scanline+x, &import_options,0); if (image->matte) { (void) ReadBlob(image,packet_size*image->tile_info.width, scanline); (void) ImportImagePixelArea(image,AlphaQuantum,quantum_size,scanline+x, &import_options,0); } if (!SyncImagePixels(image)) break; if (image->previous == (Image *) NULL) if (QuantumTick(y,image->rows)) if (!MagickMonitorFormatted(y,image->rows,exception, LoadImageText,image->filename, image->columns,image->rows)) break; } count=image->tile_info.height-image->rows-image->tile_info.y; for (i=0; i < (long) count; i++) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); break; } case PlaneInterlace: case PartitionInterlace: { unsigned long span; /* Plane interlacing: CCCCCC...MMMMMM...YYYYYY...KKKKKK... */ if (image_info->interlace == PartitionInterlace) { AppendImageFormat("C",image->filename); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == False) ThrowReaderException(FileOpenError,UnableToOpenFile,image); } packet_size=(quantum_size)/8; for (y=0; y < image->tile_info.y; y++) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); i=0; span=image->rows*(image->matte ? 5 : 4); for (y=0; y < (long) image->rows; y++) { if ((y > 0) || (image->previous == (Image *) NULL)) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); q=SetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; (void) ImportImagePixelArea(image,CyanQuantum,quantum_size,scanline+x, &import_options,0); if (!SyncImagePixels(image)) break; if (image->previous == (Image *) NULL) if (QuantumTick(i,span)) if (!MagickMonitorFormatted(i,span,&image->exception, LoadImageText,image->filename, image->columns,image->rows)) break; i++; } count=image->tile_info.height-image->rows-image->tile_info.y; for (i=0; i < (long) count; i++) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); if (image_info->interlace == PartitionInterlace) { CloseBlob(image); AppendImageFormat("M",image->filename); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == False) ThrowReaderException(FileOpenError,UnableToOpenFile,image); } for (y=0; y < image->tile_info.y; y++) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); for (y=0; y < (long) image->rows; y++) { (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); q=GetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; (void) ImportImagePixelArea(image,MagentaQuantum,quantum_size,scanline+x, &import_options,0); if (!SyncImagePixels(image)) break; if (image->previous == (Image *) NULL) if (QuantumTick(i,span)) if (!MagickMonitorFormatted(i,span,&image->exception, LoadImageText,image->filename, image->columns,image->rows)) break; i++; } count=image->tile_info.height-image->rows-image->tile_info.y; for (i=0; i < (long) count; i++) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); if (image_info->interlace == PartitionInterlace) { CloseBlob(image); AppendImageFormat("Y",image->filename); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == False) ThrowReaderException(FileOpenError,UnableToOpenFile,image); } for (y=0; y < image->tile_info.y; y++) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); for (y=0; y < (long) image->rows; y++) { (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); q=GetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; (void) ImportImagePixelArea(image,YellowQuantum,quantum_size,scanline+x, &import_options,0); if (!SyncImagePixels(image)) break; if (image->previous == (Image *) NULL) if (QuantumTick(i,span)) if (!MagickMonitorFormatted(i,span,&image->exception, LoadImageText,image->filename, image->columns,image->rows)) break; i++; } count=image->tile_info.height-image->rows-image->tile_info.y; for (i=0; i < (long) count; i++) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); if (image_info->interlace == PartitionInterlace) { CloseBlob(image); AppendImageFormat("K",image->filename); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == False) ThrowReaderException(FileOpenError,UnableToOpenFile,image); } for (y=0; y < image->tile_info.y; y++) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); for (y=0; y < (long) image->rows; y++) { (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); q=GetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; (void) ImportImagePixelArea(image,BlackQuantum,quantum_size,scanline+x, &import_options,0); if (!SyncImagePixels(image)) break; if (image->previous == (Image *) NULL) if (QuantumTick(i,span)) if (!MagickMonitorFormatted(i,span,&image->exception, LoadImageText,image->filename, image->columns,image->rows)) break; i++; } count=image->tile_info.height-image->rows-image->tile_info.y; for (i=0; i < (long) count; i++) (void) ReadBlob(image,packet_size*image->tile_info.width,scanline); if (image->matte) { /* Read matte channel. */ if (image_info->interlace == PartitionInterlace) { CloseBlob(image); AppendImageFormat("A",image->filename); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == False) ThrowReaderException(FileOpenError,UnableToOpenFile,image); } for (y=0; y < image->tile_info.y; y++) (void) ReadBlob(image,packet_size*image->tile_info.width, scanline); for (y=0; y < (long) image->rows; y++) { (void) ReadBlob(image,packet_size*image->tile_info.width, scanline); q=GetImagePixels(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; (void) ImportImagePixelArea(image,AlphaQuantum,quantum_size,scanline+x, &import_options,0); if (!SyncImagePixels(image)) break; if (image->previous == (Image *) NULL) if (QuantumTick(i,span)) if (!MagickMonitorFormatted(i,span,&image->exception, LoadImageText,image->filename, image->columns,image->rows)) break; i++; } count=image->tile_info.height-image->rows-image->tile_info.y; for (i=0; i < (long) count; i++) (void) ReadBlob(image,packet_size*image->tile_info.width, scanline); } if (image_info->interlace == PartitionInterlace) (void) strlcpy(image->filename,image_info->filename,MaxTextExtent); break; } } if (EOFBlob(image)) { ThrowException(exception,CorruptImageError,UnexpectedEndOfFile, image->filename); break; } /* Proceed to next image. */ if (image_info->subrange != 0) if (image->scene >= (image_info->subimage+image_info->subrange-1)) break; if (image_info->interlace == PartitionInterlace) break; count=ReadBlob(image,packet_size*image->tile_info.width,scanline); if (count != 0) { /* Allocate next image structure. */ AllocateNextImage(image_info,image); if (image->next == (Image *) NULL) { DestroyImageList(image); return((Image *) NULL); } image=SyncNextImageInList(image); status=MagickMonitorFormatted(TellBlob(image),GetBlobSize(image), exception,LoadImagesText, image->filename); if (status == False) break; } } while (count != 0); MagickFreeMemory(scanline); while (image->previous != (Image *) NULL) image=image->previous; CloseBlob(image); return(image); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % W r i t e P I C O N I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Procedure WritePICONImage() writes an image to a file in the Personal Icon % format. % % The format of the WritePICONImage method is: % % MagickBooleanType WritePICONImage(const ImageInfo *image_info, % Image *image) % % A description of each parameter follows. % % o image_info: the image info. % % o image: The image. % */ static MagickBooleanType WritePICONImage(const ImageInfo *image_info, Image *image) { #define ColormapExtent 155 #define GraymapExtent 95 #define PiconGeometry "48x48>" static unsigned char Colormap[]= { 0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 0x06, 0x00, 0x05, 0x00, 0xf4, 0x05, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x4f, 0x4f, 0x70, 0x80, 0x90, 0x7e, 0x7e, 0x7e, 0xdc, 0xdc, 0xdc, 0xff, 0xff, 0xff, 0x00, 0x00, 0x80, 0x00, 0x00, 0xff, 0x1e, 0x90, 0xff, 0x87, 0xce, 0xeb, 0xe6, 0xe6, 0xfa, 0x00, 0xff, 0xff, 0x80, 0x00, 0x80, 0xb2, 0x22, 0x22, 0x2e, 0x8b, 0x57, 0x32, 0xcd, 0x32, 0x00, 0xff, 0x00, 0x98, 0xfb, 0x98, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x63, 0x47, 0xff, 0xa5, 0x00, 0xff, 0xd7, 0x00, 0xff, 0xff, 0x00, 0xee, 0x82, 0xee, 0xa0, 0x52, 0x2d, 0xcd, 0x85, 0x3f, 0xd2, 0xb4, 0x8c, 0xf5, 0xde, 0xb3, 0xff, 0xfa, 0xcd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0xf9, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x05, 0x00, 0x00, 0x05, 0x18, 0x20, 0x10, 0x08, 0x03, 0x51, 0x18, 0x07, 0x92, 0x28, 0x0b, 0xd3, 0x38, 0x0f, 0x14, 0x49, 0x13, 0x55, 0x59, 0x17, 0x96, 0x69, 0x1b, 0xd7, 0x85, 0x00, 0x3b, }, Graymap[]= { 0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 0x04, 0x00, 0x04, 0x00, 0xf3, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x12, 0x12, 0x12, 0x21, 0x21, 0x21, 0x33, 0x33, 0x33, 0x45, 0x45, 0x45, 0x54, 0x54, 0x54, 0x66, 0x66, 0x66, 0x78, 0x78, 0x78, 0x87, 0x87, 0x87, 0x99, 0x99, 0x99, 0xab, 0xab, 0xab, 0xba, 0xba, 0xba, 0xcc, 0xcc, 0xcc, 0xde, 0xde, 0xde, 0xed, 0xed, 0xed, 0xff, 0xff, 0xff, 0x21, 0xf9, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x04, 0x0c, 0x10, 0x04, 0x31, 0x48, 0x31, 0x07, 0x25, 0xb5, 0x58, 0x73, 0x4f, 0x04, 0x00, 0x3b, }; #define MaxCixels 92 static const char Cixel[MaxCixels+1] = " .XoO+@#$%&*=-;:>,<1234567890qwertyuipasdfghjk" "lzxcvbnmMNBVCZASDFGHJKLPIUYTREWQ!~^/()_`'][{}|"; char buffer[MaxTextExtent], basename[MaxTextExtent], name[MaxTextExtent], symbol[MaxTextExtent]; Image *picon, *map; ImageInfo *blob_info; long j, k, y; MagickBooleanType status, transparent; MagickPixelPacket pixel; RectangleInfo geometry; register const PixelPacket *p; register IndexPacket *indexes; register long i, x; register PixelPacket *q; unsigned long characters_per_pixel, colors; /* Open output image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(image != (Image *) NULL); assert(image->signature == MagickSignature); if (image->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception); if (status == MagickFalse) return(status); if (image_info->colorspace == UndefinedColorspace) (void) SetImageColorspace(image,RGBColorspace); SetGeometry(image,&geometry); (void) ParseMetaGeometry(PiconGeometry,&geometry.x,&geometry.y, &geometry.width,&geometry.height); picon=ResizeImage(image,geometry.width,geometry.height,TriangleFilter,1.0, &image->exception); blob_info=CloneImageInfo(image_info); (void) AcquireUniqueFilename(blob_info->filename); if ((image_info->type != TrueColorType) && (IsGrayImage(image,&image->exception) != MagickFalse)) map=BlobToImage(blob_info,Graymap,GraymapExtent,&image->exception); else map=BlobToImage(blob_info,Colormap,ColormapExtent,&image->exception); (void) RelinquishUniqueFileResource(blob_info->filename); blob_info=DestroyImageInfo(blob_info); if ((picon == (Image *) NULL) || (map == (Image *) NULL)) return(MagickFalse); status=MapImage(picon,map,image_info->dither); map=DestroyImage(map); transparent=MagickFalse; if (picon->storage_class == PseudoClass) { CompressImageColormap(picon); if (picon->matte != MagickFalse) transparent=MagickTrue; } else { /* Convert DirectClass to PseudoClass picon. */ if (picon->matte != MagickFalse) { /* Map all the transparent pixels. */ for (y=0; y < (long) picon->rows; y++) { q=GetImagePixels(picon,0,y,picon->columns,1); if (q == (PixelPacket *) NULL) break; for (x=0; x < (long) picon->columns; x++) { if (q->opacity == (Quantum) TransparentOpacity) transparent=MagickTrue; else q->opacity=OpaqueOpacity; q++; } if (SyncImagePixels(picon) == MagickFalse) break; } } (void) SetImageType(picon,PaletteType); } colors=picon->colors; if (transparent != MagickFalse) { colors++; picon->colormap=(PixelPacket *) ResizeQuantumMemory((void **) picon->colormap,(size_t) colors,sizeof(*picon->colormap)); if (picon->colormap == (PixelPacket *) NULL) ThrowWriterException(ResourceLimitError,"MemoryAllocationError"); for (y=0; y < (long) picon->rows; y++) { q=GetImagePixels(picon,0,y,picon->columns,1); if (q == (PixelPacket *) NULL) break; indexes=GetIndexes(picon); for (x=0; x < (long) picon->columns; x++) { if (q->opacity == (Quantum) TransparentOpacity) indexes[x]=(IndexPacket) picon->colors; q++; } if (SyncImagePixels(picon) == MagickFalse) break; } } /* Compute the character per pixel. */ characters_per_pixel=1; for (k=MaxCixels; (long) colors > k; k*=MaxCixels) characters_per_pixel++; /* XPM header. */ (void) WriteBlobString(image,"/* XPM */\n"); GetPathComponent(picon->filename,BasePath,basename); (void) FormatMagickString(buffer,MaxTextExtent, "static char *%s[] = {\n",basename); (void) WriteBlobString(image,buffer); (void) WriteBlobString(image,"/* columns rows colors chars-per-pixel */\n"); (void) FormatMagickString(buffer,MaxTextExtent,"\"%lu %lu %lu %ld\",\n", picon->columns,picon->rows,colors,characters_per_pixel); (void) WriteBlobString(image,buffer); GetMagickPixelPacket(image,&pixel); for (i=0; i < (long) colors; i++) { /* Define XPM color. */ SetMagickPixelPacket(image,picon->colormap+i,(IndexPacket *) NULL,&pixel); pixel.colorspace=RGBColorspace; pixel.depth=8; pixel.opacity=(MagickRealType) OpaqueOpacity; (void) QueryMagickColorname(image,&pixel,XPMCompliance,MagickFalse,name, &image->exception); if (LocaleNCompare(name,"rgb",3) == 0) (void) QueryMagickColorname(image,&pixel,XPMCompliance,MagickTrue,name, &image->exception); if (transparent != MagickFalse) { if (i == (long) (colors-1)) (void) CopyMagickString(name,"grey75",MaxTextExtent); } /* Write XPM color. */ k=i % MaxCixels; symbol[0]=Cixel[k]; for (j=1; j < (long) characters_per_pixel; j++) { k=((i-k)/MaxCixels) % MaxCixels; symbol[j]=Cixel[k]; } symbol[j]='\0'; (void) FormatMagickString(buffer,MaxTextExtent,"\"%s c %s\",\n", symbol,name); (void) WriteBlobString(image,buffer); } /* Define XPM pixels. */ (void) WriteBlobString(image,"/* pixels */\n"); for (y=0; y < (long) picon->rows; y++) { p=AcquireImagePixels(picon,0,y,picon->columns,1,&picon->exception); if (p == (const PixelPacket *) NULL) break; indexes=GetIndexes(picon); (void) WriteBlobString(image,"\""); for (x=0; x < (long) picon->columns; x++) { k=((long) indexes[x] % MaxCixels); symbol[0]=Cixel[k]; for (j=1; j < (long) characters_per_pixel; j++) { k=(((int) indexes[x]-k)/MaxCixels) % MaxCixels; symbol[j]=Cixel[k]; } symbol[j]='\0'; (void) CopyMagickString(buffer,symbol,MaxTextExtent); (void) WriteBlobString(image,buffer); } (void) FormatMagickString(buffer,MaxTextExtent,"\"%s\n", y == (long) (picon->rows-1) ? "" : ","); (void) WriteBlobString(image,buffer); if (QuantumTick(y,picon->rows) != MagickFalse) if ((image->progress_monitor != (MagickProgressMonitor) NULL) && (QuantumTick(y,picon->rows) != MagickFalse)) { status=image->progress_monitor(SaveImageTag,y,picon->rows, image->client_data); if (status == MagickFalse) break; } } picon=DestroyImage(picon); (void) WriteBlobString(image,"};\n"); (void) CloseBlob(image); return(MagickTrue); }