Example #1
0
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;
}
Example #2
0
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;
   }
}
Example #3
0
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);
    }
}   
Example #4
0
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);
}