static void draw_ripple(struct state *st, short *src) { int across, down; char *dirty = st->dirty_buffer; for (down = 0; down < st->height - 1; down++, src += 1, dirty += 1) for (across = 0; across < st->width - 1; across++, src++, dirty++) { int v1, v2, v3, v4; v1 = (int)*src; v2 = (int)*(src + 1); v3 = (int)*(src + st->width); v4 = (int)*(src + st->width + 1); if ((v1 == 0 && v2 == 0 && v3 == 0 && v4 == 0)) { if (*dirty > 0) (*dirty)--; } else *dirty = DIRTY; if (*dirty > 0) { int dx; if (st->light > 0) { dx = ((v3 - v1) + (v4 - v2)) << st->light; /* light from top */ } else dx = 0; XPutPixel(st->buffer_map,(across<<1), (down<<1), map_color(st, dx + v1)); XPutPixel(st->buffer_map,(across<<1)+1,(down<<1), map_color(st, dx + ((v1 + v2) >> 1))); XPutPixel(st->buffer_map,(across<<1), (down<<1)+1,map_color(st, dx + ((v1 + v3) >> 1))); XPutPixel(st->buffer_map,(across<<1)+1,(down<<1)+1,map_color(st, dx + ((v1 + v4) >> 1))); } }
/*-----------------------------------------------------------------------------------*/ void bgcolor(unsigned char c) { c = map_color(c); color = ((c << 4) | (color & 0xF0)); /* Presume this to be one of the first calls. */ console_init(); }
void Graph::showPath(MapPoint goal_position) { std::list<MapPoint> finalPath; std::list<MapPoint>::iterator listIt; // Get goal node Node* node = nodes_list_[goal_position.label]; // Cycle through all available nodes starting from the goal to the start //node while(1) { finalPath.push_front(node->map_position_); // get this node parent node = node->parent_; // if this new node is our start position, i.e., it is our root, we're //done if( node == root_ ) break; } // Map to show path cv::Mat map_color(map_.size().height, map_.size().width, CV_8UC3); cvtColor(map_, map_color, CV_GRAY2RGB); // Now go through the list and print all positions std::cout << "This is the path from " << root_->map_position_.label << " to " << goal_position.label << ":\n"; std::cout << root_->map_position_.label; // Show them in the map to. map_color.at<cv::Vec3b>(root_->map_position_.row, root_->map_position_.column) = cv::Vec3b(0,0,255); for( listIt = finalPath.begin(); listIt != finalPath.end(); listIt++) { std::cout << " --> " << listIt->label; map_color.at<cv::Vec3b>(listIt->row,listIt->column) = cv::Vec3b(0,0,255); } std::cout << std::endl; cv::imshow("Map", map_color); cv::imwrite("Map_solution.png", map_color); }
grub_err_t grub_video_bitmap_create_scaled (struct grub_video_bitmap **dst, int dst_width, int dst_height, struct grub_video_bitmap *src, int scale, grub_video_color_t color) { int type, method; int src_width, src_height, width, height; struct grub_video_fbblit_info dst_info; struct grub_video_bitmap *tmp = 0; grub_err_t ret; *dst = 0; /* Verify the simplifying assumptions. */ if (src == 0) return grub_error (GRUB_ERR_BAD_ARGUMENT, "null src bitmap in grub_video_bitmap_create_scaled"); if (src->mode_info.red_field_pos % 8 != 0 || src->mode_info.green_field_pos % 8 != 0 || src->mode_info.blue_field_pos % 8 != 0 || src->mode_info.reserved_field_pos % 8 != 0) return grub_error (GRUB_ERR_BAD_ARGUMENT, "src format not supported for scale"); if (src->mode_info.width == 0 || src->mode_info.height == 0) return grub_error (GRUB_ERR_BAD_ARGUMENT, "source bitmap has a zero dimension"); if (dst_width <= 0 || dst_height <= 0) return grub_error (GRUB_ERR_BAD_ARGUMENT, "requested to scale to a size w/ a zero dimension"); if (src->mode_info.bytes_per_pixel * 8 != src->mode_info.bpp) return grub_error (GRUB_ERR_BAD_ARGUMENT, "bitmap to scale has inconsistent Bpp and bpp"); type = scale & GRUB_VIDEO_BITMAP_SCALE_TYPE_MASK; method = scale & GRUB_VIDEO_BITMAP_SCALE_METHOD_MASK; src_width = src->mode_info.width; src_height = src->mode_info.height; if ((src_width == dst_width) && (src_height == dst_height)) type = GRUB_VIDEO_BITMAP_SCALE_TYPE_CENTER; if ((type == GRUB_VIDEO_BITMAP_SCALE_TYPE_NORMAL) || (((type == GRUB_VIDEO_BITMAP_SCALE_TYPE_MINFIT) || (type == GRUB_VIDEO_BITMAP_SCALE_TYPE_MAXFIT)) && (src_width * dst_height == src_height * dst_width))) return grub_video_bitmap_create_scaled_internal (dst, dst_width, dst_height, src, method); ret = grub_video_bitmap_create (dst, dst_width, dst_height, src->mode_info.blit_format); if (ret != GRUB_ERR_NONE) return ret; /* Error. */ (*dst)->transparent = src->transparent; dst_info.mode_info = &(*dst)->mode_info; dst_info.data = (*dst)->data; color = map_color (dst_info.mode_info, color); switch (type) { case GRUB_VIDEO_BITMAP_SCALE_TYPE_MINFIT: case GRUB_VIDEO_BITMAP_SCALE_TYPE_MAXFIT: { if ((src_width * dst_height > src_height * dst_width) == (type == GRUB_VIDEO_BITMAP_SCALE_TYPE_MAXFIT)) { width = src_width * dst_height / src_height; height = dst_height; } else { width = dst_width; height = src_height * dst_width / src_width; } ret = grub_video_bitmap_create_scaled_internal (&tmp, width, height, src, method); if (ret) return ret; src = tmp; src_width = width; src_height = height; } case GRUB_VIDEO_BITMAP_SCALE_TYPE_CENTER: { int src_x, src_y, dst_x, dst_y; struct grub_video_fbblit_info src_info; width = (src_width > dst_width) ? dst_width : src_width; height = (src_height > dst_height) ? dst_height : src_height; src_x = (src_width - width) >> 1; src_y = (src_height - height) >> 1; dst_x = (dst_width - width) >> 1; dst_y = (dst_height - height) >> 1; if (dst_y) { grub_video_fbfill (&dst_info, color, 0, 0, dst_width, dst_y); grub_video_fbfill (&dst_info, color, 0, dst_y + height, dst_width, dst_height - dst_y - height); } if (dst_x) { grub_video_fbfill (&dst_info, color, 0, dst_y, dst_x, height); grub_video_fbfill (&dst_info, color, dst_x + width, dst_y, dst_width - dst_x - width, height); } src_info.mode_info = &src->mode_info; src_info.data = src->data; grub_video_fbblit (&dst_info, &src_info, GRUB_VIDEO_BLIT_REPLACE, dst_x, dst_y, width, height, src_x, src_y); break; } case GRUB_VIDEO_BITMAP_SCALE_TYPE_TILING: { int x, y; struct grub_video_fbblit_info src_info; src_info.mode_info = &src->mode_info; src_info.data = src->data; for (y = 0; y < dst_height; y += src_height) { for (x = 0; x < dst_width; x += src_width) { int w, h; w = src_width; if (x + w > dst_width) w = dst_width - x; h = src_height; if (y + h > dst_height) h = dst_height - y; grub_video_fbblit (&dst_info, &src_info, GRUB_VIDEO_BLIT_REPLACE, x, y, w, h, 0, 0); } } break; } default: return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid scale type value"); } if (tmp) grub_video_bitmap_destroy (tmp); return 0; }
static fz_pixmap * pam_binary_read_image(fz_context *ctx, struct info *pnm, unsigned char *p, unsigned char *e, int onlymeta) { fz_pixmap *img = NULL; int bitmap = 0; p = pam_binary_read_header(ctx, pnm, p, e); if (pnm->tupletype == NULL) switch (pnm->depth) { case 1: pnm->tupletype = fz_strdup(ctx, "BLACKANDWHITE"); break; case 2: pnm->tupletype = fz_strdup(ctx, "GRAYSCALE_ALPHA"); break; case 3: pnm->tupletype = fz_strdup(ctx, "RGB"); break; case 4: pnm->tupletype = fz_strdup(ctx, "CMYK"); break; case 5: pnm->tupletype = fz_strdup(ctx, "CMYK_ALPHA"); break; default: fz_throw(ctx, FZ_ERROR_GENERIC, "cannot guess tupletype based on depth in pnm image"); } if (!strcmp(pnm->tupletype, "BLACKANDWHITE")) { if (pnm->depth != 1) fz_throw(ctx, FZ_ERROR_GENERIC, "depth out of range for b/w pnm image"); if (pnm->maxval == 1) bitmap = 1; else if (pnm->maxval < 2 || pnm->maxval > 65535) fz_throw(ctx, FZ_ERROR_GENERIC, "maxval out of range for grayscale pnm image"); pnm->cs = fz_device_gray(ctx); } else if (!strcmp(pnm->tupletype, "GRAYSCALE")) { if (pnm->maxval < 2 || pnm->maxval > 65535) fz_throw(ctx, FZ_ERROR_GENERIC, "maxval out of range for grayscale pnm image"); if (pnm->depth != 1) fz_throw(ctx, FZ_ERROR_GENERIC, "depth out of range for grayscale pnm image"); pnm->cs = fz_device_gray(ctx); } else if (!strcmp(pnm->tupletype, "GRAYSCALE_ALPHA")) { if (pnm->maxval < 2 || pnm->maxval > 65535) fz_throw(ctx, FZ_ERROR_GENERIC, "maxval out of range for grayscale pnm image with alpha"); if (pnm->depth != 2) fz_throw(ctx, FZ_ERROR_GENERIC, "depth out of range for grayscale pnm image with alpha"); pnm->cs = fz_device_gray(ctx); pnm->alpha = 1; } else if (!strcmp(pnm->tupletype, "RGB")) { if (pnm->maxval < 1 || pnm->maxval > 65535) fz_throw(ctx, FZ_ERROR_GENERIC, "maxval out of range for rgb pnm image"); if (pnm->depth != 3) fz_throw(ctx, FZ_ERROR_GENERIC, "depth out of range for rgb pnm image"); pnm->cs = fz_device_rgb(ctx); } else if (!strcmp(pnm->tupletype, "RGB_ALPHA")) { if (pnm->maxval < 1 || pnm->maxval > 65535) fz_throw(ctx, FZ_ERROR_GENERIC, "maxval out of range for rgb pnm image with alpha"); if (pnm->depth != 4) fz_throw(ctx, FZ_ERROR_GENERIC, "depth out of range for rgb pnm image with alpha"); pnm->cs = fz_device_rgb(ctx); pnm->alpha = 1; } else if (!strcmp(pnm->tupletype, "CMYK")) { if (pnm->maxval < 1 || pnm->maxval > 65535) fz_throw(ctx, FZ_ERROR_GENERIC, "maxval out of range for cmyk pnm image"); if (pnm->depth != 4) fz_throw(ctx, FZ_ERROR_GENERIC, "depth out of range for cmyk pnm image"); pnm->cs = fz_device_cmyk(ctx); } else if (!strcmp(pnm->tupletype, "CMYK_ALPHA")) { if (pnm->maxval < 1 || pnm->maxval > 65535) fz_throw(ctx, FZ_ERROR_GENERIC, "maxval out of range for cmyk pnm image with alpha"); if (pnm->depth != 5) fz_throw(ctx, FZ_ERROR_GENERIC, "depth out of range for cmyk pnm image with alpha"); pnm->cs = fz_device_cmyk(ctx); pnm->alpha = 1; } else { fz_free(ctx, pnm->tupletype); fz_throw(ctx, FZ_ERROR_GENERIC, "unsupported tupletype"); } fz_free(ctx, pnm->tupletype); if (!onlymeta) { unsigned char *dp; int x, y, k; img = fz_new_pixmap(ctx, pnm->cs, pnm->width, pnm->height, pnm->alpha); dp = img->samples; if (bitmap) { if (e - p < pnm->height * pnm->width * img->n) fz_throw(ctx, FZ_ERROR_GENERIC, "truncated image"); for (y = 0; y < pnm->height; y++) for (x = 0; x < pnm->width; x++) for (k = 0; k < img->colorspace->n; k++) { if (*p) *dp = 0x00; else *dp = 0xff; dp++; p++; } } else { if (pnm->maxval == 255) { if (e - p < pnm->height * pnm->width * img->n) fz_throw(ctx, FZ_ERROR_GENERIC, "truncated image"); for (y = 0; y < pnm->height; y++) for (x = 0; x < pnm->width; x++) for (k = 0; k < img->n; k++) *dp++ = *p++; } else if (pnm->maxval < 256) { if (e - p < pnm->height * pnm->width * img->n) fz_throw(ctx, FZ_ERROR_GENERIC, "truncated image"); for (y = 0; y < pnm->height; y++) for (x = 0; x < pnm->width; x++) for (k = 0; k < img->n; k++) *dp++ = map_color(ctx, *p++, pnm->maxval, 255); } else { if (e - p < pnm->height * pnm->width * img->n * 2) fz_throw(ctx, FZ_ERROR_GENERIC, "truncated image"); for (y = 0; y < pnm->height; y++) for (x = 0; x < pnm->width; x++) for (k = 0; k < img->n; k++) { *dp++ = map_color(ctx, (p[0] << 8) | p[1], pnm->maxval, 255); p += 2; } } } } return img; }
static fz_pixmap * pnm_binary_read_image(fz_context *ctx, struct info *pnm, unsigned char *p, unsigned char *e, int onlymeta, int bitmap) { fz_pixmap *img = NULL; p = pnm_read_number(ctx, p, e, &pnm->width); p = pnm_read_white(ctx, p, e, 0); if (bitmap) { p = pnm_read_number(ctx, p, e, &pnm->height); p = pnm_read_white(ctx, p, e, 1); pnm->maxval = 1; } else { p = pnm_read_number(ctx, p, e, &pnm->height); p = pnm_read_white(ctx, p, e, 0); p = pnm_read_number(ctx, p, e, &pnm->maxval); p = pnm_read_white(ctx, p, e, 1); if (pnm->maxval < 0 || pnm->maxval >= 65536) fz_throw(ctx, FZ_ERROR_GENERIC, "maximum sample value of out range in pnm image: %d", pnm->maxval); } if (!onlymeta) { unsigned char *dp; int x, y, k; img = fz_new_pixmap(ctx, pnm->cs, pnm->width, pnm->height, 0); dp = img->samples; if (bitmap) { for (y = 0; y < pnm->height; y++) { for (x = 0; x < pnm->width; x++) { if (*p & (1 << (7 - (x & 0x7)))) *dp = 0x00; else *dp = 0xff; dp++; if ((x & 0x7) == 7) p++; } if (pnm->width & 0x7) p++; } } else { if (pnm->maxval == 255) { for (y = 0; y < pnm->height; y++) for (x = 0; x < pnm->width; x++) for (k = 0; k < img->colorspace->n; k++) *dp++ = *p++; } else if (pnm->maxval < 256) { for (y = 0; y < pnm->height; y++) for (x = 0; x < pnm->width; x++) for (k = 0; k < img->colorspace->n; k++) *dp++ = map_color(ctx, *p++, pnm->maxval, 255); } else { for (y = 0; y < pnm->height; y++) for (x = 0; x < pnm->width; x++) for (k = 0; k < img->colorspace->n; k++) { *dp++ = map_color(ctx, (p[0] << 8) | p[1], pnm->maxval, 255); p += 2; } } } } return img; }
static fz_pixmap * pnm_ascii_read_image(fz_context *ctx, struct info *pnm, unsigned char *p, unsigned char *e, int onlymeta, int bitmap) { fz_pixmap *img = NULL; p = pnm_read_number(ctx, p, e, &pnm->width); p = pnm_read_white(ctx, p, e, 0); if (bitmap) { p = pnm_read_number(ctx, p, e, &pnm->height); p = pnm_read_white(ctx, p, e, 1); pnm->maxval = 1; } else { p = pnm_read_number(ctx, p, e, &pnm->height); p = pnm_read_white(ctx, p, e, 0); p = pnm_read_number(ctx, p, e, &pnm->maxval); p = pnm_read_white(ctx, p, e, 0); if (pnm->maxval < 0 || pnm->maxval >= 65536) fz_throw(ctx, FZ_ERROR_GENERIC, "maximum sample value of out range in pnm image: %d", pnm->maxval); } if (!onlymeta) { unsigned char *dp; int x, y, k; img = fz_new_pixmap(ctx, pnm->cs, pnm->width, pnm->height, 0); dp = img->samples; if (bitmap) { for (y = 0; y < pnm->height; y++) { for (x = 0; x < pnm->width; x++) { int v = 0; p = pnm_read_number(ctx, p, e, &v); p = pnm_read_white(ctx, p, e, 0); if (v == 0) *dp = 0x00; else *dp = 0xff; dp++; } } } else { for (y = 0; y < pnm->height; y++) for (x = 0; x < pnm->width; x++) for (k = 0; k < img->colorspace->n; k++) { int v = 0; p = pnm_read_number(ctx, p, e, &v); p = pnm_read_white(ctx, p, e, 0); v = fz_clampi(v, 0, pnm->maxval); *dp++ = map_color(ctx, v, pnm->maxval, 255); } } } return img; }
/*-----------------------------------------------------------------------------------*/ void textcolor(unsigned char c) { color = map_color(c); setcolor(); }
/* * Put cell element "element" onto the board, and draw it on screen. * This currently means to fill the cell with a unique color, * but this could be more elaborate... * @param pos: location of element * @param element: type of cell element (e.g. wall) */ static void put_cell(const coord_t pos, cell_t element) { put_board(pos, element); uint32_t color = map_color(element); gfx_draw_rect(pos.x * cellWidth, pos.y * cellWidth, cellWidth, cellWidth, color); }
static fz_pixmap * pam_binary_read_image(fz_context *ctx, struct info *pnm, const unsigned char *p, const unsigned char *e, int onlymeta, const unsigned char **out) { fz_pixmap *img = NULL; int bitmap = 0; int minval = 1; int maxval = 65535; fz_var(img); p = pam_binary_read_header(ctx, pnm, p, e); if (pnm->tupletype == PAM_UNKNOWN) switch (pnm->depth) { case 1: pnm->tupletype = pnm->maxval == 1 ? PAM_BW : PAM_GRAY; break; case 2: pnm->tupletype = pnm->maxval == 1 ? PAM_BWA : PAM_GRAYA; break; case 3: pnm->tupletype = PAM_RGB; break; case 4: pnm->tupletype = PAM_CMYK; break; case 5: pnm->tupletype = PAM_CMYKA; break; default: fz_throw(ctx, FZ_ERROR_GENERIC, "cannot guess tuple type based on depth in pnm image"); } if (pnm->tupletype == PAM_BW && pnm->maxval > 1) pnm->tupletype = PAM_GRAY; else if (pnm->tupletype == PAM_GRAY && pnm->maxval == 1) pnm->tupletype = PAM_BW; else if (pnm->tupletype == PAM_BWA && pnm->maxval > 1) pnm->tupletype = PAM_GRAYA; else if (pnm->tupletype == PAM_GRAYA && pnm->maxval == 1) pnm->tupletype = PAM_BWA; switch (pnm->tupletype) { case PAM_BWA: pnm->alpha = 1; /* fallthrough */ case PAM_BW: pnm->cs = fz_device_gray(ctx); maxval = 1; bitmap = 1; break; case PAM_GRAYA: pnm->alpha = 1; /* fallthrough */ case PAM_GRAY: pnm->cs = fz_device_gray(ctx); minval = 2; break; case PAM_RGBA: pnm->alpha = 1; /* fallthrough */ case PAM_RGB: pnm->cs = fz_device_rgb(ctx); break; case PAM_CMYKA: pnm->alpha = 1; /* fallthrough */ case PAM_CMYK: pnm->cs = fz_device_cmyk(ctx); break; default: fz_throw(ctx, FZ_ERROR_GENERIC, "unsupported tuple type"); } if (pnm->depth != fz_colorspace_n(ctx, pnm->cs) + pnm->alpha) fz_throw(ctx, FZ_ERROR_GENERIC, "depth out of tuple type range"); if (pnm->maxval < minval || pnm->maxval > maxval) fz_throw(ctx, FZ_ERROR_GENERIC, "maxval out of range"); pnm->bitdepth = bitdepth_from_maxval(pnm->maxval); if (pnm->height <= 0) fz_throw(ctx, FZ_ERROR_GENERIC, "image height must be > 0"); if (pnm->width <= 0) fz_throw(ctx, FZ_ERROR_GENERIC, "image width must be > 0"); if ((unsigned int)pnm->height > UINT_MAX / pnm->width / fz_colorspace_n(ctx, pnm->cs) / (pnm->bitdepth / 8 + 1)) fz_throw(ctx, FZ_ERROR_GENERIC, "image too large"); if (onlymeta) { int packed; int w, h, n; w = pnm->width; h = pnm->height; n = fz_colorspace_n(ctx, pnm->cs) + pnm->alpha; /* some encoders incorrectly pack bits into bytes and invert the image */ packed = 0; if (pnm->maxval == 1) { const unsigned char *e_packed = p + w * h * n / 8; if (e_packed < e - 1 && e_packed[0] == 'P' && e_packed[1] >= '0' && e_packed[1] <= '7') e = e_packed; if (e - p < w * h * n) packed = 1; } if (packed && e - p < w * h * n / 8) fz_throw(ctx, FZ_ERROR_GENERIC, "truncated packed image"); if (!packed && e - p < w * h * n * (pnm->maxval < 256 ? 1 : 2)) fz_throw(ctx, FZ_ERROR_GENERIC, "truncated image"); if (pnm->maxval == 255) p += n * w * h; else if (bitmap && packed) p += ((w + 7) / 8) * h; else if (bitmap) p += n * w * h; else if (pnm->maxval < 255) p += n * w * h; else p += 2 * n * w * h; } if (!onlymeta) { unsigned char *dp; int x, y, k, packed; int w, h, n; img = fz_new_pixmap(ctx, pnm->cs, pnm->width, pnm->height, NULL, pnm->alpha); fz_try(ctx) { dp = img->samples; w = img->w; h = img->h; n = img->n; /* some encoders incorrectly pack bits into bytes and invert the image */ packed = 0; if (pnm->maxval == 1) { const unsigned char *e_packed = p + w * h * n / 8; if (e_packed < e - 1 && e_packed[0] == 'P' && e_packed[1] >= '0' && e_packed[1] <= '7') e = e_packed; if (e - p < w * h * n) packed = 1; } if (packed && e - p < w * h * n / 8) fz_throw(ctx, FZ_ERROR_GENERIC, "truncated packed image"); if (!packed && e - p < w * h * n * (pnm->maxval < 256 ? 1 : 2)) fz_throw(ctx, FZ_ERROR_GENERIC, "truncated image"); if (pnm->maxval == 255) memcpy(dp, p, w * h * n); else if (bitmap && packed) { for (y = 0; y < h; y++) for (x = 0; x < w; x++) { for (k = 0; k < n; k++) { *dp++ = (*p & (1 << (7 - (x & 0x7)))) ? 0x00 : 0xff; if ((x & 0x7) == 7) p++; } if (w & 0x7) p++; } } else if (bitmap) { for (y = 0; y < h; y++) for (x = 0; x < w; x++) for (k = 0; k < n; k++) *dp++ = *p++ ? 0xff : 0x00; } else if (pnm->maxval < 255) { for (y = 0; y < h; y++) for (x = 0; x < w; x++) for (k = 0; k < n; k++) *dp++ = map_color(ctx, *p++, pnm->maxval, 255); } else { for (y = 0; y < h; y++) for (x = 0; x < w; x++) for (k = 0; k < n; k++) { *dp++ = map_color(ctx, (p[0] << 8) | p[1], pnm->maxval, 255); p += 2; } } if (pnm->alpha) fz_premultiply_pixmap(ctx, img); } fz_catch(ctx) { fz_drop_pixmap(ctx, img); fz_rethrow(ctx); } }
static fz_pixmap * pnm_binary_read_image(fz_context *ctx, struct info *pnm, const unsigned char *p, const unsigned char *e, int onlymeta, int bitmap, const unsigned char **out) { fz_pixmap *img = NULL; pnm->width = 0; p = pnm_read_number(ctx, p, e, &pnm->width); p = pnm_read_white(ctx, p, e, 0); if (bitmap) { pnm->height = 0; p = pnm_read_number(ctx, p, e, &pnm->height); p = pnm_read_white(ctx, p, e, 1); pnm->maxval = 1; } else { pnm->height = 0; p = pnm_read_number(ctx, p, e, &pnm->height); p = pnm_read_white(ctx, p, e, 0); pnm->maxval = 0; p = pnm_read_number(ctx, p, e, &pnm->maxval); p = pnm_read_white(ctx, p, e, 1); } if (pnm->maxval <= 0 || pnm->maxval >= 65536) fz_throw(ctx, FZ_ERROR_GENERIC, "maximum sample value of out range in pnm image: %d", pnm->maxval); pnm->bitdepth = bitdepth_from_maxval(pnm->maxval); if (pnm->height <= 0) fz_throw(ctx, FZ_ERROR_GENERIC, "image height must be > 0"); if (pnm->width <= 0) fz_throw(ctx, FZ_ERROR_GENERIC, "image width must be > 0"); if ((unsigned int)pnm->height > UINT_MAX / pnm->width / fz_colorspace_n(ctx, pnm->cs) / (pnm->bitdepth / 8 + 1)) fz_throw(ctx, FZ_ERROR_GENERIC, "image too large"); if (onlymeta) { int w = pnm->width; int h = pnm->height; int n = fz_colorspace_n(ctx, pnm->cs); if (pnm->maxval == 255) p += n * w * h; else if (bitmap) p += ((w + 7) / 8) * h; else if (pnm->maxval < 255) p += n * w * h; else p += 2 * n * w * h; } else { unsigned char *dp; int x, y, k; int w, h, n; img = fz_new_pixmap(ctx, pnm->cs, pnm->width, pnm->height, NULL, 0); dp = img->samples; w = img->w; h = img->h; n = img->n; if (pnm->maxval == 255) { memcpy(dp, p, w * h * n); p += n * w * h; } else if (bitmap) { for (y = 0; y < h; y++) { for (x = 0; x < w; x++) { *dp++ = (*p & (1 << (7 - (x & 0x7)))) ? 0x00 : 0xff; if ((x & 0x7) == 7) p++; } if (w & 0x7) p++; } } else if (pnm->maxval < 255) { for (y = 0; y < h; y++) for (x = 0; x < w; x++) for (k = 0; k < n; k++) *dp++ = map_color(ctx, *p++, pnm->maxval, 255); } else { for (y = 0; y < h; y++) for (x = 0; x < w; x++) for (k = 0; k < n; k++) { *dp++ = map_color(ctx, (p[0] << 8) | p[1], pnm->maxval, 255); p += 2; } } } if (out) *out = p; return img; }
static fz_pixmap * pnm_ascii_read_image(fz_context *ctx, struct info *pnm, const unsigned char *p, const unsigned char *e, int onlymeta, int bitmap, const unsigned char **out) { fz_pixmap *img = NULL; p = pnm_read_number(ctx, p, e, &pnm->width); p = pnm_read_white(ctx, p, e, 0); if (bitmap) { p = pnm_read_number(ctx, p, e, &pnm->height); p = pnm_read_white(ctx, p, e, 1); pnm->maxval = 1; } else { p = pnm_read_number(ctx, p, e, &pnm->height); p = pnm_read_white(ctx, p, e, 0); p = pnm_read_number(ctx, p, e, &pnm->maxval); p = pnm_read_white(ctx, p, e, 0); } if (pnm->maxval <= 0 || pnm->maxval >= 65536) fz_throw(ctx, FZ_ERROR_GENERIC, "maximum sample value of out range in pnm image: %d", pnm->maxval); pnm->bitdepth = bitdepth_from_maxval(pnm->maxval); if (pnm->height <= 0) fz_throw(ctx, FZ_ERROR_GENERIC, "image height must be > 0"); if (pnm->width <= 0) fz_throw(ctx, FZ_ERROR_GENERIC, "image width must be > 0"); if ((unsigned int)pnm->height > UINT_MAX / pnm->width / fz_colorspace_n(ctx, pnm->cs) / (pnm->bitdepth / 8 + 1)) fz_throw(ctx, FZ_ERROR_GENERIC, "image too large"); if (onlymeta) { int x, y, k; int w, h, n; w = pnm->width; h = pnm->height; n = fz_colorspace_n(ctx, pnm->cs); if (bitmap) { for (y = 0; y < h; y++) for (x = -1; x < w; x++) { p = pnm_read_number(ctx, p, e, NULL); p = pnm_read_white(ctx, p, e, 0); } } else { for (y = 0; y < h; y++) for (x = 0; x < w; x++) for (k = 0; k < n; k++) { p = pnm_read_number(ctx, p, e, NULL); p = pnm_read_white(ctx, p, e, 0); } } } else { unsigned char *dp; int x, y, k; int w, h, n; img = fz_new_pixmap(ctx, pnm->cs, pnm->width, pnm->height, NULL, 0); dp = img->samples; w = img->w; h = img->h; n = img->n; if (bitmap) { for (y = 0; y < h; y++) { for (x = 0; x < w; x++) { int v = 0; p = pnm_read_number(ctx, p, e, &v); p = pnm_read_white(ctx, p, e, 0); *dp++ = v ? 0x00 : 0xff; } } } else { for (y = 0; y < h; y++) for (x = 0; x < w; x++) for (k = 0; k < n; k++) { int v = 0; p = pnm_read_number(ctx, p, e, &v); p = pnm_read_white(ctx, p, e, 0); v = fz_clampi(v, 0, pnm->maxval); *dp++ = map_color(ctx, v, pnm->maxval, 255); } } } if (out) *out = p; return img; }