void save_by_conns(vector<real_t> &container, const string &nam) {
LOOP(const WC_CONN_PAIR & p, connections) {
VDI begin = container.begin() + p.second.get<2>();
VDI end = container.begin() + p.second.get<3>();
if (begin != end) {
save_range(make_pair(begin, end), p.second.get<1>() + "_" + nam);
}
}
bool http_download::get(acl_int64 range_from /* = -1 */, acl_int64 range_to /* = -1 */,
const char* body /* = NULL */, size_t len /* = 0 */)
{
if (req_ == NULL)
{
logger_error("no valid url");
return false;
}
else if (range_from >= 0)
return save_range(body, len, range_from, range_to);
else
return save_total(body, len);
}
static void
save_set_all(FILE *fp)
{
struct text_label *this_label;
struct arrow_def *this_arrow;
struct linestyle_def *this_linestyle;
struct arrowstyle_def *this_arrowstyle;
legend_key *key = &keyT;
int axis;
/* opinions are split as to whether we save term and outfile
* as a compromise, we output them as comments !
*/
if (term)
fprintf(fp, "# set terminal %s %s\n", term->name, term_options);
else
fputs("# set terminal unknown\n", fp);
if (outstr)
fprintf(fp, "# set output '%s'\n", outstr);
else
fputs("# set output\n", fp);
fprintf(fp, "\
%sset clip points\n\
%sset clip one\n\
%sset clip two\n\
set bar %f %s\n",
(clip_points) ? "" : "un",
(clip_lines1) ? "" : "un",
(clip_lines2) ? "" : "un",
bar_size, (bar_layer == LAYER_BACK) ? "back" : "front");
if (draw_border) {
fprintf(fp, "set border %d %s", draw_border, border_layer == 0 ? "back" : "front");
save_linetype(fp, &border_lp, FALSE);
fprintf(fp, "\n");
} else
fputs("unset border\n", fp);
for (axis = FIRST_AXES; axis < LAST_REAL_AXIS; axis++) {
if (axis == SECOND_Z_AXIS) continue;
if (strlen(axis_array[axis].timefmt))
fprintf(fp, "set timefmt %s \"%s\"\n", axis_defaults[axis].name,
conv_text(axis_array[axis].timefmt));
if (axis == COLOR_AXIS) continue;
fprintf(fp, "set %sdata %s\n", axis_defaults[axis].name,
axis_array[axis].datatype == DT_TIMEDATE ? "time" :
"");
}
if (boxwidth < 0.0)
fputs("set boxwidth\n", fp);
else
fprintf(fp, "set boxwidth %g %s\n", boxwidth,
(boxwidth_is_absolute) ? "absolute" : "relative");
fprintf(fp, "set style fill ");
save_fillstyle(fp, &default_fillstyle);
#ifdef EAM_OBJECTS
/* Default rectangle style */
fprintf(fp, "set style rectangle %s fc ",
default_rectangle.layer > 0 ? "front" :
default_rectangle.layer < 0 ? "behind" : "back");
if (default_rectangle.lp_properties.use_palette)
save_pm3dcolor(fp, &default_rectangle.lp_properties.pm3d_color);
else
fprintf(fp, "lt %d",default_rectangle.lp_properties.l_type+1);
fprintf(fp, " fillstyle ");
save_fillstyle(fp, &default_rectangle.fillstyle);
/* Default circle properties */
fprintf(fp, "set style circle radius ");
save_position(fp, &default_circle.o.circle.extent, FALSE);
fputs(" \n", fp);
/* Default ellipse properties */
fprintf(fp, "set style ellipse size ");
save_position(fp, &default_ellipse.o.ellipse.extent, FALSE);
fprintf(fp, " angle %g ", default_ellipse.o.ellipse.orientation);
fputs("units ", fp);
switch (default_ellipse.o.ellipse.type) {
case ELLIPSEAXES_XY:
fputs("xy\n", fp);
break;
case ELLIPSEAXES_XX:
fputs("xx\n", fp);
break;
case ELLIPSEAXES_YY:
fputs("yy\n", fp);
break;
}
#endif
if (dgrid3d) {
if( dgrid3d_mode == DGRID3D_QNORM ) {
fprintf(fp, "set dgrid3d %d,%d, %d\n",
dgrid3d_row_fineness,
dgrid3d_col_fineness,
dgrid3d_norm_value);
} else if( dgrid3d_mode == DGRID3D_SPLINES ) {
fprintf(fp, "set dgrid3d %d,%d splines\n",
dgrid3d_row_fineness, dgrid3d_col_fineness );
} else {
fprintf(fp, "set dgrid3d %d,%d %s%s %f,%f\n",
dgrid3d_row_fineness,
dgrid3d_col_fineness,
reverse_table_lookup(dgrid3d_mode_tbl, dgrid3d_mode),
dgrid3d_kdensity ? " kdensity2d" : "",
dgrid3d_x_scale,
dgrid3d_y_scale );
}
}
fprintf(fp, "set dummy %s,%s\n", set_dummy_var[0], set_dummy_var[1]);
#define SAVE_FORMAT(axis) \
fprintf(fp, "set format %s \"%s\"\n", axis_defaults[axis].name, \
conv_text(axis_array[axis].formatstring));
SAVE_FORMAT(FIRST_X_AXIS );
SAVE_FORMAT(FIRST_Y_AXIS );
SAVE_FORMAT(SECOND_X_AXIS);
SAVE_FORMAT(SECOND_Y_AXIS);
SAVE_FORMAT(FIRST_Z_AXIS );
SAVE_FORMAT(COLOR_AXIS );
SAVE_FORMAT(POLAR_AXIS );
#undef SAVE_FORMAT
fprintf(fp, "set angles %s\n",
(ang2rad == 1.0) ? "radians" : "degrees");
/* Grid back/front controls tics also. Make sure it is saved */
if (grid_layer >= 0)
fprintf(fp,"set tics %s\n", grid_layer == 0 ? "back" : "front");
if (! some_grid_selected())
fputs("unset grid\n", fp);
else {
if (polar_grid_angle) /* set angle already output */
fprintf(fp, "set grid polar %f\n", polar_grid_angle / ang2rad);
else
fputs("set grid nopolar\n", fp);
#define SAVE_GRID(axis) \
fprintf(fp, " %s%stics %sm%stics", \
axis_array[axis].gridmajor ? "" : "no", \
axis_defaults[axis].name, \
axis_array[axis].gridminor ? "" : "no", \
axis_defaults[axis].name);
fputs("set grid", fp);
SAVE_GRID(FIRST_X_AXIS);
SAVE_GRID(FIRST_Y_AXIS);
SAVE_GRID(FIRST_Z_AXIS);
fputs(" \\\n", fp);
SAVE_GRID(SECOND_X_AXIS);
SAVE_GRID(SECOND_Y_AXIS);
SAVE_GRID(COLOR_AXIS);
fputs("\n", fp);
#undef SAVE_GRID
fprintf(fp, "set grid %s ", (grid_layer==-1) ? "layerdefault" : ((grid_layer==0) ? "back" : "front"));
save_linetype(fp, &grid_lp, FALSE);
fprintf(fp, ", ");
save_linetype(fp, &mgrid_lp, FALSE);
fputc('\n', fp);
}
fprintf(fp, "%sset raxis\n", raxis ? "" : "un");
fprintf(fp, "set key title \"%s\"", conv_text(key->title));
if (key->font)
fprintf(fp, " font \"%s\"", key->font);
if (key->textcolor.type != TC_LT || key->textcolor.lt != LT_BLACK)
save_textcolor(fp, &key->textcolor);
fputs("\n", fp);
fputs("set key ", fp);
switch (key->region) {
case GPKEY_AUTO_INTERIOR_LRTBC:
fputs("inside", fp);
break;
case GPKEY_AUTO_EXTERIOR_LRTBC:
fputs("outside", fp);
break;
case GPKEY_AUTO_EXTERIOR_MARGIN:
switch (key->margin) {
case GPKEY_TMARGIN:
fputs("tmargin", fp);
break;
case GPKEY_BMARGIN:
fputs("bmargin", fp);
break;
case GPKEY_LMARGIN:
fputs("lmargin", fp);
break;
case GPKEY_RMARGIN:
fputs("rmargin", fp);
break;
}
break;
case GPKEY_USER_PLACEMENT:
fputs("at ", fp);
save_position(fp, &key->user_pos, FALSE);
break;
}
if (!(key->region == GPKEY_AUTO_EXTERIOR_MARGIN
&& (key->margin == GPKEY_LMARGIN || key->margin == GPKEY_RMARGIN))) {
switch (key->hpos) {
case RIGHT:
fputs(" right", fp);
break;
case LEFT:
fputs(" left", fp);
break;
case CENTRE:
fputs(" center", fp);
break;
}
}
if (!(key->region == GPKEY_AUTO_EXTERIOR_MARGIN
&& (key->margin == GPKEY_TMARGIN || key->margin == GPKEY_BMARGIN))) {
switch (key->vpos) {
case JUST_TOP:
fputs(" top", fp);
break;
case JUST_BOT:
fputs(" bottom", fp);
break;
case JUST_CENTRE:
fputs(" center", fp);
break;
}
}
fprintf(fp, " %s %s %sreverse %senhanced %s ",
key->stack_dir == GPKEY_VERTICAL ? "vertical" : "horizontal",
key->just == GPKEY_LEFT ? "Left" : "Right",
key->reverse ? "" : "no",
key->enhanced ? "" : "no",
key->auto_titles == COLUMNHEAD_KEYTITLES ? "autotitles columnhead"
: key->auto_titles == FILENAME_KEYTITLES ? "autotitles"
: "noautotitles" );
if (key->box.l_type > LT_NODRAW) {
fputs("box", fp);
save_linetype(fp, &(key->box), FALSE);
} else
fputs("nobox", fp);
/* Put less common options on separate lines */
fprintf(fp, "\nset key %sinvert samplen %g spacing %g width %g height %g ",
key->invert ? "" : "no",
key->swidth, key->vert_factor, key->width_fix, key->height_fix);
fprintf(fp, "\nset key maxcolumns %d maxrows %d",key->maxcols,key->maxrows);
fputc('\n', fp);
fprintf(fp, "set key %sopaque\n", key->front ? "" : "no");
if (!(key->visible))
fputs("unset key\n", fp);
fputs("unset label\n", fp);
for (this_label = first_label; this_label != NULL;
this_label = this_label->next) {
fprintf(fp, "set label %d \"%s\" at ",
this_label->tag,
conv_text(this_label->text));
save_position(fp, &this_label->place, FALSE);
switch (this_label->pos) {
case LEFT:
fputs(" left", fp);
break;
case CENTRE:
fputs(" centre", fp);
break;
case RIGHT:
fputs(" right", fp);
break;
}
if (this_label->rotate)
fprintf(fp, " rotate by %d", this_label->rotate);
else
fprintf(fp, " norotate");
if (this_label->font != NULL)
fprintf(fp, " font \"%s\"", this_label->font);
fprintf(fp, " %s", (this_label->layer==0) ? "back" : "front");
if (this_label->noenhanced)
fprintf(fp, " noenhanced");
save_textcolor(fp, &(this_label->textcolor));
if (this_label->lp_properties.pointflag == 0)
fprintf(fp, " nopoint");
else {
fprintf(fp, " point");
save_linetype(fp, &(this_label->lp_properties), TRUE);
}
save_position(fp, &this_label->offset, TRUE);
fputc('\n', fp);
}
fputs("unset arrow\n", fp);
for (this_arrow = first_arrow; this_arrow != NULL;
this_arrow = this_arrow->next) {
fprintf(fp, "set arrow %d from ", this_arrow->tag);
save_position(fp, &this_arrow->start, FALSE);
fputs(this_arrow->relative ? " rto " : " to ", fp);
save_position(fp, &this_arrow->end, FALSE);
fprintf(fp, " %s %s %s",
arrow_head_names[this_arrow->arrow_properties.head],
(this_arrow->arrow_properties.layer==0) ? "back" : "front",
( (this_arrow->arrow_properties.head_filled==2) ? "filled" :
( (this_arrow->arrow_properties.head_filled==1) ? "empty" :
"nofilled" )) );
save_linetype(fp, &(this_arrow->arrow_properties.lp_properties), FALSE);
if (this_arrow->arrow_properties.head_length > 0) {
static char *msg[] = {"first", "second", "graph", "screen",
"character"};
fprintf(fp, " size %s %.3f,%.3f,%.3f",
msg[this_arrow->arrow_properties.head_lengthunit],
this_arrow->arrow_properties.head_length,
this_arrow->arrow_properties.head_angle,
this_arrow->arrow_properties.head_backangle);
}
fprintf(fp, "\n");
}
fprintf(fp, "set style increment %s\n", prefer_line_styles ? "userstyles" : "default");
fputs("unset style line\n", fp);
for (this_linestyle = first_linestyle; this_linestyle != NULL;
this_linestyle = this_linestyle->next) {
fprintf(fp, "set style line %d ", this_linestyle->tag);
save_linetype(fp, &(this_linestyle->lp_properties), TRUE);
fprintf(fp, "\n");
}
fputs("unset style arrow\n", fp);
for (this_arrowstyle = first_arrowstyle; this_arrowstyle != NULL;
this_arrowstyle = this_arrowstyle->next) {
fprintf(fp, "set style arrow %d", this_arrowstyle->tag);
fprintf(fp, " %s %s %s",
arrow_head_names[this_arrowstyle->arrow_properties.head],
(this_arrowstyle->arrow_properties.layer==0)?"back":"front",
( (this_arrowstyle->arrow_properties.head_filled==2)?"filled":
( (this_arrowstyle->arrow_properties.head_filled==1)?"empty":
"nofilled" )) );
save_linetype(fp, &(this_arrowstyle->arrow_properties.lp_properties), FALSE);
if (this_arrowstyle->arrow_properties.head_length > 0) {
static char *msg[] = {"first", "second", "graph", "screen",
"character"};
fprintf(fp, " size %s %.3f,%.3f,%.3f",
msg[this_arrowstyle->arrow_properties.head_lengthunit],
this_arrowstyle->arrow_properties.head_length,
this_arrowstyle->arrow_properties.head_angle,
this_arrowstyle->arrow_properties.head_backangle);
}
fprintf(fp, "\n");
}
fprintf(fp, "set style histogram ");
switch (histogram_opts.type) {
default:
case HT_CLUSTERED:
fprintf(fp,"clustered gap %d ",histogram_opts.gap); break;
case HT_ERRORBARS:
fprintf(fp,"errorbars gap %d lw %g",histogram_opts.gap,histogram_opts.bar_lw); break;
case HT_STACKED_IN_LAYERS:
fprintf(fp,"rowstacked "); break;
case HT_STACKED_IN_TOWERS:
fprintf(fp,"columnstacked "); break;
}
fprintf(fp,"title ");
save_position(fp, &histogram_opts.title.offset, TRUE);
fprintf(fp, "\n");
#ifdef EAM_OBJECTS
save_object(fp, 0);
#endif
fputs("unset logscale\n", fp);
#define SAVE_LOG(axis) \
if (axis_array[axis].log) \
fprintf(fp, "set logscale %s %g\n", axis_defaults[axis].name, \
axis_array[axis].base);
SAVE_LOG(FIRST_X_AXIS );
SAVE_LOG(FIRST_Y_AXIS );
SAVE_LOG(SECOND_X_AXIS);
SAVE_LOG(SECOND_Y_AXIS);
SAVE_LOG(FIRST_Z_AXIS );
SAVE_LOG(COLOR_AXIS );
SAVE_LOG(POLAR_AXIS );
#undef SAVE_LOG
save_offsets(fp, "set offsets");
/* FIXME */
fprintf(fp, "\
set pointsize %g\n\
set pointintervalbox %g\n\
set encoding %s\n\
%sset polar\n\
%sset parametric\n",
pointsize, pointintervalbox,
encoding_names[encoding],
(polar) ? "" : "un",
(parametric) ? "" : "un");
if (numeric_locale)
fprintf(fp, "set decimalsign locale \"%s\"\n", numeric_locale);
if (decimalsign != NULL)
fprintf(fp, "set decimalsign '%s'\n", decimalsign);
if (!numeric_locale && !decimalsign)
fprintf(fp, "unset decimalsign\n");
fputs("set view ", fp);
if (splot_map == TRUE)
fputs("map", fp);
else {
fprintf(fp, "%g, %g, %g, %g",
surface_rot_x, surface_rot_z, surface_scale, surface_zscale);
}
if (aspect_ratio_3D)
fprintf(fp, "\nset view %s", aspect_ratio_3D == 2 ? "equal xy" :
aspect_ratio_3D == 3 ? "equal xyz": "");
fprintf(fp, "\n\
set samples %d, %d\n\
set isosamples %d, %d\n\
%sset surface\n\
%sset contour",
samples_1, samples_2,
iso_samples_1, iso_samples_2,
(draw_surface) ? "" : "un",
(draw_contour) ? "" : "un");
switch (draw_contour) {
case CONTOUR_NONE:
fputc('\n', fp);
break;
case CONTOUR_BASE:
fputs(" base\n", fp);
break;
case CONTOUR_SRF:
fputs(" surface\n", fp);
break;
case CONTOUR_BOTH:
fputs(" both\n", fp);
break;
}
if (label_contours)
fprintf(fp, "set clabel '%s'\n", contour_format);
else
fputs("unset clabel\n", fp);
#ifdef GP_MACROS
if (expand_macros)
fputs("set macros\n", fp);
#endif
fputs("set mapping ", fp);
switch (mapping3d) {
case MAP3D_SPHERICAL:
fputs("spherical\n", fp);
break;
case MAP3D_CYLINDRICAL:
fputs("cylindrical\n", fp);
break;
case MAP3D_CARTESIAN:
default:
fputs("cartesian\n", fp);
break;
}
if (missing_val != NULL)
fprintf(fp, "set datafile missing '%s'\n", missing_val);
if (df_separator != '\0')
fprintf(fp, "set datafile separator \"%c\"\n",df_separator);
else
fprintf(fp, "set datafile separator whitespace\n");
if (strcmp(df_commentschars, DEFAULT_COMMENTS_CHARS))
fprintf(fp, "set datafile commentschars '%s'\n", df_commentschars);
if (df_fortran_constants)
fprintf(fp, "set datafile fortran\n");
if (df_nofpe_trap)
fprintf(fp, "set datafile nofpe_trap\n");
save_hidden3doptions(fp);
fprintf(fp, "set cntrparam order %d\n", contour_order);
fputs("set cntrparam ", fp);
switch (contour_kind) {
case CONTOUR_KIND_LINEAR:
fputs("linear\n", fp);
break;
case CONTOUR_KIND_CUBIC_SPL:
fputs("cubicspline\n", fp);
break;
case CONTOUR_KIND_BSPLINE:
fputs("bspline\n", fp);
break;
}
fputs("set cntrparam levels ", fp);
switch (contour_levels_kind) {
case LEVELS_AUTO:
fprintf(fp, "auto %d\n", contour_levels);
break;
case LEVELS_INCREMENTAL:
fprintf(fp, "incremental %g,%g,%g\n",
contour_levels_list[0], contour_levels_list[1],
contour_levels_list[0] + contour_levels_list[1] * contour_levels);
break;
case LEVELS_DISCRETE:
{
int i;
fprintf(fp, "discrete %g", contour_levels_list[0]);
for (i = 1; i < contour_levels; i++)
fprintf(fp, ",%g ", contour_levels_list[i]);
fputc('\n', fp);
}
}
fprintf(fp, "\
set cntrparam points %d\n\
set size ratio %g %g,%g\n\
set origin %g,%g\n",
contour_pts,
aspect_ratio, xsize, ysize,
xoffset, yoffset);
fprintf(fp, "set style data ");
save_data_func_style(fp,"data",data_style);
fprintf(fp, "set style function ");
save_data_func_style(fp,"function",func_style);
save_zeroaxis(fp, FIRST_X_AXIS);
save_zeroaxis(fp, FIRST_Y_AXIS);
save_zeroaxis(fp, FIRST_Z_AXIS);
save_zeroaxis(fp, SECOND_X_AXIS);
save_zeroaxis(fp, SECOND_Y_AXIS);
if (xyplane.absolute)
fprintf(fp, "set xyplane at %g\n", xyplane.z);
else
fprintf(fp, "set ticslevel %g\n", xyplane.z);
#define SAVE_MINI(axis) \
switch(axis_array[axis].minitics & TICS_MASK) { \
case 0: \
fprintf(fp, "set nom%stics\n", axis_defaults[axis].name); \
break; \
case MINI_AUTO: \
fprintf(fp, "set m%stics\n", axis_defaults[axis].name); \
break; \
case MINI_DEFAULT: \
fprintf(fp, "set m%stics default\n", axis_defaults[axis].name); \
break; \
case MINI_USER: \
fprintf(fp, "set m%stics %f\n", axis_defaults[axis].name, \
axis_array[axis].mtic_freq); \
break; \
}
SAVE_MINI(FIRST_X_AXIS);
SAVE_MINI(FIRST_Y_AXIS);
SAVE_MINI(FIRST_Z_AXIS); /* HBB 20000506: noticed mztics were not saved! */
SAVE_MINI(SECOND_X_AXIS);
SAVE_MINI(SECOND_Y_AXIS);
SAVE_MINI(COLOR_AXIS);
#undef SAVE_MINI
save_tics(fp, FIRST_X_AXIS);
save_tics(fp, FIRST_Y_AXIS);
save_tics(fp, FIRST_Z_AXIS);
save_tics(fp, SECOND_X_AXIS);
save_tics(fp, SECOND_Y_AXIS);
save_tics(fp, COLOR_AXIS);
save_tics(fp, POLAR_AXIS);
#define SAVE_AXISLABEL_OR_TITLE(name,suffix,lab) \
{ \
fprintf(fp, "set %s%s \"%s\" ", \
name, suffix, lab.text ? conv_text(lab.text) : ""); \
fprintf(fp, "\nset %s%s ", name, suffix); \
save_position(fp, &(lab.offset), TRUE); \
fprintf(fp, " font \"%s\"", lab.font ? conv_text(lab.font) : "");\
save_textcolor(fp, &(lab.textcolor)); \
if (lab.tag == ROTATE_IN_3D_LABEL_TAG) \
fprintf(fp, " rotate parallel"); \
if (lab.rotate) \
fprintf(fp, " rotate by %d", lab.rotate); \
else \
fprintf(fp, " norotate"); \
fprintf(fp, "%s\n", (lab.noenhanced) ? " noenhanced" : ""); \
}
SAVE_AXISLABEL_OR_TITLE("", "title", title);
/* FIXME */
fprintf(fp, "set timestamp %s \n", timelabel_bottom ? "bottom" : "top");
SAVE_AXISLABEL_OR_TITLE("", "timestamp", timelabel);
save_range(fp, POLAR_AXIS);
save_range(fp, T_AXIS);
save_range(fp, U_AXIS);
save_range(fp, V_AXIS);
#define SAVE_AXISLABEL(axis) \
SAVE_AXISLABEL_OR_TITLE(axis_defaults[axis].name,"label", \
axis_array[axis].label)
SAVE_AXISLABEL(FIRST_X_AXIS);
SAVE_AXISLABEL(SECOND_X_AXIS);
save_range(fp, FIRST_X_AXIS);
save_range(fp, SECOND_X_AXIS);
SAVE_AXISLABEL(FIRST_Y_AXIS);
SAVE_AXISLABEL(SECOND_Y_AXIS);
if (splot_map == FALSE) {
save_range(fp, FIRST_Y_AXIS);
save_range(fp, SECOND_Y_AXIS);
} else { /* 'set view map' uses flipped y-axes */
splot_map_deactivate();
save_range(fp, FIRST_Y_AXIS);
save_range(fp, SECOND_Y_AXIS);
splot_map_activate();
}
SAVE_AXISLABEL(FIRST_Z_AXIS);
save_range(fp, FIRST_Z_AXIS);
SAVE_AXISLABEL(COLOR_AXIS);
save_range(fp, COLOR_AXIS);
#undef SAVE_AXISLABEL
#undef SAVE_AXISLABEL_OR_TITLE
fprintf(fp, "set zero %g\n", zero);
fprintf(fp, "set lmargin %s %g\n",
lmargin.scalex == screen ? "at screen" : "", lmargin.x);
fprintf(fp, "set bmargin %s %g\n",
bmargin.scalex == screen ? "at screen" : "", bmargin.x);
fprintf(fp, "set rmargin %s %g\n",
rmargin.scalex == screen ? "at screen" : "", rmargin.x);
fprintf(fp, "set tmargin %s %g\n",
tmargin.scalex == screen ? "at screen" : "", tmargin.x);
fprintf(fp, "set locale \"%s\"\n", get_time_locale());
fputs("set pm3d ", fp);
fputs((PM3D_IMPLICIT == pm3d.implicit ? "implicit" : "explicit"), fp);
fprintf(fp, " at %s\n", pm3d.where);
fputs("set pm3d ", fp);
switch (pm3d.direction) {
case PM3D_SCANS_AUTOMATIC: fputs("scansautomatic\n", fp); break;
case PM3D_SCANS_FORWARD: fputs("scansforward\n", fp); break;
case PM3D_SCANS_BACKWARD: fputs("scansbackward\n", fp); break;
case PM3D_DEPTH: fputs("depthorder\n", fp); break;
}
fprintf(fp, "set pm3d interpolate %d,%d", pm3d.interp_i, pm3d.interp_j);
fputs(" flush ", fp);
switch (pm3d.flush) {
case PM3D_FLUSH_CENTER: fputs("center", fp); break;
case PM3D_FLUSH_BEGIN: fputs("begin", fp); break;
case PM3D_FLUSH_END: fputs("end", fp); break;
}
fputs((pm3d.ftriangles ? " " : " no"), fp);
fputs("ftriangles", fp);
if (pm3d.hidden3d_tag > 0) fprintf(fp," hidden3d %d", pm3d.hidden3d_tag);
else fputs(pm3d.hidden3d_tag ? " hidden3d" : " nohidden3d", fp);
fputs(" corners2color ", fp);
switch (pm3d.which_corner_color) {
case PM3D_WHICHCORNER_MEAN: fputs("mean", fp); break;
case PM3D_WHICHCORNER_GEOMEAN: fputs("geomean", fp); break;
case PM3D_WHICHCORNER_MEDIAN: fputs("median", fp); break;
case PM3D_WHICHCORNER_MIN: fputs("min", fp); break;
case PM3D_WHICHCORNER_MAX: fputs("max", fp); break;
default: /* PM3D_WHICHCORNER_C1 ... _C4 */
fprintf(fp, "c%i", pm3d.which_corner_color - PM3D_WHICHCORNER_C1 + 1);
}
fputs("\n", fp);
/*
* Save palette information
*/
fprintf( fp, "set palette %s %s maxcolors %d ",
sm_palette.positive==SMPAL_POSITIVE ? "positive" : "negative",
sm_palette.ps_allcF ? "ps_allcF" : "nops_allcF",
sm_palette.use_maxcolors);
fprintf( fp, "gamma %g ", sm_palette.gamma );
if (sm_palette.colorMode == SMPAL_COLOR_MODE_GRAY) {
fputs( "gray\n", fp );
}
else {
fputs( "color model ", fp );
switch( sm_palette.cmodel ) {
case C_MODEL_RGB: fputs( "RGB ", fp ); break;
case C_MODEL_HSV: fputs( "HSV ", fp ); break;
case C_MODEL_CMY: fputs( "CMY ", fp ); break;
case C_MODEL_YIQ: fputs( "YIQ ", fp ); break;
case C_MODEL_XYZ: fputs( "XYZ ", fp ); break;
default:
fprintf( stderr, "%s:%d ooops: Unknown color model '%c'.\n",
__FILE__, __LINE__, (char)(sm_palette.cmodel) );
}
fputs( "\nset palette ", fp );
switch( sm_palette.colorMode ) {
case SMPAL_COLOR_MODE_RGB:
fprintf( fp, "rgbformulae %d, %d, %d\n", sm_palette.formulaR,
sm_palette.formulaG, sm_palette.formulaB );
break;
case SMPAL_COLOR_MODE_GRADIENT: {
int i=0;
fprintf( fp, "defined (" );
for( i=0; i<sm_palette.gradient_num; ++i ) {
fprintf( fp, " %.4g %.4g %.4g %.4g", sm_palette.gradient[i].pos,
sm_palette.gradient[i].col.r, sm_palette.gradient[i].col.g,
sm_palette.gradient[i].col.b );
if (i<sm_palette.gradient_num-1) {
fputs( ",", fp);
if (i==2 || i%4==2) fputs( "\\\n ", fp );
}
}
fputs( " )\n", fp );
break;
}
case SMPAL_COLOR_MODE_FUNCTIONS:
fprintf( fp, "functions %s, %s, %s\n", sm_palette.Afunc.definition,
sm_palette.Bfunc.definition, sm_palette.Cfunc.definition );
break;
case SMPAL_COLOR_MODE_CUBEHELIX:
fprintf( fp, "cubehelix start %.2g cycles %.2g saturation %.2g\n",
sm_palette.cubehelix_start, sm_palette.cubehelix_cycles,
sm_palette.cubehelix_saturation);
break;
default:
fprintf( stderr, "%s:%d ooops: Unknown color mode '%c'.\n",
__FILE__, __LINE__, (char)(sm_palette.colorMode) );
}
}
/*
* Save colorbox info
*/
if (color_box.where != SMCOLOR_BOX_NO)
fprintf(fp,"set colorbox %s\n", color_box.where==SMCOLOR_BOX_DEFAULT ? "default" : "user");
fprintf(fp, "set colorbox %sal origin ", color_box.rotation == 'v' ? "vertic" : "horizont");
save_position(fp, &color_box.origin, FALSE);
fputs(" size ", fp);
save_position(fp, &color_box.size, FALSE);
fprintf(fp, " %s ", color_box.layer == LAYER_FRONT ? "front" : "back");
if (color_box.border == 0) fputs("noborder", fp);
else if (color_box.border_lt_tag < 0) fputs("bdefault", fp);
else fprintf(fp, "border %d", color_box.border_lt_tag);
if (color_box.where == SMCOLOR_BOX_NO) fputs("\nunset colorbox\n", fp);
else fputs("\n", fp);
fprintf(fp, "set style boxplot %s %s %5.2f %soutliers pt %d separation %g labels %s %ssorted\n",
boxplot_opts.plotstyle == FINANCEBARS ? "financebars" : "candles",
boxplot_opts.limit_type == 1 ? "fraction" : "range",
boxplot_opts.limit_value,
boxplot_opts.outliers ? "" : "no",
boxplot_opts.pointtype+1,
boxplot_opts.separation,
(boxplot_opts.labels == BOXPLOT_FACTOR_LABELS_X) ? "x" :
(boxplot_opts.labels == BOXPLOT_FACTOR_LABELS_X2) ? "x2" :
(boxplot_opts.labels == BOXPLOT_FACTOR_LABELS_AUTO) ? "auto" :"off",
boxplot_opts.sort_factors ? "" : "un");
fputs("set loadpath ", fp);
{
char *s;
while ((s = save_loadpath()) != NULL)
fprintf(fp, "\"%s\" ", s);
fputc('\n', fp);
}
fputs("set fontpath ", fp);
{
char *s;
while ((s = save_fontpath()) != NULL)
fprintf(fp, "\"%s\" ", s);
fputc('\n', fp);
}
if (PS_psdir)
fprintf(fp, "set psdir \"%s\"\n", PS_psdir);
else
fprintf(fp, "set psdir\n");
fprintf(fp, "set fit");
if (fitlogfile)
fprintf(fp, " logfile \'%s\'", fitlogfile);
fprintf(fp, " %serrorvariables",
fit_errorvariables ? "" : "no");
fprintf(fp, " %sprescale", fit_prescale ? "" : "no");
fputc('\n', fp);
}
int main(int argc, char **argv)
{
int c;
int option_index = 0;
char *inFile, *outFile;
FILE *fin, *fout=NULL, *frange=NULL;
float *output;
int frame_size=0;
OpusMSDecoder *st=NULL;
opus_int64 packet_count=0;
int total_links=0;
int stream_init = 0;
int quiet = 0;
ogg_int64_t page_granule=0;
ogg_int64_t link_out=0;
struct option long_options[] =
{
{"help", no_argument, NULL, 0},
{"quiet", no_argument, NULL, 0},
{"version", no_argument, NULL, 0},
{"version-short", no_argument, NULL, 0},
{"rate", required_argument, NULL, 0},
{"gain", required_argument, NULL, 0},
{"no-dither", no_argument, NULL, 0},
{"packet-loss", required_argument, NULL, 0},
{"save-range", required_argument, NULL, 0},
{0, 0, 0, 0}
};
ogg_sync_state oy;
ogg_page og;
ogg_packet op;
ogg_stream_state os;
int close_in=0;
int eos=0;
ogg_int64_t audio_size=0;
double last_coded_seconds=0;
float loss_percent=-1;
float manual_gain=0;
int channels=-1;
int mapping_family;
int rate=0;
int wav_format=0;
int preskip=0;
int gran_offset=0;
int has_opus_stream=0;
ogg_int32_t opus_serialno;
int dither=1;
shapestate shapemem;
SpeexResamplerState *resampler=NULL;
float gain=1;
int streams=0;
size_t last_spin=0;
#ifdef WIN_UNICODE
int argc_utf8;
char **argv_utf8;
#endif
if(query_cpu_support()){
fprintf(stderr,"\n\n** WARNING: This program with compiled with SSE%s\n",query_cpu_support()>1?"2":"");
fprintf(stderr," but this CPU claims to lack these instructions. **\n\n");
}
#ifdef WIN_UNICODE
(void)argc;
(void)argv;
init_console_utf8();
init_commandline_arguments_utf8(&argc_utf8, &argv_utf8);
#endif
output=0;
shapemem.a_buf=0;
shapemem.b_buf=0;
shapemem.mute=960;
shapemem.fs=0;
/*Process options*/
while(1)
{
c = getopt_long (argc_utf8, argv_utf8, "hV",
long_options, &option_index);
if (c==-1)
break;
switch(c)
{
case 0:
if (strcmp(long_options[option_index].name,"help")==0)
{
usage();
quit(0);
} else if (strcmp(long_options[option_index].name,"quiet")==0)
{
quiet = 1;
} else if (strcmp(long_options[option_index].name,"version")==0)
{
version();
quit(0);
} else if (strcmp(long_options[option_index].name,"version-short")==0)
{
version_short();
quit(0);
} else if (strcmp(long_options[option_index].name,"no-dither")==0)
{
dither=0;
} else if (strcmp(long_options[option_index].name,"rate")==0)
{
rate=atoi (optarg);
} else if (strcmp(long_options[option_index].name,"gain")==0)
{
manual_gain=atof (optarg);
}else if(strcmp(long_options[option_index].name,"save-range")==0){
frange=fopen_utf8(optarg,"w");
if(frange==NULL){
perror(optarg);
fprintf(stderr,"Could not open save-range file: %s\n",optarg);
fprintf(stderr,"Must provide a writable file name.\n");
quit(1);
}
} else if (strcmp(long_options[option_index].name,"packet-loss")==0)
{
loss_percent = atof(optarg);
}
break;
case 'h':
usage();
quit(0);
break;
case 'V':
version();
quit(0);
break;
case '?':
usage();
quit(1);
break;
}
}
if (argc_utf8-optind!=2 && argc_utf8-optind!=1)
{
usage();
quit(1);
}
inFile=argv_utf8[optind];
/*Output to a file or playback?*/
if (argc_utf8-optind==2){
/*If we're outputting to a file, should we apply a wav header?*/
int i;
char *ext;
outFile=argv_utf8[optind+1];
ext=".wav";
i=strlen(outFile)-4;
wav_format=i>=0;
while(wav_format&&ext&&outFile[i]) {
wav_format&=tolower(outFile[i++])==*ext++;
}
}else {
outFile="";
wav_format=0;
/*If playing to audio out, default the rate to 48000
instead of the original rate. The original rate is
only important for minimizing surprise about the rate
of output files and preserving length, which aren't
relevant for playback. Many audio devices sound
better at 48kHz and not resampling also saves CPU.*/
if(rate==0)rate=48000;
}
/*Open input file*/
if (strcmp(inFile, "-")==0)
{
#if defined WIN32 || defined _WIN32
_setmode(_fileno(stdin), _O_BINARY);
#endif
fin=stdin;
}
else
{
fin = fopen_utf8(inFile, "rb");
if (!fin)
{
perror(inFile);
quit(1);
}
close_in=1;
}
/* .opus files use the Ogg container to provide framing and timekeeping.
* http://tools.ietf.org/html/draft-terriberry-oggopus
* The easiest way to decode the Ogg container is to use libogg, so
* thats what we do here.
* Using libogg is fairly straight forward-- you take your stream of bytes
* and feed them to ogg_sync_ and it periodically returns Ogg pages, you
* check if the pages belong to the stream you're decoding then you give
* them to libogg and it gives you packets. You decode the packets. The
* pages also provide timing information.*/
ogg_sync_init(&oy);
/*Main decoding loop*/
while (1)
{
char *data;
int i, nb_read;
/*Get the ogg buffer for writing*/
data = ogg_sync_buffer(&oy, 200);
/*Read bitstream from input file*/
nb_read = fread(data, sizeof(char), 200, fin);
ogg_sync_wrote(&oy, nb_read);
/*Loop for all complete pages we got (most likely only one)*/
while (ogg_sync_pageout(&oy, &og)==1)
{
if (stream_init == 0) {
ogg_stream_init(&os, ogg_page_serialno(&og));
stream_init = 1;
}
if (ogg_page_serialno(&og) != os.serialno) {
/* so all streams are read. */
ogg_stream_reset_serialno(&os, ogg_page_serialno(&og));
}
/*Add page to the bitstream*/
ogg_stream_pagein(&os, &og);
page_granule = ogg_page_granulepos(&og);
/*Extract all available packets*/
while (ogg_stream_packetout(&os, &op) == 1)
{
/*OggOpus streams are identified by a magic string in the initial
stream header.*/
if (op.b_o_s && op.bytes>=8 && !memcmp(op.packet, "OpusHead", 8)) {
if(!has_opus_stream)
{
opus_serialno = os.serialno;
has_opus_stream = 1;
link_out = 0;
packet_count = 0;
eos = 0;
total_links++;
} else {
fprintf(stderr,"Warning: ignoring opus stream %" I64FORMAT "\n",(long long)os.serialno);
}
}
if (!has_opus_stream || os.serialno != opus_serialno)
break;
/*If first packet in a logical stream, process the Opus header*/
if (packet_count==0)
{
st = process_header(&op, &rate, &mapping_family, &channels, &preskip, &gain, manual_gain, &streams, wav_format, quiet);
if (!st)
quit(1);
/*Remember how many samples at the front we were told to skip
so that we can adjust the timestamp counting.*/
gran_offset=preskip;
/*Setup the memory for the dithered output*/
if(!shapemem.a_buf)
{
shapemem.a_buf=calloc(channels,sizeof(float)*4);
shapemem.b_buf=calloc(channels,sizeof(float)*4);
shapemem.fs=rate;
}
if(!output)output=malloc(sizeof(float)*MAX_FRAME_SIZE*channels);
/*Normal players should just play at 48000 or their maximum rate,
as described in the OggOpus spec. But for commandline tools
like opusdec it can be desirable to exactly preserve the original
sampling rate and duration, so we have a resampler here.*/
if (rate != 48000)
{
int err;
resampler = speex_resampler_init(channels, 48000, rate, 5, &err);
if (err!=0)
fprintf(stderr, "resampler error: %s\n", speex_resampler_strerror(err));
speex_resampler_skip_zeros(resampler);
}
if(!fout)fout=out_file_open(outFile, &wav_format, rate, mapping_family, &channels);
} else if (packet_count==1)
{
if (!quiet)
print_comments((char*)op.packet, op.bytes);
} else {
int ret;
opus_int64 maxout;
opus_int64 outsamp;
int lost=0;
if (loss_percent>0 && 100*((float)rand())/RAND_MAX<loss_percent)
lost=1;
/*End of stream condition*/
if (op.e_o_s && os.serialno == opus_serialno)eos=1; /* don't care for anything except opus eos */
/*Are we simulating loss for this packet?*/
if (!lost){
/*Decode Opus packet*/
ret = opus_multistream_decode_float(st, (unsigned char*)op.packet, op.bytes, output, MAX_FRAME_SIZE, 0);
} else {
/*Extract the original duration.
Normally you wouldn't have it for a lost packet, but normally the
transports used on lossy channels will effectively tell you.
This avoids opusdec squaking when the decoded samples and
granpos mismatches.*/
opus_int32 lost_size;
lost_size = MAX_FRAME_SIZE;
if(op.bytes>0){
opus_int32 spp;
spp=opus_packet_get_nb_frames(op.packet,op.bytes);
if(spp>0){
spp*=opus_packet_get_samples_per_frame(op.packet,48000/*decoding_rate*/);
if(spp>0)lost_size=spp;
}
}
/*Invoke packet loss concealment.*/
ret = opus_multistream_decode_float(st, NULL, 0, output, lost_size, 0);
}
if(!quiet){
/*Display a progress spinner while decoding.*/
static const char spinner[]="|/-\\";
double coded_seconds = (double)audio_size/(channels*rate*sizeof(short));
if(coded_seconds>=last_coded_seconds+1){
fprintf(stderr,"\r[%c] %02d:%02d:%02d", spinner[last_spin&3],
(int)(coded_seconds/3600),(int)(coded_seconds/60)%60,
(int)(coded_seconds)%60);
fflush(stderr);
last_spin++;
last_coded_seconds=coded_seconds;
}
}
/*If the decoder returned less than zero, we have an error.*/
if (ret<0)
{
fprintf (stderr, "Decoding error: %s\n", opus_strerror(ret));
break;
}
frame_size = ret;
/*If we're collecting --save-range debugging data, collect it now.*/
if(frange!=NULL){
OpusDecoder *od;
opus_uint32 rngs[256];
for(i=0;i<streams;i++){
ret=opus_multistream_decoder_ctl(st,OPUS_MULTISTREAM_GET_DECODER_STATE(i,&od));
ret=opus_decoder_ctl(od,OPUS_GET_FINAL_RANGE(&rngs[i]));
}
save_range(frange,frame_size*(48000/48000/*decoding_rate*/),op.packet,op.bytes,
rngs,streams);
}
/*Apply header gain, if we're not using an opus library new
enough to do this internally.*/
if (gain!=0){
for (i=0;i<frame_size*channels;i++)
output[i] *= gain;
}
/*This handles making sure that our output duration respects
the final end-trim by not letting the output sample count
get ahead of the granpos indicated value.*/
maxout=((page_granule-gran_offset)*rate/48000)-link_out;
outsamp=audio_write(output, channels, frame_size, fout, resampler, &preskip, dither?&shapemem:0, strlen(outFile)!=0,0>maxout?0:maxout);
link_out+=outsamp;
audio_size+=sizeof(short)*outsamp*channels;
}
packet_count++;
}
/*We're done, drain the resampler if we were using it.*/
if(eos && resampler)
{
float *zeros;
int drain;
zeros=(float *)calloc(100*channels,sizeof(float));
drain = speex_resampler_get_input_latency(resampler);
do {
opus_int64 outsamp;
int tmp = drain;
if (tmp > 100)
tmp = 100;
outsamp=audio_write(zeros, channels, tmp, fout, resampler, NULL, &shapemem, strlen(outFile)!=0, ((page_granule-gran_offset)*rate/48000)-link_out);
link_out+=outsamp;
audio_size+=sizeof(short)*outsamp*channels;
drain -= tmp;
} while (drain>0);
free(zeros);
speex_resampler_destroy(resampler);
resampler=NULL;
}
if(eos)
{
has_opus_stream=0;
if(st)opus_multistream_decoder_destroy(st);
st=NULL;
}
}
if (feof(fin)) {
if(!quiet) {
fprintf(stderr, "\rDecoding complete. \n");
fflush(stderr);
}
break;
}
}
/*If we were writing wav, go set the duration.*/
if (strlen(outFile)!=0 && fout && wav_format>=0 && audio_size<0x7FFFFFFF)
{
if (fseek(fout,4,SEEK_SET)==0)
{
int tmp;
tmp = le_int(audio_size+20+wav_format);
if(fwrite(&tmp,4,1,fout)!=1)fprintf(stderr,"Error writing end length.\n");
if (fseek(fout,16+wav_format,SEEK_CUR)==0)
{
tmp = le_int(audio_size);
if(fwrite(&tmp,4,1,fout)!=1)fprintf(stderr,"Error writing header length.\n");
} else
{
fprintf (stderr, "First seek worked, second didn't\n");
}
} else {
fprintf (stderr, "Cannot seek on wave file, size will be incorrect\n");
}
}
/*Did we make it to the end without recovering ANY opus logical streams?*/
if(!total_links)fprintf (stderr, "This doesn't look like a Opus file\n");
if (stream_init)
ogg_stream_clear(&os);
ogg_sync_clear(&oy);
#if defined WIN32 || defined _WIN32
if (strlen(outFile)==0)
WIN_Audio_close ();
#endif
if(shapemem.a_buf)free(shapemem.a_buf);
if(shapemem.b_buf)free(shapemem.b_buf);
if(output)free(output);
if(frange)fclose(frange);
if (close_in)
fclose(fin);
if (fout != NULL)
fclose(fout);
#ifdef WIN_UNICODE
free_commandline_arguments_utf8(&argc_utf8, &argv_utf8);
uninit_console_utf8();
#endif
return 0;
}
