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;
}
static gboolean stpui_slider_update(stpui_Slider *c)
{
stp_parameter_t desc;
gboolean result;
gboolean enabled=TRUE;
if(c->checkbutton)
enabled=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(c->checkbutton));
stp_describe_parameter(c->vars,c->optionname,&desc);
if(desc.is_active)
{
switch(desc.p_type)
{
case STP_PARAMETER_TYPE_DOUBLE:
{
double min,max,current;
min=desc.bounds.dbl.lower;
max=desc.bounds.dbl.upper;
current=stp_get_float_parameter(c->vars,c->optionname);
gtk_range_set_range(GTK_RANGE(c->scale),min,max);
gtk_range_set_value(GTK_RANGE(c->scale),current);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(c->spin),min,max);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(c->spin),current);
break;
}
case STP_PARAMETER_TYPE_INT:
{
int min,max,current;
min=desc.bounds.integer.lower;
max=desc.bounds.integer.upper;
current=stp_get_int_parameter(c->vars,c->optionname);
gtk_range_set_range(GTK_RANGE(c->scale),min,max);
gtk_range_set_value(GTK_RANGE(c->scale),current);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(c->spin),min,max);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(c->spin),current);
break;
}
case STP_PARAMETER_TYPE_DIMENSION:
{
int min,max,current;
min=desc.bounds.integer.lower;
max=desc.bounds.integer.upper;
current=stp_get_dimension_parameter(c->vars,c->optionname);
// Convert to correct unit here...
gtk_range_set_range(GTK_RANGE(c->scale),min,max);
gtk_range_set_value(GTK_RANGE(c->scale),current);
dimension_set_range_pt(DIMENSION(c->spin),min,max);
dimension_set_pt(DIMENSION(c->spin),current);
break;
}
default:
break;
}
}
if(desc.is_active)
{
gtk_widget_show(GTK_WIDGET(c));
if(c->checkbutton)
gtk_widget_show(GTK_WIDGET(c->checkbutton));
if(c->label)
gtk_widget_show(GTK_WIDGET(c->label));
}
else
{
gtk_widget_hide(GTK_WIDGET(c));
if(c->checkbutton)
gtk_widget_hide(GTK_WIDGET(c->checkbutton));
if(c->label)
gtk_widget_hide(GTK_WIDGET(c->label));
}
gtk_widget_set_sensitive(GTK_WIDGET(c->scale),desc.is_active);
gtk_widget_set_sensitive(GTK_WIDGET(c->spin),desc.is_active & enabled);
if(c->checkbutton)
gtk_widget_set_sensitive(GTK_WIDGET(c->checkbutton),desc.is_active);
result=desc.is_active;
return(result);
}
void
stp_channel_initialize(stp_vars_t *v, stp_image_t *image,
int input_channel_count)
{
stpi_channel_group_t *cg = get_channel_group(v);
int width = stp_image_width(image);
int curve_count = 0;
int i, j, k;
if (!cg)
{
cg = stp_zalloc(sizeof(stpi_channel_group_t));
cg->black_channel = -1;
stp_allocate_component_data(v, "Channel", NULL, stpi_channel_free, cg);
}
if (cg->initialized)
return;
cg->initialized = 1;
cg->max_density = 0;
if (cg->black_channel < -1 || cg->black_channel >= cg->channel_count)
cg->black_channel = -1;
for (i = 0; i < cg->channel_count; i++)
{
stpi_channel_t *c = &(cg->c[i]);
int sc = c->subchannel_count;
if (c->curve)
{
curve_count++;
stp_curve_resample(c->curve, 4096);
c->hue_map = stp_curve_get_data(c->curve, &(c->h_count));
cg->curve_count++;
}
if (sc > 1)
{
int val = 0;
int next_breakpoint;
c->lut = stp_zalloc(sizeof(unsigned short) * sc * 65536);
next_breakpoint = c->sc[0].value * 65535 * c->sc[0].cutoff;
if (next_breakpoint > 65535)
next_breakpoint = 65535;
while (val <= next_breakpoint)
{
int value = (int) ((double) val / c->sc[0].value);
c->lut[val * sc + sc - 1] = value;
val++;
}
for (k = 0; k < sc - 1; k++)
{
double this_val = c->sc[k].value;
double next_val = c->sc[k + 1].value;
double this_cutoff = c->sc[k].cutoff;
double next_cutoff = c->sc[k + 1].cutoff;
int range;
int base = val;
double cutoff = sqrt(this_cutoff * next_cutoff);
next_breakpoint = next_val * 65535 * cutoff;
if (next_breakpoint > 65535)
next_breakpoint = 65535;
range = next_breakpoint - val;
while (val <= next_breakpoint)
{
double where = ((double) val - base) / (double) range;
double lower_val = base * (1.0 - where);
double lower_amount = lower_val / this_val;
double upper_amount = (val - lower_val) / next_val;
if (lower_amount > 65535.0)
lower_amount = 65535.0;
c->lut[val * sc + sc - k - 2] = upper_amount;
c->lut[val * sc + sc - k - 1] = lower_amount;
val++;
}
}
while (val <= 65535)
{
c->lut[val * sc] = val / c->sc[sc - 1].value;
val++;
}
}
if (cg->gloss_channel != i && c->subchannel_count > 0)
cg->aux_output_channels++;
cg->total_channels += c->subchannel_count;
for (j = 0; j < c->subchannel_count; j++)
cg->max_density += c->sc[j].s_density;
}
if (cg->gloss_channel >= 0)
{
for (i = 0; i < cg->channel_count; i++)
{
if (cg->gloss_channel == i)
break;
cg->gloss_physical_channel += cg->c[i].subchannel_count;
}
}
cg->input_channels = input_channel_count;
cg->width = width;
cg->alloc_data_1 =
stp_malloc(sizeof(unsigned short) * cg->total_channels * width);
cg->output_data = cg->alloc_data_1;
if (curve_count == 0)
{
cg->gcr_channels = cg->input_channels;
if (input_needs_splitting(v))
{
cg->alloc_data_2 =
stp_malloc(sizeof(unsigned short) * cg->input_channels * width);
cg->input_data = cg->alloc_data_2;
cg->split_input = cg->input_data;
cg->gcr_data = cg->split_input;
}
else if (cg->gloss_channel != -1)
{
cg->alloc_data_2 =
stp_malloc(sizeof(unsigned short) * cg->input_channels * width);
cg->input_data = cg->alloc_data_2;
cg->gcr_data = cg->output_data;
cg->gcr_channels = cg->total_channels;
}
else
{
cg->input_data = cg->output_data;
cg->gcr_data = cg->output_data;
}
cg->aux_output_channels = cg->gcr_channels;
}
else
{
cg->alloc_data_2 =
stp_malloc(sizeof(unsigned short) * cg->input_channels * width);
cg->input_data = cg->alloc_data_2;
if (input_needs_splitting(v))
{
cg->alloc_data_3 =
stp_malloc(sizeof(unsigned short) * cg->aux_output_channels * width);
cg->multi_tmp = cg->alloc_data_3;
cg->split_input = cg->multi_tmp;
cg->gcr_data = cg->split_input;
}
else
{
cg->multi_tmp = cg->alloc_data_1;
cg->gcr_data = cg->output_data;
cg->aux_output_channels = cg->total_channels;
}
cg->gcr_channels = cg->aux_output_channels;
}
cg->cyan_balance = stp_get_float_parameter(v, "CyanBalance");
cg->magenta_balance = stp_get_float_parameter(v, "MagentaBalance");
cg->yellow_balance = stp_get_float_parameter(v, "YellowBalance");
stp_dprintf(STP_DBG_INK, v, "stp_channel_initialize:\n");
stp_dprintf(STP_DBG_INK, v, " channel_count %d\n", cg->channel_count);
stp_dprintf(STP_DBG_INK, v, " total_channels %d\n", cg->total_channels);
stp_dprintf(STP_DBG_INK, v, " input_channels %d\n", cg->input_channels);
stp_dprintf(STP_DBG_INK, v, " aux_channels %d\n", cg->aux_output_channels);
stp_dprintf(STP_DBG_INK, v, " gcr_channels %d\n", cg->gcr_channels);
stp_dprintf(STP_DBG_INK, v, " width %ld\n", (long)cg->width);
stp_dprintf(STP_DBG_INK, v, " ink_limit %d\n", cg->ink_limit);
stp_dprintf(STP_DBG_INK, v, " gloss_limit %d\n", cg->gloss_limit);
stp_dprintf(STP_DBG_INK, v, " max_density %d\n", cg->max_density);
stp_dprintf(STP_DBG_INK, v, " curve_count %d\n", cg->curve_count);
stp_dprintf(STP_DBG_INK, v, " black_channel %d\n", cg->black_channel);
stp_dprintf(STP_DBG_INK, v, " gloss_channel %d\n", cg->gloss_channel);
stp_dprintf(STP_DBG_INK, v, " gloss_physical %d\n", cg->gloss_physical_channel);
stp_dprintf(STP_DBG_INK, v, " cyan %.3f\n", cg->cyan_balance);
stp_dprintf(STP_DBG_INK, v, " magenta %.3f\n", cg->magenta_balance);
stp_dprintf(STP_DBG_INK, v, " yellow %.3f\n", cg->yellow_balance);
stp_dprintf(STP_DBG_INK, v, " input_data %p\n",
(void *) cg->input_data);
stp_dprintf(STP_DBG_INK, v, " multi_tmp %p\n",
(void *) cg->multi_tmp);
stp_dprintf(STP_DBG_INK, v, " split_input %p\n",
(void *) cg->split_input);
stp_dprintf(STP_DBG_INK, v, " output_data %p\n",
(void *) cg->output_data);
stp_dprintf(STP_DBG_INK, v, " gcr_data %p\n",
(void *) cg->gcr_data);
stp_dprintf(STP_DBG_INK, v, " alloc_data_1 %p\n",
(void *) cg->alloc_data_1);
stp_dprintf(STP_DBG_INK, v, " alloc_data_2 %p\n",
(void *) cg->alloc_data_2);
stp_dprintf(STP_DBG_INK, v, " alloc_data_3 %p\n",
(void *) cg->alloc_data_3);
stp_dprintf(STP_DBG_INK, v, " gcr_curve %p\n",
(void *) cg->gcr_curve);
for (i = 0; i < cg->channel_count; i++)
{
stp_dprintf(STP_DBG_INK, v, " Channel %d:\n", i);
for (j = 0; j < cg->c[i].subchannel_count; j++)
{
stpi_subchannel_t *sch = &(cg->c[i].sc[j]);
stp_dprintf(STP_DBG_INK, v, " Subchannel %d:\n", j);
stp_dprintf(STP_DBG_INK, v, " value %.3f:\n", sch->value);
stp_dprintf(STP_DBG_INK, v, " lower %.3f:\n", sch->lower);
stp_dprintf(STP_DBG_INK, v, " upper %.3f:\n", sch->upper);
stp_dprintf(STP_DBG_INK, v, " cutoff %.3f:\n", sch->cutoff);
stp_dprintf(STP_DBG_INK, v, " density %d:\n", sch->s_density);
}
}
}
