static int
checkargs (int argc, char **argv, bool_t *double_resolution, bool_t *panel,
int *fps, char **image_name, fiasco_d_options_t **options)
/*
* Check validness of command line parameters and of the parameter files.
*
* Return value.
* index in argv of the first argv-element that is not an option.
*
* Side effects:
* 'double_resolution', 'panel', 'fps', 'image_name' and 'options'
* are modified.
*/
{
int optind; /* last processed commandline param */
optind = parseargs (params, argc, argv,
"Decode FIASCO-FILEs and write frame(s) to disk.",
"With no FIASCO-FILE, or if FIASCO-FILE is -, "
"read standard input.\n"
"Environment:\n"
"FIASCO_DATA Search path for automata files. "
"Default: ./\n"
"FIASCO_IMAGES Save path for image files. "
"Default: ./", " [FIASCO-FILE]...",
FIASCO_SHARE, "system.fiascorc", ".fiascorc");
*image_name = (char *) parameter_value (params, "output");
*double_resolution = *((bool_t *) parameter_value (params, "double"));
*panel = *((bool_t *) parameter_value (params, "panel"));
*fps = *((int *) parameter_value (params, "framerate"));
/*
* Additional options ... (have to be set with the fiasco_set_... methods)
*/
*options = fiasco_d_options_new ();
{
int n = *((int *) parameter_value (params, "smoothing"));
if (!fiasco_d_options_set_smoothing (*options, max (-1, n)))
error (fiasco_get_error_message ());
}
{
int n = *((int *) parameter_value (params, "magnify"));
if (!fiasco_d_options_set_magnification (*options, n))
error (fiasco_get_error_message ());
}
{
bool_t n = *((bool_t *) parameter_value (params, "fast"));
if (!fiasco_d_options_set_4_2_0_format (*options, n > 0 ? YES : NO))
error (fiasco_get_error_message ());
}
return optind;
}
int
main (int argc, char **argv)
{
char const **image_template; /* template for input image files */
char *wfa_name; /* filename of output WFA */
float quality; /* approximation quality */
fiasco_c_options_t *options; /* additional coder options */
pnm_init(&argc, argv);
init_error_handling (argv [0]);
checkargs (argc, argv, &image_template, &wfa_name, &quality, &options);
if (fiasco_coder (image_template, wfa_name, quality, options))
return 0;
else
{
fprintf (stderr, "%s", fiasco_get_error_message ());
fprintf (stderr, "\n");
return 1;
}
}
static void
checkargs (int argc, char **argv, char const ***image_template,
char **wfa_name, float *quality, fiasco_c_options_t **options)
/*
* Check validness of command line parameters and of the parameter files.
*
* Return value:
* 1 on success
* 0 otherwise
*
*
* Side effects:
* 'image_template', 'wfa_name', 'quality' and 'options' are set.
*/
{
int optind; /* last processed commandline param */
char *image_name; /* filename given by option '--input_name' */
int i; /* counter */
optind = parseargs (params, argc, argv,
"Compress raw PPM/PGM image FILEs to a FIASCO file.",
"With no image FILE, or if FILE is -, "
"read standard input.\n"
"FILE must be either a filename"
" or an image template of the form:\n"
"`prefix[start-end{+,-}step]suffix'\n"
"e.g., img0[12-01-1].pgm is substituted by"
" img012.pgm ... img001.pgm\n\n"
"Environment:\n"
"FIASCO_DATA Search and save path for FIASCO files. "
"Default: ./\n"
"FIASCO_IMAGES Search path for image files. "
"Default: ./", " [FILE]...",
FIASCO_SHARE, "system.fiascorc", ".fiascorc");
/*
* Default options ...
*/
image_name = (char *) parameter_value (params, "image-name");
*wfa_name = (char *) parameter_value (params, "output-name");
for (;;)
{
*quality = * (float *) parameter_value (params, "quality");
if (*quality > 100)
fprintf (stderr, "Typical range of quality: (0,100].\n"
"Expect some trouble on slow machines.\n");
if (*quality > 0)
break;
ask_and_set (params, "quality",
"Please enter coding quality 'q' ('q' > 0): ");
}
if (optind < argc) /* Additional command line param */
{
if (image_name)
error ("Multiple image_template arguments."
"\nOption --input-name %s already specified!", image_name);
*image_template = calloc (argc - optind + 1, sizeof (char *));
if (!*image_template)
error ("Out of memory.");
for (i = 0; optind < argc; i++, optind++)
(*image_template) [i] = argv [optind];
(*image_template) [i] = NULL;
}
else /* option -i image_name */
{
*image_template = calloc (2, sizeof (char *));
if (!*image_template)
error ("Out of memory.");
(*image_template) [0] = image_name;
(*image_template) [1] = NULL;
}
/*
* Additional options ... (have to be set with the fiasco_set_... methods)
*/
{
*options = fiasco_c_options_new ();
{
char *pattern = (char *) parameter_value (params, "pattern");
if (!fiasco_c_options_set_frame_pattern (*options, pattern))
error (fiasco_get_error_message ());
}
{
char *basis = (char *) parameter_value (params, "basis-name");
if (!fiasco_c_options_set_basisfile (*options, basis))
error (fiasco_get_error_message ());
}
{
int n = * (int *) parameter_value (params, "chroma-dictionary");
float q = * (float *) parameter_value (params, "chroma-qfactor");
if (!fiasco_c_options_set_chroma_quality (*options, q, MAX(0, n)))
error (fiasco_get_error_message ());
}
{
int n = *((int *) parameter_value (params, "smooth"));
if (!fiasco_c_options_set_smoothing (*options, MAX(0, n)))
error (fiasco_get_error_message ());
}
{
int n = * (int *) parameter_value (params, "progress-meter");
fiasco_progress_e type = (n < 0) ?
FIASCO_PROGRESS_NONE : (fiasco_progress_e) n;
if (!fiasco_c_options_set_progress_meter (*options, type))
error (fiasco_get_error_message ());
}
{
char *t = (char *) parameter_value (params, "title");
if (strlen (t) > 0 && !fiasco_c_options_set_title (*options, t))
error (fiasco_get_error_message ());
}
{
char *c = (char *) parameter_value (params, "comment");
if (strlen (c) > 0 && !fiasco_c_options_set_comment (*options, c))
error (fiasco_get_error_message ());
}
{
fiasco_tiling_e method = FIASCO_TILING_VARIANCE_DSC;
int e = * (int *) parameter_value (params, "tiling-exponent");
char *m = (char *) parameter_value (params, "tiling-method");
if (strcaseeq (m, "desc-variance"))
method = FIASCO_TILING_VARIANCE_DSC;
else if (strcaseeq (m, "asc-variance"))
method = FIASCO_TILING_VARIANCE_ASC;
else if (strcaseeq (m, "asc-spiral"))
method = FIASCO_TILING_SPIRAL_ASC;
else if (strcaseeq (m, "dsc-spiral"))
method = FIASCO_TILING_SPIRAL_DSC;
else
error (_("Invalid tiling method `%s' specified."), m);
if (!fiasco_c_options_set_tiling (*options, method, MAX(0, e)))
error (fiasco_get_error_message ());
}
{
int M/* = * (int *) parameter_value (params, "max-level") */;
int m/* = * (int *) parameter_value (params, "min-level") */;
int N/* = * (int *) parameter_value (params, "max-elements") */;
int D = * (int *) parameter_value (params, "dictionary-size");
int o = * (int *) parameter_value (params, "optimize");
if (o <= 0)
{
o = 0;
M = 10;
m = 6;
N = 3;
}
else
{
o -= 1;
M = 12;
m = 4;
N = 5;
}
if (!fiasco_c_options_set_optimizations (*options, m, M, N,
MAX(0, D), o))
error (fiasco_get_error_message ());
}
{
int M = * (int *) parameter_value (params, "max-level");
int m = * (int *) parameter_value (params, "min-level");
int p = * (int *) parameter_value (params, "prediction");
if (!fiasco_c_options_set_prediction (*options,
p, MAX(0, m), MAX(0, M)))
error (fiasco_get_error_message ());
}
{
float r = * (float *)parameter_value(params, "rpf-range");
float dc_r = * (float *)parameter_value(params, "dc-rpf-range");
int m = * (int *) parameter_value(params, "rpf-mantissa");
int dc_m = * (int *) parameter_value(params, "dc-rpf-mantissa");
fiasco_rpf_range_e range, dc_range;
if (r < 1)
range = FIASCO_RPF_RANGE_0_75;
else if (r < 1.5)
range = FIASCO_RPF_RANGE_1_00;
else if (r < 2.0)
range = FIASCO_RPF_RANGE_1_50;
else
range = FIASCO_RPF_RANGE_2_00;
if (dc_r < 1)
dc_range = FIASCO_RPF_RANGE_0_75;
else if (dc_r < 1.5)
dc_range = FIASCO_RPF_RANGE_1_00;
else if (dc_r < 2.0)
dc_range = FIASCO_RPF_RANGE_1_50;
else
dc_range = FIASCO_RPF_RANGE_2_00;
if (!fiasco_c_options_set_quantization (*options,
MAX(0, m), range,
MAX(0, dc_m), dc_range))
error (fiasco_get_error_message ());
}
if (fiasco_get_verbosity () == FIASCO_ULTIMATE_VERBOSITY)
write_parameters (params, stderr);
}
}
static void
video_decoder (const char *wfa_name, const char *image_name, bool_t panel,
bool_t double_resolution, int fps, fiasco_d_options_t *options)
{
do
{
unsigned width, height, frames, n;
fiasco_decoder_t *decoder_state;
char *filename;
char *basename; /* basename of decoded frame */
char *suffix; /* suffix of decoded frame */
unsigned frame_time;
if (!(decoder_state = fiasco_decoder_new (wfa_name, options)))
error (fiasco_get_error_message ());
if (fps <= 0) /* then use value of FIASCO file */
fps = fiasco_decoder_get_rate (decoder_state);
frame_time = fps ? (1000 / fps) : (1000 / 25);
if (!(width = fiasco_decoder_get_width (decoder_state)))
error (fiasco_get_error_message ());
if (!(height = fiasco_decoder_get_height (decoder_state)))
error (fiasco_get_error_message ());
if (!(frames = fiasco_decoder_get_length (decoder_state)))
error (fiasco_get_error_message ());
get_output_template (image_name, wfa_name,
fiasco_decoder_is_color (decoder_state),
&basename, &suffix);
filename = Calloc (strlen (basename) + strlen (suffix) + 2
+ 10 + (int) (log10 (frames) + 1), sizeof (char));
for (n = 0; n < frames; n++)
{
clock_t fps_timer; /* frames per second timer struct */
prg_timer (&fps_timer, START);
if (image_name) /* just write frame to disk */
{
if (frames == 1) /* just one image */
{
if (streq (image_name, "-"))
strcpy (filename, "-");
else
sprintf (filename, "%s.%s", basename, suffix);
}
else
{
fprintf (stderr, "Decoding frame %d to file `%s.%0*d.%s\n",
n, basename, (int) (log10 (frames - 1) + 1),
n, suffix);
sprintf (filename, "%s.%0*d.%s", basename,
(int) (log10 (frames - 1) + 1), n, suffix);
}
if (!fiasco_decoder_write_frame (decoder_state, filename))
error (fiasco_get_error_message ());
}
}
free (filename);
fiasco_decoder_delete (decoder_state);
} while (panel);
}