/* Initialize a bounding box device. */ void gx_device_bbox_init(gx_device_bbox * dev, gx_device * target, gs_memory_t *mem) { gx_device_init((gx_device *) dev, (const gx_device *)&gs_bbox_device, (target ? target->memory : mem), true); if (target) { gx_device_forward_fill_in_procs((gx_device_forward *) dev); set_dev_proc(dev, get_initial_matrix, gx_forward_get_initial_matrix); set_dev_proc(dev, map_rgb_color, gx_forward_map_rgb_color); set_dev_proc(dev, map_color_rgb, gx_forward_map_color_rgb); set_dev_proc(dev, map_cmyk_color, gx_forward_map_cmyk_color); set_dev_proc(dev, map_rgb_alpha_color, gx_forward_map_rgb_alpha_color); set_dev_proc(dev, get_color_mapping_procs, gx_forward_get_color_mapping_procs); set_dev_proc(dev, get_color_comp_index, gx_forward_get_color_comp_index); set_dev_proc(dev, encode_color, gx_forward_encode_color); set_dev_proc(dev, decode_color, gx_forward_decode_color); set_dev_proc(dev, dev_spec_op, gx_forward_dev_spec_op); set_dev_proc(dev, fill_rectangle_hl_color, gx_forward_fill_rectangle_hl_color); set_dev_proc(dev, include_color_space, gx_forward_include_color_space); set_dev_proc(dev, update_spot_equivalent_colors, gx_forward_update_spot_equivalent_colors); set_dev_proc(dev, get_page_device, gx_forward_get_page_device); set_dev_proc(dev, ret_devn_params, gx_forward_ret_devn_params); gx_device_set_target((gx_device_forward *)dev, target); } else { gx_device_fill_in_procs((gx_device *)dev); gx_device_forward_fill_in_procs((gx_device_forward *) dev); } dev->box_procs = box_procs_default; dev->box_proc_data = dev; bbox_copy_params(dev, false); dev->free_standing = false; /* being used as a component */ }
/* Initialize a RasterOp source device. */ void gx_make_rop_texture_device(gx_device_rop_texture * dev, gx_device * target, gs_logical_operation_t log_op, const gx_device_color * texture) { gx_device_init((gx_device *) dev, (const gx_device *)&gs_rop_texture_device, NULL, true); gx_device_set_target((gx_device_forward *)dev, target); /* Drawing operations are defaulted, non-drawing are forwarded. */ check_device_separable((gx_device *) dev); gx_device_fill_in_procs((gx_device *) dev); gx_device_copy_params((gx_device *)dev, target); dev->log_op = log_op; dev->texture = *texture; }
static int bbox_create_compositor(gx_device * dev, gx_device ** pcdev, const gs_composite_t * pcte, gs_imager_state * pis, gs_memory_t * memory, gx_device *cindev) { gx_device_bbox *const bdev = (gx_device_bbox *) dev; gx_device *target = bdev->target; /* * If there isn't a target, all we care about is the bounding box, * so don't bother with actually compositing. */ if (target == 0) { *pcdev = dev; return 0; } /* * Create a compositor for the target, and then wrap another * bbox device around it, but still accumulating the bounding * box in the same place. */ { gx_device *temp_cdev; gx_device_bbox *bbcdev; int code = (*dev_proc(target, create_compositor)) (target, &temp_cdev, pcte, pis, memory, cindev); /* If the target did not create a new compositor then we are done. */ if (code < 0 || target == temp_cdev) { *pcdev = dev; return code; } bbcdev = gs_alloc_struct_immovable(memory, gx_device_bbox, &st_device_bbox, "bbox_create_compositor"); if (bbcdev == 0) { (*dev_proc(temp_cdev, close_device)) (temp_cdev); return_error(gs_error_VMerror); } gx_device_bbox_init(bbcdev, target, memory); gx_device_set_target((gx_device_forward *)bbcdev, temp_cdev); bbcdev->box_procs = box_procs_forward; bbcdev->box_proc_data = bdev; *pcdev = (gx_device *) bbcdev; return 0; } }
RELOC_PTRS_END /* Initialize a mask clipping device. */ int gx_mask_clip_initialize(gx_device_mask_clip * cdev, const gx_device_mask_clip * proto, const gx_bitmap * bits, gx_device * tdev, int tx, int ty, gs_memory_t *mem) { int buffer_width = bits->size.x; int buffer_height = tile_clip_buffer_size / (bits->raster + sizeof(byte *)); gx_device_init((gx_device *)cdev, (const gx_device *)proto, mem, true); cdev->width = tdev->width; cdev->height = tdev->height; cdev->color_info = tdev->color_info; gx_device_set_target((gx_device_forward *)cdev, tdev); cdev->phase.x = -tx; cdev->phase.y = -ty; if (buffer_height > bits->size.y) buffer_height = bits->size.y; gs_make_mem_mono_device(&cdev->mdev, 0, 0); for (;;) { ulong bitmap_size = max_ulong; if (buffer_height <= 0) { /* * The tile is too wide to buffer even one scan line. * We could do copy_mono in chunks, but for now, we punt. */ cdev->mdev.base = 0; return_error(gs_error_VMerror); } cdev->mdev.width = buffer_width; cdev->mdev.height = buffer_height; gdev_mem_bitmap_size(&cdev->mdev, &bitmap_size); if (bitmap_size <= tile_clip_buffer_size) break; buffer_height--; } cdev->mdev.base = cdev->buffer.bytes; return (*dev_proc(&cdev->mdev, open_device))((gx_device *)&cdev->mdev); }
/* Create an alpha compositor. */ static int c_alpha_create_default_compositor(const gs_composite_t * pcte, gx_device ** pcdev, gx_device * dev, gs_imager_state * pis, gs_memory_t * mem) { gx_device_composite_alpha *cdev; if (pacte->params.op == composite_Copy) { /* Just use the original device. */ *pcdev = dev; return 0; } cdev = gs_alloc_struct_immovable(mem, gx_device_composite_alpha, &st_device_composite_alpha, "create default alpha compositor"); *pcdev = (gx_device *)cdev; if (cdev == 0) return_error(gs_error_VMerror); gx_device_init((gx_device *)cdev, (const gx_device *)&gs_composite_alpha_device, mem, true); gx_device_copy_params((gx_device *)cdev, dev); /* * Set the color_info and depth to be compatible with the target, * but using standard chunky color storage, including alpha. ****** CURRENTLY ALWAYS USE 8-BIT COLOR ****** */ cdev->color_info.depth = (dev->color_info.num_components == 4 ? 32 /* CMYK, no alpha */ : (dev->color_info.num_components + 1) * 8); cdev->color_info.max_gray = cdev->color_info.max_color = 255; /* No halftoning will occur, but we fill these in anyway.... */ cdev->color_info.dither_grays = cdev->color_info.dither_colors = 256; /* * We could speed things up a little by tailoring the procedures in * the device to the specific num_components, but for simplicity, * we'll defer considering that until there is a demonstrated need. */ gx_device_set_target((gx_device_forward *)cdev, dev); cdev->params = pacte->params; return 0; }
/* Release a bounding box device. */ void gx_device_bbox_release(gx_device_bbox *dev) { /* Just release the reference to the target. */ gx_device_set_target((gx_device_forward *)dev, NULL); }