static int bbox_begin_typed_image(gx_device * dev, const gs_imager_state * pis, const gs_matrix * pmat, const gs_image_common_t * pic, const gs_int_rect * prect, const gx_drawing_color * pdcolor, const gx_clip_path * pcpath, gs_memory_t * memory, gx_image_enum_common_t ** pinfo) { bbox_image_enum *pbe; int code = bbox_image_begin(pis, pmat, pic, prect, pcpath, memory, &pbe); if (code < 0) return code; /* * If there is no target, we still have to call default_begin_image * to get the correct num_planes and plane_depths. */ { gx_device_bbox *const bdev = (gx_device_bbox *) dev; gx_device *tdev = bdev->target; dev_proc_begin_typed_image((*begin_typed_image)); byte wanted[GS_IMAGE_MAX_COMPONENTS]; if (tdev == 0) { tdev = dev; begin_typed_image = gx_default_begin_typed_image; } else { begin_typed_image = dev_proc(tdev, begin_typed_image); } code = (*begin_typed_image) (tdev, pis, pmat, pic, prect, pdcolor, pcpath, memory, &pbe->target_info); if (code) { bbox_image_end_image((gx_image_enum_common_t *)pbe, false); return code; } /* * We fill in num_planes and plane_depths later. format is * irrelevant. NOTE: we assume that if begin_typed_image returned * 0, the image is a data image. */ code = gx_image_enum_common_init((gx_image_enum_common_t *) pbe, (const gs_data_image_t *)pic, &bbox_image_enum_procs, dev, 0, gs_image_format_chunky); if (code < 0) return code; bbox_image_copy_target_info(pbe); pbe->params_are_const = gx_image_planes_wanted(pbe->target_info, wanted); } *pinfo = (gx_image_enum_common_t *) pbe; return 0; }
/* Initialize for enumerating an image. */ int gdev_vector_begin_image(gx_device_vector * vdev, const gs_imager_state * pis, const gs_image_t * pim, gs_image_format_t format, const gs_int_rect * prect, const gx_drawing_color * pdcolor, const gx_clip_path * pcpath, gs_memory_t * mem, const gx_image_enum_procs_t * pprocs, gdev_vector_image_enum_t * pie) { const gs_color_space *pcs = pim->ColorSpace; int num_components; int bits_per_pixel; int code; if (pim->ImageMask) bits_per_pixel = num_components = 1; else num_components = gs_color_space_num_components(pcs), bits_per_pixel = pim->BitsPerComponent; code = gx_image_enum_common_init((gx_image_enum_common_t *) pie, (const gs_data_image_t *)pim, pprocs, (gx_device *) vdev, num_components, format); if (code < 0) return code; pie->bits_per_pixel = bits_per_pixel * num_components / pie->num_planes; pie->default_info = 0; pie->bbox_info = 0; if ((code = gdev_vector_update_log_op(vdev, pis->log_op)) < 0 || (code = gdev_vector_update_clip_path(vdev, pcpath)) < 0 || ((pim->ImageMask || (pim->CombineWithColor && rop3_uses_T(pis->log_op))) && (code = gdev_vector_update_fill_color(vdev, pis, pdcolor)) < 0) || (vdev->bbox_device && (code = (*dev_proc(vdev->bbox_device, begin_image)) ((gx_device *) vdev->bbox_device, pis, pim, format, prect, pdcolor, pcpath, mem, &pie->bbox_info)) < 0) ) return code; pie->memory = mem; if (prect) pie->width = prect->q.x - prect->p.x, pie->height = prect->q.y - prect->p.y; else pie->width = pim->Width, pie->height = pim->Height; pie->bits_per_row = pie->width * pie->bits_per_pixel; pie->y = 0; return 0; }
int gx_begin_image3_generic(gx_device * dev, const gs_imager_state *pis, const gs_matrix *pmat, const gs_image_common_t *pic, const gs_int_rect *prect, const gx_drawing_color *pdcolor, const gx_clip_path *pcpath, gs_memory_t *mem, image3_make_mid_proc_t make_mid, image3_make_mcde_proc_t make_mcde, gx_image_enum_common_t **pinfo) { const gs_image3_t *pim = (const gs_image3_t *)pic; gx_image3_enum_t *penum; gs_int_rect mask_rect, data_rect; gx_device *mdev = 0; gx_device *pcdev = 0; gs_image_t i_pixel, i_mask; gs_matrix mi_pixel, mi_mask, mat; gs_rect mrect; gs_int_point origin; int code; /* Validate the parameters. */ if (pim->Height <= 0 || pim->MaskDict.Height <= 0) return_error(gs_error_rangecheck); switch (pim->InterleaveType) { default: return_error(gs_error_rangecheck); case interleave_chunky: if (pim->MaskDict.Width != pim->Width || pim->MaskDict.Height != pim->Height || pim->MaskDict.BitsPerComponent != pim->BitsPerComponent || pim->format != gs_image_format_chunky ) return_error(gs_error_rangecheck); break; case interleave_scan_lines: if (pim->MaskDict.Height % pim->Height != 0 && pim->Height % pim->MaskDict.Height != 0 ) return_error(gs_error_rangecheck); /* falls through */ case interleave_separate_source: if (pim->MaskDict.BitsPerComponent != 1) return_error(gs_error_rangecheck); } if (!check_image3_extent(pim->ImageMatrix.xx, pim->MaskDict.ImageMatrix.xx) || !check_image3_extent(pim->ImageMatrix.xy, pim->MaskDict.ImageMatrix.xy) || !check_image3_extent(pim->ImageMatrix.yx, pim->MaskDict.ImageMatrix.yx) || !check_image3_extent(pim->ImageMatrix.yy, pim->MaskDict.ImageMatrix.yy) ) return_error(gs_error_rangecheck); if ((code = gs_matrix_invert(&pim->ImageMatrix, &mi_pixel)) < 0 || (code = gs_matrix_invert(&pim->MaskDict.ImageMatrix, &mi_mask)) < 0 ) return code; if (fabs(mi_pixel.tx - mi_mask.tx) >= 0.5 || fabs(mi_pixel.ty - mi_mask.ty) >= 0.5 ) return_error(gs_error_rangecheck); #ifdef DEBUG { /* Although the PLRM says that the Mask and Image *must* be the same size, */ /* Adobe CPSI (and other RIPS) ignore this and process anyway. Note that we */ /* are not compatible if the Mask Height than the Data (pixel) Height. CPSI */ /* de-interleaves the mask from the data image and stops at the Mask Height */ /* Problem detected with Genoa 468-03 (part of file 468-01.ps) */ /***** fixme: When Data Image Height > Mask Height *****/ gs_point ep, em; if ((code = gs_point_transform(pim->Width, pim->Height, &mi_pixel, &ep)) < 0 || (code = gs_point_transform(pim->MaskDict.Width, pim->MaskDict.Height, &mi_mask, &em)) < 0 ) return code; if (fabs(ep.x - em.x) >= 0.5 || fabs(ep.y - em.y) >= 0.5) code = gs_error_rangecheck; /* leave the check in for debug breakpoint */ } #endif /* DEBUG */ penum = gs_alloc_struct(mem, gx_image3_enum_t, &st_image3_enum, "gx_begin_image3"); if (penum == 0) return_error(gs_error_VMerror); penum->num_components = gs_color_space_num_components(pim->ColorSpace); gx_image_enum_common_init((gx_image_enum_common_t *) penum, (const gs_data_image_t *)pim, &image3_enum_procs, dev, 1 + penum->num_components, pim->format); /* Initialize pointers now in case we bail out. */ penum->mask_data = 0; penum->pixel_data = 0; if (prect) { long lmw = pim->MaskDict.Width, lmh = pim->MaskDict.Height; data_rect = *prect; mask_rect.p.x = (int)(data_rect.p.x * lmw / pim->Width); mask_rect.p.y = (int)(data_rect.p.y * lmh / pim->Height); mask_rect.q.x = (int)((data_rect.q.x + pim->Width - 1) * lmw / pim->Width); mask_rect.q.y = (int)((data_rect.q.y + pim->Height - 1) * lmh / pim->Height); } else { mask_rect.p.x = mask_rect.p.y = 0; mask_rect.q.x = pim->MaskDict.Width; mask_rect.q.y = pim->MaskDict.Height; data_rect.p.x = data_rect.p.y = 0; data_rect.q.x = pim->Width; data_rect.q.y = pim->Height; } penum->mask_width = mask_rect.q.x - mask_rect.p.x; penum->mask_height = mask_rect.q.y - mask_rect.p.y; penum->mask_full_height = pim->MaskDict.Height; penum->mask_y = 0; penum->mask_skip = 0; penum->pixel_width = data_rect.q.x - data_rect.p.x; penum->pixel_height = data_rect.q.y - data_rect.p.y; penum->pixel_full_height = pim->Height; penum->pixel_y = 0; penum->mask_info = 0; penum->pixel_info = 0; if (pim->InterleaveType == interleave_chunky) { /* Allocate row buffers for the mask and pixel data. */ penum->pixel_data = gs_alloc_bytes(mem, (penum->pixel_width * pim->BitsPerComponent * penum->num_components + 7) >> 3, "gx_begin_image3(pixel_data)"); penum->mask_data = gs_alloc_bytes(mem, (penum->mask_width + 7) >> 3, "gx_begin_image3(mask_data)"); if (penum->pixel_data == 0 || penum->mask_data == 0) { code = gs_note_error(gs_error_VMerror); goto out1; } }