/* * 'escp2_print()' - Print an image to an EPSON printer. */ static int raw_print(const stp_vars_t *v, stp_image_t *image) { int model = stp_get_model_id(v); int width = stp_get_page_width(v); int height = stp_get_page_height(v); int i, j; int y; /* Looping vars */ stp_vars_t *nv = stp_vars_create_copy(v); int out_channels; unsigned short *final_out = NULL; int status = 1; int bytes_per_channel = raw_model_capabilities[model].output_bits / 8; int ink_channels = 1; int rotate_output = 0; const char *ink_type = stp_get_string_parameter(nv, "InkType"); stp_image_init(image); stp_prune_inactive_options(nv); if (!stp_verify(nv)) { stp_eprintf(nv, _("Print options not verified; cannot print.\n")); stp_vars_destroy(nv); stp_image_conclude(image); return 0; } if (width != stp_image_width(image) || height != stp_image_height(image)) { stp_eprintf(nv, _("Image dimensions must match paper dimensions")); stp_vars_destroy(nv); stp_image_conclude(image); return 0; } if (ink_type) { for (i = 0; i < ink_count; i++) if (strcmp(ink_type, inks[i].name) == 0) { stp_set_string_parameter(nv, "STPIOutputType", inks[i].output_type); ink_channels = inks[i].output_channels; rotate_output = inks[i].rotate_channels; break; } } stp_set_float_parameter(nv, "Density", 1.0); stp_set_boolean_parameter(nv, "SimpleGamma", 1); stp_channel_reset(nv); for (i = 0; i < ink_channels; i++) stp_channel_add(nv, i, 0, 1.0); if (bytes_per_channel == 1) out_channels = stp_color_init(nv, image, 256); else out_channels = stp_color_init(nv, image, 65536); if (out_channels != ink_channels && out_channels != 1 && ink_channels != 1) { stp_eprintf(nv, "Internal error! Output channels or input channels must be 1\n"); stp_vars_destroy(nv); stp_image_conclude(image); return 0; } if (out_channels != ink_channels) final_out = stp_malloc(width * ink_channels * 2); for (y = 0; y < height; y++) { unsigned short *out; unsigned short *real_out; unsigned zero_mask; if (stp_color_get_row(nv, image, y, &zero_mask)) { status = 2; break; } out = stp_channel_get_input(nv); real_out = out; if (rotate_output) { unsigned short *tmp_out = real_out; for (i = 0; i < width; i++) { unsigned short tmp = tmp_out[0]; for (j = 0; j < ink_channels - 1; j++) tmp_out[j] = tmp_out[j + 1]; tmp_out[ink_channels - 1] = tmp; tmp_out += ink_channels; } } if (out_channels != ink_channels) { real_out = final_out; if (out_channels < ink_channels) { for (i = 0; i < width; i++) { for (j = 0; j < ink_channels; j++) final_out[i * ink_channels + j] = out[i]; } } else { for (i = 0; i < width; i++) { int avg = 0; for (j = 0; j < out_channels; j++) avg += out[i * out_channels + j]; final_out[i] = avg / out_channels; } } } if (bytes_per_channel == 1) { unsigned char *char_out = (unsigned char *) real_out; for (i = 0; i < width * ink_channels; i++) char_out[i] = real_out[i] / 257; } stp_zfwrite((char *) real_out, width * ink_channels * bytes_per_channel, 1, nv); } stp_image_conclude(image); if (final_out) stp_free(final_out); stp_vars_destroy(nv); return status; }
struct stp_vars *guten_prepare_printer(const stp_printer_t *printer) { const struct stp_vars *gvars_defaults; struct stp_vars *gvars; gvars_defaults = stp_printer_get_defaults(printer); gvars = stp_vars_create_copy(gvars_defaults); stp_set_outdata(gvars, stdout); stp_set_outfunc(gvars, gfunc_print); stp_set_errdata(gvars, stderr); stp_set_errfunc(gvars, gfunc_error); stp_parameter_list_t *list = stp_get_parameter_list(gvars); size_t count = stp_parameter_list_count(list); int i; for(i=0; i<count; i++) { const stp_parameter_t *par = stp_parameter_list_param(list, i); stp_parameter_t pardesc; stp_describe_parameter(gvars, par->name, &pardesc); if(pardesc.is_mandatory) { switch(pardesc.p_type) { case STP_PARAMETER_TYPE_STRING_LIST: { stp_set_string_parameter(gvars, pardesc.name, pardesc.deflt.str); break; } case STP_PARAMETER_TYPE_INT: { stp_set_int_parameter(gvars, pardesc.name, pardesc.deflt.integer); break; } case STP_PARAMETER_TYPE_BOOLEAN: { stp_set_boolean_parameter(gvars, pardesc.name, pardesc.deflt.boolean); break; } case STP_PARAMETER_TYPE_DOUBLE: { stp_set_float_parameter(gvars, pardesc.name, pardesc.deflt.dbl); break; } case STP_PARAMETER_TYPE_CURVE: { stp_set_curve_parameter(gvars, pardesc.name, pardesc.deflt.curve); break; } case STP_PARAMETER_TYPE_FILE: { stp_set_file_parameter(gvars, pardesc.name, pardesc.deflt.str); break; } /* case STP_PARAMETER_TYPE_RAW: { stp_set_raw_parameter(gvars, pardesc.name, pardesc.deflt.str); break; } */ case STP_PARAMETER_TYPE_ARRAY: { stp_set_array_parameter(gvars, pardesc.name, pardesc.deflt.array); break; } case STP_PARAMETER_TYPE_DIMENSION: { stp_set_dimension_parameter(gvars, pardesc.name, pardesc.deflt.dimension); break; } default: {} } } } stp_parameter_list_destroy(list); return gvars; }
void guten_set_user_parameters(struct stp_vars* gvars, char **params, unsigned int params_num) { int i; for(i=0; i<params_num; i++) { stp_parameter_t pardesc; char* name = params[2*i]; char* value = params[2*i +1]; stp_describe_parameter(gvars, name, &pardesc); switch(pardesc.p_type) { case STP_PARAMETER_TYPE_STRING_LIST: { stp_set_string_parameter(gvars, pardesc.name, value); break; } case STP_PARAMETER_TYPE_INT: { int ival; if(sscanf(value, "%d", &ival)) { stp_set_int_parameter(gvars, pardesc.name, ival); } else { printf("Cannot parse gutenprint int parameter %s=%s - skipping\n", name, value); } break; } case STP_PARAMETER_TYPE_BOOLEAN: { boolean bval; boolean correct = FALSE; if(strcasecmp(value, "true") == 0 || strcasecmp(value, "yes") == 0 || strcmp(value, "1") == 0) { bval = TRUE; correct = TRUE; } else if(strcasecmp(value, "false") == 0 || strcasecmp(value, "no") == 0 || strcmp(value, "0") == 0) { bval = FALSE; correct = TRUE; } if(correct) { stp_set_boolean_parameter(gvars, pardesc.name, bval); } else { printf("Cannot parse gutenprint boolean parameter %s=%s - skipping\n", name, value); } break; } case STP_PARAMETER_TYPE_DOUBLE: { double dval; if(sscanf(value, "%lf", &dval)) { stp_set_float_parameter(gvars, pardesc.name, dval); } else { printf("Cannot parse gutenprint double parameter %s=%s - skipping\n", name, value); } break; } case STP_PARAMETER_TYPE_CURVE: { printf("Gutenprint curve parameter %s - skipping, freel free to write a curve parser for this tool\n", name); break; } case STP_PARAMETER_TYPE_FILE: { stp_set_file_parameter(gvars, pardesc.name, value); break; } case STP_PARAMETER_TYPE_RAW: { printf("Gutenprint raw parameter %s - skipping, freel free to write an implementation to support raw parameter in this tool\n", name); break; } case STP_PARAMETER_TYPE_ARRAY: { printf("Gutenprint array parameter %s - skipping, freel free to write an implementation to support arra parameter in this tool\n", name); break; } case STP_PARAMETER_TYPE_DIMENSION: { int ival; if(sscanf(value, "%d", &ival)) { stp_set_dimension_parameter(gvars, pardesc.name, ival); } else { printf("Cannot parse gutenprint dimension parameter %s=%s - skipping\n", name, value); } break; } default: { printf("Gutenprint parameter %s has unknown type - skippig\n", name); } } } }
static int do_print(void) { int status = 0; stp_vars_t *v; const stp_printer_t *the_printer; int left, right, top, bottom; int x, y; int width, height; int retval; stp_parameter_list_t params; int count; int i; char tmp[32]; initialize_global_parameters(); global_vars = stp_vars_create(); stp_set_outfunc(global_vars, writefunc); stp_set_errfunc(global_vars, writefunc); stp_set_outdata(global_vars, stdout); stp_set_errdata(global_vars, stderr); setlocale(LC_ALL, "C"); retval = yyparse(); setlocale(LC_ALL, ""); if (retval) return retval + 1; if (!global_did_something) return 1; v = stp_vars_create(); the_printer = stp_get_printer_by_driver(global_printer); if (!the_printer) { int j; fprintf(stderr, "Unknown printer %s\nValid printers are:\n", global_printer); for (j = 0; j < stp_printer_model_count(); j++) { the_printer = stp_get_printer_by_index(j); fprintf(stderr, "%-16s%s\n", stp_printer_get_driver(the_printer), stp_printer_get_long_name(the_printer)); } return 2; } bytes_written = 0; if (global_output) { if (strcmp(global_output, "-") == 0) output = stdout; else if (strcmp(global_output, "") == 0) output = NULL; else if (global_output[0] == '|') { close_output(); write_to_process = 1; output = popen(global_output+1, "w"); if (! output) { fprintf(stderr, "popen '%s' failed: %s\n", global_output, strerror(errno)); output = NULL; } free(global_output); global_output = NULL; } else { close_output(); output = fopen(global_output, "wb"); if (! output) { fprintf(stderr, "Create %s failed: %s\n", global_output, strerror(errno)); output = NULL; } free(global_output); global_output = NULL; } } stp_set_printer_defaults(v, the_printer); stp_set_outfunc(v, writefunc); stp_set_errfunc(v, writefunc); stp_set_outdata(v, output); stp_set_errdata(v, stderr); stp_set_string_parameter(v, "InputImageType", global_image_type); sprintf(tmp, "%d", global_bit_depth); stp_set_string_parameter(v, "ChannelBitDepth", tmp); if (strcmp(global_image_type, "Raw") == 0) { sprintf(tmp, "%d", global_channel_depth); stp_set_string_parameter(v, "RawChannels", tmp); } stp_set_float_parameter(v, "Density", global_density); stp_set_string_parameter(v, "Quality", "None"); stp_set_string_parameter(v, "ImageType", "None"); params = stp_get_parameter_list(v); count = stp_parameter_list_count(params); for (i = 0; i < count; i++) { const stp_parameter_t *p = stp_parameter_list_param(params, i); if (p->p_type == STP_PARAMETER_TYPE_STRING_LIST) { const char *val = stp_get_string_parameter(global_vars, p->name); if (val && strlen(val) > 0) { stp_set_string_parameter(v, p->name, val); } } else if (p->p_type == STP_PARAMETER_TYPE_INT && stp_check_int_parameter(global_vars, p->name, STP_PARAMETER_ACTIVE)) { int val = stp_get_int_parameter(global_vars, p->name); stp_set_int_parameter(v, p->name, val); } else if (p->p_type == STP_PARAMETER_TYPE_BOOLEAN && stp_check_boolean_parameter(global_vars, p->name, STP_PARAMETER_ACTIVE)) { int val = stp_get_boolean_parameter(global_vars, p->name); stp_set_boolean_parameter(v, p->name, val); } else if (p->p_type == STP_PARAMETER_TYPE_CURVE && stp_check_curve_parameter(global_vars, p->name, STP_PARAMETER_ACTIVE)) { const stp_curve_t *val = stp_get_curve_parameter(global_vars, p->name); stp_set_curve_parameter(v, p->name, val); } else if (p->p_type == STP_PARAMETER_TYPE_DOUBLE && stp_check_float_parameter(global_vars, p->name, STP_PARAMETER_ACTIVE)) { double val = stp_get_float_parameter(global_vars, p->name); stp_set_float_parameter(v, p->name, val); } } stp_set_page_width(v, stp_get_page_width(global_vars)); stp_set_page_height(v, stp_get_page_height(global_vars)); stp_parameter_list_destroy(params); if (stp_check_string_parameter(v, "PageSize", STP_PARAMETER_ACTIVE) && !strcmp(stp_get_string_parameter(v, "PageSize"), "Auto")) { stp_parameter_t desc; stp_describe_parameter(v, "PageSize", &desc); if (desc.p_type == STP_PARAMETER_TYPE_STRING_LIST) stp_set_string_parameter(v, "PageSize", desc.deflt.str); stp_parameter_description_destroy(&desc); } stp_set_printer_defaults_soft(v, the_printer); stp_get_imageable_area(v, &left, &right, &bottom, &top); stp_describe_resolution(v, &x, &y); if (x < 0) x = 300; if (y < 0) y = 300; width = right - left; height = bottom - top; switch (global_size_mode) { case SIZE_PT: top += (int) (global_xtop + .5); left += (int) (global_xleft + .5); width = (int) (global_hsize + .5); height = (int) (global_vsize + .5); break; case SIZE_IN: top += (int) ((global_xtop * 72) + .5); left += (int) ((global_xleft * 72) + .5); width = (int) ((global_hsize * 72) + .5); height = (int) ((global_vsize * 72) + .5); break; case SIZE_MM: top += (int) ((global_xtop * 72 / 25.4) + .5); left += (int) ((global_xleft * 72 / 25.4) + .5); width = (int) ((global_hsize * 72 / 25.4) + .5); height = (int) ((global_vsize * 72 / 25.4) + .5); break; case SIZE_RELATIVE: default: top += height * global_xtop; left += width * global_xleft; width *= global_hsize; height *= global_vsize; break; } stp_set_width(v, width); stp_set_height(v, height); #if 0 width = (width / global_steps) * global_steps; height = (height / global_n_testpatterns) * global_n_testpatterns; #endif if (global_steps > width) global_steps = width; global_printer_width = width * x / 72; global_printer_height = height * y / 72; global_band_height = global_printer_height / global_n_testpatterns; if (global_band_height == 0) global_band_height = 1; stp_set_left(v, left); stp_set_top(v, top); stp_merge_printvars(v, stp_printer_get_defaults(the_printer)); if (stp_verify(v)) { bytes_written = 0; if (start_job) { stp_start_job(v, &theImage); start_job = 0; } if (stp_print(v, &theImage) != 1) { if (!global_quiet) fputs("FAILED", stderr); failures++; status = 2; if (global_halt_on_error) return status; } else if (bytes_written == 0) { if (!global_quiet) fputs("FAILED: No output", stderr); failures++; status = 2; if (global_halt_on_error) return status; } else passes++; if (end_job) { stp_end_job(v, &theImage); end_job = 0; } } else { if (! global_fail_verify_ok) { if (!global_quiet) fputs("FAILED", stderr); failures++; status = 2; if (global_halt_on_error) return status; } else { if (!global_quiet) fputs("(skipped)", stderr); skipped++; } } if (!global_quiet) fputc('\n', stderr); stp_vars_destroy(v); stp_free(static_testpatterns); static_testpatterns = NULL; return status; }