diff options
| author | giraffedata <giraffedata@9d0c8265-081b-0410-96cb-a4ca84ce46f8> | 2009-12-30 03:59:47 +0000 |
|---|---|---|
| committer | giraffedata <giraffedata@9d0c8265-081b-0410-96cb-a4ca84ce46f8> | 2009-12-30 03:59:47 +0000 |
| commit | 25c660a745eedbff471fb636f97e7198a8b866f8 (patch) | |
| tree | de434d3b286477762cdeff137225232cf773873b /converter | |
| parent | 38049c8b75e5e8abbacc5636562e57451f4ebb12 (diff) | |
| download | netpbm-mirror-25c660a745eedbff471fb636f97e7198a8b866f8.tar.gz netpbm-mirror-25c660a745eedbff471fb636f97e7198a8b866f8.tar.xz netpbm-mirror-25c660a745eedbff471fb636f97e7198a8b866f8.zip | |
Release 10.49.00 - copied from trunk
git-svn-id: http://svn.code.sf.net/p/netpbm/code/advanced@1086 9d0c8265-081b-0410-96cb-a4ca84ce46f8
Diffstat (limited to 'converter')
21 files changed, 2372 insertions, 2075 deletions
diff --git a/converter/other/fiasco/codec/coder.c b/converter/other/fiasco/codec/coder.c index df878d87..927ebbda 100644 --- a/converter/other/fiasco/codec/coder.c +++ b/converter/other/fiasco/codec/coder.c @@ -1,8 +1,8 @@ /* - * coder.c: WFA coder toplevel functions + * coder.c: WFA coder toplevel functions * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO («F»ractal «I»mage «A»nd «S»equence «CO»dec) * Copyright (C) 1994-2000 Ullrich Hafner <hafner@bigfoot.de> */ @@ -18,6 +18,7 @@ #define _XOPEN_SOURCE 500 /* Make sure strdup() is in string.h */ #include "config.h" +#include "pm_c_util.h" #include "pnm.h" #include <math.h> @@ -53,328 +54,320 @@ /***************************************************************************** - global variables + global variables *****************************************************************************/ -const real_t MAXCOSTS = 1e20; +const real_t MAXCOSTS = 1e20; /***************************************************************************** - prototypes + private code *****************************************************************************/ -static coding_t * -alloc_coder (char const * const *inputname, const c_options_t *options, - wfa_info_t *wi); -static void -free_coder (coding_t *c); static char * -get_input_image_name (char const * const *templptr, unsigned ith_image); -static void -video_coder (char const * const *image_template, bitfile_t *output, - wfa_t *wfa, coding_t *c); -static void -frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output); -static void -print_statistics (char c, real_t costs, const wfa_t *wfa, const image_t *image, - const range_t *range); -static frame_type_e -pattern2type (unsigned frame, const char *pattern); - -/***************************************************************************** - - public code - -*****************************************************************************/ - -int -fiasco_coder (char const * const *inputname, const char *outputname, - float quality, const fiasco_c_options_t *options) +get_input_image_name (char const * const *templptr, unsigned ith_image) /* - * FIASCO coder. - * Encode image or video frames given by the array of filenames `inputname' - * and write to the outputfile `outputname'. - * If 'inputname' = NULL or - * 'inputname [0]' == NULL or - * 'inputname [0]' == "-", read standard input. - * If 'outputname' == NULL or "-", write on standard output. - * 'quality' defines the approximation quality and is 1 (worst) to 100 (best). + * Construct the i-th image-name using templates. + * If the template contains a '[' it must be of the form + * "prefix[start-end{+,-}step]suffix" + * where "{+,-}step" is optional. + * Leading zeros of "start" are significant. + * + * Example: + * "image0[12-01-1].pgm" yields image012.pgm, image011.pgm, ..., image001.pgm * * Return value: - * 1 on success - * 0 otherwise + * ptr to name of image 'ith_image' or NULL if ith_image is out of range. */ { - try - { - char const * const default_input [] = {"-", NULL}; - fiasco_c_options_t *default_options = NULL; - const c_options_t *cop; - char const * const *template; - - /* - * Check parameters - */ - if (!inputname || !inputname [0] || streq (inputname [0], "-")) - template = default_input; - else - template = inputname; - - if (quality <= 0) - { - set_error (_("Compression quality has to be positive.")); - return 0; - } - else if (quality >= 100) - { - warning (_("Quality typically is 1 (worst) to 100 (best).\n" - "Be prepared for a long running time.")); - } - - if (options) - { - cop = cast_c_options ((fiasco_c_options_t *) options); - if (!cop) - return 0; - } - else - { - default_options = fiasco_c_options_new (); - cop = cast_c_options (default_options); - } - - /* - * Open output stream and initialize WFA - */ - { - bitfile_t *output = open_bitfile (outputname, "FIASCO_DATA", - WRITE_ACCESS); - if (!output) - { - set_error (_("Can't write outputfile `%s'.\n%s"), - outputname ? outputname : "<stdout>", - get_system_error ()); - if (default_options) - fiasco_c_options_delete (default_options); - return 0; - } - else - { - wfa_t *wfa = alloc_wfa (YES); - coding_t *c = alloc_coder (template, cop, wfa->wfainfo); - - read_basis (cop->basis_name, wfa); - append_basis_states (wfa->basis_states, wfa, c); - - c->price = 128 * 64 / quality; - - video_coder (template, output, wfa, c); - - close_bitfile (output); - free_wfa (wfa); - free_coder (c); - - if (default_options) - fiasco_c_options_delete (default_options); - } - } - return 1; - } - catch - { - return 0; - } -} + while (*templptr) + { + const char *template = *templptr++; + char *s; + + if (!(s = strchr (template, '['))) /* no template, just a filename */ + { + if (ith_image == 0) + return strdup (template); + else + ith_image--; + } + else /* template parser */ + { + unsigned n_digits; /* # of digits in image name no. */ + char *s2; + char *suffix; /* characters after template end */ + char prefix [MAXSTRLEN]; /* chars up to the template start */ + unsigned first; /* first image number */ + unsigned last; /* last image number */ + int image_num; /* current image number */ + int increment = 1; + int dummy; + + strcpy (prefix, template); + prefix [s - template] = '\0'; + + for (s2 = ++s, n_digits = 0; ISDIGIT (*s2); s2++, n_digits++) + ; + if (sscanf (s, "%d", &dummy) == 0 || dummy < 0) + error ("Input name template conversion failure.\n" + "Check spelling of template."); + first = (unsigned) dummy; + + if (*s2++ != '-') + error ("Input name template conversion failure.\n" + "Check spelling of template."); + + for (s = s2; ISDIGIT (*s2); s2++) + ; + if (sscanf (s, "%d", &dummy) == 0 || dummy < 0) + error ("Input name template conversion failure.\n" + "Check spelling of template."); + last = (unsigned) dummy; + + if (*s2 == '+' || *s2 == '-') + { + for (s = s2++; ISDIGIT (*s2); s2++) + ; + if (sscanf (s, "%d", &increment) == 0) + error ("Input name template conversion failure.\n" + "Check spelling of template."); + } + if (*s2 != ']') + error ("Input name template conversion failure.\n" + "Check spelling of template."); + suffix = s2 + 1; + + image_num = first + increment * ith_image; + if (image_num < 0) + error ("Input name template conversion failure.\n" + "Check spelling of template."); + + if ((increment > 0 && (unsigned) image_num > last) || + (increment <= 0 && (unsigned) image_num < last)) + { + /* TODO: check this */ + ith_image -= (last - first) / increment + 1; + } + else + { + char formatstr [MAXSTRLEN]; + /* format string for image filename */ + char image_name [MAXSTRLEN]; + /* image file name to be composed */ + + strcpy (formatstr, "%s%0?d%s"); + formatstr [4] = '0' + (char) n_digits; + sprintf (image_name, formatstr, prefix, image_num, suffix); + return strdup (image_name); + } + } + } + return NULL; +} -/***************************************************************************** - private code - -*****************************************************************************/ static coding_t * -alloc_coder (char const * const *inputname, const c_options_t *options, - wfa_info_t *wi) +alloc_coder (char const * const * const inputname, + const c_options_t * const options, + wfa_info_t * const wi, + unsigned int const stdinwidth, + unsigned int const stdinheight, + xelval const stdinmaxval, + int const stdinformat) /* * Coder structure constructor. * Allocate memory for the FIASCO coder structure and * fill in default values specified by 'options'. * * Return value: - * pointer to the new coder structure or NULL on error + * pointer to the new coder structure or NULL on error */ { - coding_t *c = NULL; + coding_t * c; + + c = NULL; /* initial value */ /* * Check whether all specified image frames are readable and of same type */ - { - char *filename; - int width, w = 0, height, h = 0; - bool_t color, c = NO; - unsigned n; + { + char *filename; + int width, w = 0, height, h = 0; + bool_t color, c = NO; + unsigned n; - for (n = 0; (filename = get_input_image_name (inputname, n)); n++) - { - FILE *file; - xelval maxval; - int format; - if (filename == NULL) - file = stdin; - else - file = pm_openr(filename); - pnm_readpnminit(file, &width, &height, &maxval, &format); - color = (PNM_FORMAT_TYPE(format) == PPM_FORMAT) ? TRUE: FALSE; - - pm_close(file); - if (n) - { - if (w != width || h != height || c != color) - { - set_error (_("Format of image frame `%s' doesn't match."), - filename ? filename : "<stdin>"); - return NULL; - } - } - else - { - w = width; - h = height; - c = color; - } - Free (filename); - } - wi->frames = n; - wi->width = w; - wi->height = h; - wi->color = c; - } + for (n = 0; (filename = get_input_image_name (inputname, n)); n++) + { + xelval maxval; + int format; + if (streq(filename, "-")) { + width = stdinwidth; + height = stdinheight; + maxval = stdinmaxval; + format = stdinformat; + } else { + FILE *file; + + file = pm_openr(filename); + + pnm_readpnminit(file, &width, &height, &maxval, &format); + + pm_close(file); + } + color = (PNM_FORMAT_TYPE(format) == PPM_FORMAT) ? TRUE: FALSE; + + if (n > 0) + { + if (w != width || h != height || c != color) + { + set_error (_("Format of image frame `%s' doesn't match."), + filename ? filename : "<stdin>"); + return NULL; + } + } + else + { + w = width; + h = height; + c = color; + } + Free (filename); + } + wi->frames = n; + wi->width = w; + wi->height = h; + wi->color = c; + } - /* + /* * Levels ... */ - { - unsigned lx, ly; + { + unsigned lx, ly; - lx = (unsigned) (log2 (wi->width - 1) + 1); - ly = (unsigned) (log2 (wi->height - 1) + 1); + lx = (unsigned) (log2 (wi->width - 1) + 1); + ly = (unsigned) (log2 (wi->height - 1) + 1); - wi->level = max (lx, ly) * 2 - ((ly == lx + 1) ? 1 : 0); - } + wi->level = max (lx, ly) * 2 - ((ly == lx + 1) ? 1 : 0); + } - c = Calloc (1, sizeof (coding_t)); + c = Calloc (1, sizeof (coding_t)); - c->options = *options; - c->options.lc_min_level = max (options->lc_min_level, 3); - c->options.lc_max_level = min (options->lc_max_level, wi->level - 1); + c->options = *options; + c->options.lc_min_level = max (options->lc_min_level, 3); + c->options.lc_max_level = min (options->lc_max_level, wi->level - 1); - c->tiling = alloc_tiling (options->tiling_method, - options->tiling_exponent, wi->level); + c->tiling = alloc_tiling (options->tiling_method, + options->tiling_exponent, wi->level); - if (wi->frames > 1 && c->tiling->exponent > 0) - { - c->tiling->exponent = 0; - warning (_("Image tiling valid only with still image compression.")); - } + if (wi->frames > 1 && c->tiling->exponent > 0) + { + c->tiling->exponent = 0; + warning (_("Image tiling valid only with still image compression.")); + } - if (c->options.lc_max_level >= wi->level - c->tiling->exponent) - { - message ("'max_level' changed from %d to %d due to image tiling level.", - c->options.lc_max_level, wi->level - c->tiling->exponent - 1); - c->options.lc_max_level = wi->level - c->tiling->exponent - 1; - } + if (c->options.lc_max_level >= wi->level - c->tiling->exponent) + { + message ("'max_level' changed from %d to %d " + "due to image tiling level.", + c->options.lc_max_level, wi->level - c->tiling->exponent - 1); + c->options.lc_max_level = wi->level - c->tiling->exponent - 1; + } - if (c->options.lc_min_level > c->options.lc_max_level) - c->options.lc_min_level = c->options.lc_max_level; + if (c->options.lc_min_level > c->options.lc_max_level) + c->options.lc_min_level = c->options.lc_max_level; - /* - * p_min_level, p_max_level min and max level for ND/MC prediction - * [p_min_level, p_max_level] must be a subset of [min_level, max_level] ! - */ - wi->p_min_level = max (options->p_min_level, c->options.lc_min_level); - wi->p_max_level = min (options->p_max_level, c->options.lc_max_level); - if (wi->p_min_level > wi->p_max_level) - wi->p_min_level = wi->p_max_level; - - c->options.images_level = min (c->options.images_level, - c->options.lc_max_level - 1); + /* + * p_min_level, p_max_level min and max level for ND/MC prediction + * [p_min_level, p_max_level] must be a subset of [min_level, max_level] ! + */ + wi->p_min_level = max (options->p_min_level, c->options.lc_min_level); + wi->p_max_level = min (options->p_max_level, c->options.lc_max_level); + if (wi->p_min_level > wi->p_max_level) + wi->p_min_level = wi->p_max_level; + + c->options.images_level = min (c->options.images_level, + c->options.lc_max_level - 1); - c->products_level = max (0, ((signed int) c->options.lc_max_level - - (signed int) c->options.images_level - 1)); - c->pixels = Calloc (size_of_level (c->options.lc_max_level), - sizeof (real_t)); - c->images_of_state = Calloc (MAXSTATES, sizeof (real_t *)); - c->ip_images_state = Calloc (MAXSTATES, sizeof (real_t *)); - c->ip_states_state = Calloc (MAXSTATES * MAXLEVEL, sizeof (real_t *)); + c->products_level = max (0, ((signed int) c->options.lc_max_level + - (signed int) c->options.images_level - 1)); + c->pixels = Calloc (size_of_level (c->options.lc_max_level), + sizeof (real_t)); + c->images_of_state = Calloc (MAXSTATES, sizeof (real_t *)); + c->ip_images_state = Calloc (MAXSTATES, sizeof (real_t *)); + c->ip_states_state = Calloc (MAXSTATES * MAXLEVEL, sizeof (real_t *)); - debug_message ("Imageslevel :%d, Productslevel :%d", - c->options.images_level, c->products_level); - debug_message ("Memory : (%d + %d + %d * 'states') * 'states' + %d", - size_of_tree (c->options.images_level) * 4, - size_of_tree (c->products_level) * 4, - (c->options.lc_max_level - c->options.images_level), - size_of_level (c->options.lc_max_level)); + debug_message ("Imageslevel :%d, Productslevel :%d", + c->options.images_level, c->products_level); + debug_message ("Memory : (%d + %d + %d * 'states') * 'states' + %d", + size_of_tree (c->options.images_level) * 4, + size_of_tree (c->products_level) * 4, + (c->options.lc_max_level - c->options.images_level), + size_of_level (c->options.lc_max_level)); - /* + /* * Domain pools ... */ - c->domain_pool = NULL; - c->d_domain_pool = NULL; - - /* - * Coefficients model ... - */ - c->coeff = NULL; - c->d_coeff = NULL; - - /* - * Max. number of states and edges - */ - wi->max_states = max (min (options->max_states, MAXSTATES), 1); - c->options.max_elements = max (min (options->max_elements, MAXEDGES), 1); - - /* - * Title and comment strings - */ - wi->title = strdup (options->title); - wi->comment = strdup (options->comment); + c->domain_pool = NULL; + c->d_domain_pool = NULL; + + /* + * Coefficients model ... + */ + c->coeff = NULL; + c->d_coeff = NULL; + + /* + * Max. number of states and edges + */ + wi->max_states = max (min (options->max_states, MAXSTATES), 1); + c->options.max_elements = max (min (options->max_elements, MAXEDGES), 1); + + /* + * Title and comment strings + */ + wi->title = strdup (options->title); + wi->comment = strdup (options->comment); - /* - * Reduced precision format - */ - wi->rpf - = alloc_rpf (options->rpf_mantissa, options->rpf_range); - wi->dc_rpf - = alloc_rpf (options->dc_rpf_mantissa, options->dc_rpf_range); - wi->d_rpf - = alloc_rpf (options->d_rpf_mantissa, options->d_rpf_range); - wi->d_dc_rpf - = alloc_rpf (options->d_dc_rpf_mantissa, options->d_dc_rpf_range); + /* + * Reduced precision format + */ + wi->rpf + = alloc_rpf (options->rpf_mantissa, options->rpf_range); + wi->dc_rpf + = alloc_rpf (options->dc_rpf_mantissa, options->dc_rpf_range); + wi->d_rpf + = alloc_rpf (options->d_rpf_mantissa, options->d_rpf_range); + wi->d_dc_rpf + = alloc_rpf (options->d_dc_rpf_mantissa, options->d_dc_rpf_range); - /* - * Color image options ... - */ - wi->chroma_max_states = max (1, options->chroma_max_states); + /* + * Color image options ... + */ + wi->chroma_max_states = max (1, options->chroma_max_states); - /* + /* * Set up motion compensation struct. * p_min_level, p_max_level are also used for ND prediction */ - wi->search_range = options->search_range; - wi->fps = options->fps; - wi->half_pixel = options->half_pixel_prediction; - wi->cross_B_search = options->half_pixel_prediction; - wi->B_as_past_ref = options->B_as_past_ref; - wi->smoothing = options->smoothing; + wi->search_range = options->search_range; + wi->fps = options->fps; + wi->half_pixel = options->half_pixel_prediction; + wi->cross_B_search = options->half_pixel_prediction; + wi->B_as_past_ref = options->B_as_past_ref; + wi->smoothing = options->smoothing; - c->mt = alloc_motion (wi); + c->mt = alloc_motion (wi); - return c; + return c; } + + static void free_coder (coding_t *c) /* @@ -384,7 +377,7 @@ free_coder (coding_t *c) * No return value. * * Side effects: - * structure 'coder' is discarded. + * structure 'coder' is discarded. */ { free_tiling (c->tiling); @@ -397,285 +390,8 @@ free_coder (coding_t *c) Free (c); } -static char * -get_input_image_name (char const * const *templptr, unsigned ith_image) -/* - * Construct the i-th image-name using templates. - * If the template contains a '[' it must be of the form - * "prefix[start-end{+,-}step]suffix" - * where "{+,-}step" is optional. - * Leading zeros of "start" are significant. - * - * Example: - * "image0[12-01-1].pgm" yields image012.pgm, image011.pgm, ..., image001.pgm - * - * Return value: - * ptr to name of image 'ith_image' or NULL if ith_image is out of range. - */ -{ - while (*templptr) - { - const char *template = *templptr++; - char *s; - - if (!(s = strchr (template, '['))) /* no template, just a filename */ - { - if (ith_image == 0) - return strdup (template); - else - ith_image--; - } - else /* template parser */ - { - unsigned n_digits; /* # of digits in image name no. */ - char *s2; - char *suffix; /* characters after template end */ - char prefix [MAXSTRLEN]; /* chars up to the template start */ - unsigned first; /* first image number */ - unsigned last; /* last image number */ - int image_num; /* current image number */ - int increment = 1; - int dummy; - - strcpy (prefix, template); - prefix [s - template] = '\0'; - - for (s2 = ++s, n_digits = 0; ISDIGIT (*s2); s2++, n_digits++) - ; - if (sscanf (s, "%d", &dummy) == 0 || dummy < 0) - error ("Input name template conversion failure.\n" - "Check spelling of template."); - first = (unsigned) dummy; - - if (*s2++ != '-') - error ("Input name template conversion failure.\n" - "Check spelling of template."); - - for (s = s2; ISDIGIT (*s2); s2++) - ; - if (sscanf (s, "%d", &dummy) == 0 || dummy < 0) - error ("Input name template conversion failure.\n" - "Check spelling of template."); - last = (unsigned) dummy; - - if (*s2 == '+' || *s2 == '-') - { - for (s = s2++; ISDIGIT (*s2); s2++) - ; - if (sscanf (s, "%d", &increment) == 0) - error ("Input name template conversion failure.\n" - "Check spelling of template."); - } - if (*s2 != ']') - error ("Input name template conversion failure.\n" - "Check spelling of template."); - suffix = s2 + 1; - - image_num = first + increment * ith_image; - if (image_num < 0) - error ("Input name template conversion failure.\n" - "Check spelling of template."); - - if ((increment > 0 && (unsigned) image_num > last) || - (increment <= 0 && (unsigned) image_num < last)) - { - /* TODO: check this */ - ith_image -= (last - first) / increment + 1; - } - else - { - char formatstr [MAXSTRLEN]; /* format string for image filename */ - char image_name [MAXSTRLEN]; /* image file name to be composed */ - - strcpy (formatstr, "%s%0?d%s"); - formatstr [4] = '0' + (char) n_digits; - sprintf (image_name, formatstr, prefix, image_num, suffix); - return strdup (image_name); - } - } - } - return NULL; -} - -static void -video_coder (char const * const *image_template, bitfile_t *output, - wfa_t *wfa, coding_t *c) -/* - * Toplevel function to encode a sequence of video frames specified - * by 'image_template'. The output is written to stream 'output'. - * Coding options are given by 'c'. - * - * No return value. - */ -{ - unsigned display; /* picture number in display order */ - int future_display; /* number of future reference */ - int frame; /* current frame number */ - char *image_name; /* image name of current frame */ - image_t *reconst = NULL; /* decoded reference image */ - bool_t future_frame = NO; /* YES if last frame was in future */ - - debug_message ("Generating %d WFA's ...", wfa->wfainfo->frames); - - future_display = -1; - frame = -1; - display = 0; - - while ((image_name = get_input_image_name (image_template, display))) - { - frame_type_e type; /* current frame type: I, B, P */ - - /* - * Determine type of next frame. - * Skip already coded frames (future reference!) - */ - if (display == 0 && !c->options.reference_filename) - type = I_FRAME; /* Force first frame to be intra */ - else - type = pattern2type (display, c->options.pattern); - - if (type != I_FRAME && c->options.reference_filename) - /* Load reference from disk */ - { - debug_message ("Reading reference frame `%s'.", - c->options.reference_filename); - reconst = read_image (c->options.reference_filename); - c->options.reference_filename = NULL; - } - if ((int) display == future_display) /* Skip already coded future ref */ - { - display++; - continue; - } - else if (type == B_FRAME && (int) display > future_display) - { - unsigned i = display; - /* - * Search for future reference - */ - while (type == B_FRAME) - { - char *name; /* image name of future frame */ - - i++; - name = get_input_image_name (image_template, i); - - if (!name) /* Force last valid frame to be 'P' */ - { - future_display = i - 1; - type = P_FRAME; - } - else - { - future_display = i; - image_name = name; - type = pattern2type (i, c->options.pattern); - } - frame = future_display; - } - } - else - { - frame = display; - display++; - } - - debug_message ("Coding \'%s\' [%c-frame].", image_name, - type == I_FRAME ? 'I' : (type == P_FRAME ? 'P' : 'B')); - - /* - * Depending on current frame type update past and future frames - * which are needed as reference frames. - */ - c->mt->frame_type = type; - if (type == I_FRAME) - { - if (c->mt->past) /* discard past frame */ - free_image (c->mt->past); - c->mt->past = NULL; - if (c->mt->future) /* discard future frame */ - free_image (c->mt->future); - c->mt->future = NULL; - if (reconst) /* discard current frame */ - free_image (reconst); - reconst = NULL; - } - else if (type == P_FRAME) - { - if (c->mt->past) /* discard past frame */ - free_image (c->mt->past); - c->mt->past = reconst; /* past frame <- current frame */ - reconst = NULL; - if (c->mt->future) /* discard future frame */ - free_image (c->mt->future); - c->mt->future = NULL; - } - else /* B_FRAME */ - { - if (future_frame) /* last frame was future frame */ - { - if (c->mt->future) /* discard future frame */ - free_image (c->mt->future); - c->mt->future = reconst; /* future frame <- current frame */ - reconst = NULL; - } - else - { - if (wfa->wfainfo->B_as_past_ref == YES) - { - if (c->mt->past) /* discard past frame */ - free_image (c->mt->past); - c->mt->past = reconst; /* past frame <- current frame */ - reconst = NULL; - } - else - { - if (reconst) /* discard current frame */ - free_image (reconst); - reconst = NULL; - } - } - } - - /* - * Start WFA coding of current frame - */ - future_frame = frame == future_display; - c->mt->number = frame; - c->mt->original = read_image (image_name); - if (c->tiling->exponent && type == I_FRAME) - perform_tiling (c->mt->original, c->tiling); - - frame_coder (wfa, c, output); - - /* - * Regenerate image: - * 1. Compute approximation of WFA ranges (real image bintree order) - * 2. Generate byte image in rasterscan order - * 3. Apply motion compensation - */ - reconst = decode_image (wfa->wfainfo->width, wfa->wfainfo->height, - FORMAT_4_4_4, NULL, wfa); - - if (type != I_FRAME) - restore_mc (0, reconst, c->mt->past, c->mt->future, wfa); - if (c->mt->original) - free_image (c->mt->original); - c->mt->original = NULL; - - remove_states (wfa->basis_states, wfa); /* Clear WFA structure */ - } - if (reconst) - free_image (reconst); - if (c->mt->future) - free_image (c->mt->future); - if (c->mt->past) - free_image (c->mt->past); - if (c->mt->original) - free_image (c->mt->original); -} static frame_type_e pattern2type (unsigned frame, const char *pattern) @@ -700,6 +416,72 @@ pattern2type (unsigned frame, const char *pattern) return retval; } + + +static void +print_statistics (char c, real_t costs, const wfa_t *wfa, const image_t *image, + const range_t *range) +{ + unsigned max_level, min_level, state, label, lincomb; + + for (max_level = 0, min_level = MAXLEVEL, state = wfa->basis_states; + state < wfa->states; state++) + { + for (lincomb = 0, label = 0; label < MAXLABELS; label++) + lincomb += isrange(wfa->tree[state][label]) ? 1 : 0; + + if (lincomb) + { + max_level = max (max_level, + (unsigned) (wfa->level_of_state [state] - 1)); + min_level = min (min_level, + (unsigned) (wfa->level_of_state [state] - 1)); + } + } + debug_message ("Image partitioning: maximum level %d , minimum level %d", + max_level, min_level); + debug_message ("WFA contains %d states (%d basis states).", + wfa->states, wfa->basis_states); + debug_message ("Estimated error: %.2f (RMSE: %.2f, PSNR: %.2f dB).", + (double) range->err, + sqrt (range->err / image->width / image->height), + 10 * log ( 255.0 * 255.0 / + (range->err / image->width / image->height)) + / log (10.0)); + debug_message ("Estimated filesize: %.0f bits (%.0f bytes).", + (double) (range->tree_bits + range->matrix_bits + + range->weights_bits + + range->mv_tree_bits + range->mv_coord_bits + + range->nd_tree_bits + range->nd_weights_bits), + (double) (range->tree_bits + range->matrix_bits + + range->weights_bits + range->mv_tree_bits + + range->mv_coord_bits + range->nd_tree_bits + + range->nd_weights_bits) / 8); + if (c) + debug_message ("(%cT: %.0f, %cM: %.0f, %cW: %.0f, %cMC: %.0f, " + "%cMV: %.0f, %cNT: %.0f, %cNW: %.0f.)", + c, (double) range->tree_bits, + c, (double) range->matrix_bits, + c, (double) range->weights_bits, + c, (double) range->mv_tree_bits, + c, (double) range->mv_coord_bits, + c, (double) range->nd_tree_bits, + c, (double) range->nd_weights_bits); + else + debug_message ("(T: %.0f, M: %.0f, W: %.0f, MC: %.0f, MV: %.0f, " + "NT: %.0f, NW: %.0f.)", + (double) range->tree_bits, + (double) range->matrix_bits, + (double) range->weights_bits, + (double) range->mv_tree_bits, + (double) range->mv_coord_bits, + (double) range->nd_tree_bits, + (double) range->nd_weights_bits); + debug_message ("Total costs : %.2f", (double) costs); +} + + + static void frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) /* @@ -712,9 +494,9 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) */ { unsigned state; - range_t range; /* first range == the entire image */ - real_t costs; /* total costs (minimized quantity) */ - unsigned bits; /* number of bits written on disk */ + range_t range; /* first range == the entire image */ + real_t costs; /* total costs (minimized quantity) */ + unsigned bits; /* number of bits written on disk */ clock_t ptimer; prg_timer (&ptimer, START); @@ -726,48 +508,48 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) c->domain_pool = alloc_domain_pool (c->options.id_domain_pool, - wfa->wfainfo->max_states, - c->options.max_elements, wfa); + wfa->wfainfo->max_states, + c->options.max_elements, wfa); c->d_domain_pool = alloc_domain_pool ((c->options.prediction - || c->mt->frame_type != I_FRAME) - ? c->options.id_d_domain_pool : "constant", - wfa->wfainfo->max_states, - c->options.max_elements, wfa); + || c->mt->frame_type != I_FRAME) + ? c->options.id_d_domain_pool : "constant", + wfa->wfainfo->max_states, + c->options.max_elements, wfa); c->coeff = alloc_coeff_model (c->options.id_rpf_model, - wfa->wfainfo->rpf, - wfa->wfainfo->dc_rpf, - c->options.lc_min_level, - c->options.lc_max_level); + wfa->wfainfo->rpf, + wfa->wfainfo->dc_rpf, + c->options.lc_min_level, + c->options.lc_max_level); c->d_coeff = alloc_coeff_model (c->options.id_d_rpf_model, - wfa->wfainfo->d_rpf, - wfa->wfainfo->d_dc_rpf, - c->options.lc_min_level, - c->options.lc_max_level); + wfa->wfainfo->d_rpf, + wfa->wfainfo->d_dc_rpf, + c->options.lc_min_level, + c->options.lc_max_level); - if (!c->mt->original->color) /* grayscale image */ + if (!c->mt->original->color) /* grayscale image */ { memset (&range, 0, sizeof (range_t)); range.level = wfa->wfainfo->level; costs = subdivide (MAXCOSTS, GRAY, RANGE, &range, wfa, c, - c->options.prediction || c->mt->frame_type != I_FRAME, - NO); + c->options.prediction || c->mt->frame_type != I_FRAME, + NO); if (c->options.progress_meter != FIASCO_PROGRESS_NONE) - message (""); + message (""); - if (isrange (range.tree)) /* entire image is approx. by lc? */ - error ("No root state generated!"); + if (isrange (range.tree)) /* entire image is approx. by lc? */ + error ("No root state generated!"); else - wfa->root_state = range.tree; + wfa->root_state = range.tree; print_statistics ('\0', costs, wfa, c->mt->original, &range); } else { int YCb_node = -1; - int tree [3]; /* 3 root states of each color comp. */ + int tree [3]; /* 3 root states of each color comp. */ color_e band; /* @@ -781,62 +563,62 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) */ for (band = first_band (YES); band <= last_band (YES) ; band++) { - debug_message ("Encoding color component %d", band); - tree [band] = RANGE; - if (band == Cb) - { - unsigned min_level; - - c->domain_pool->chroma (wfa->wfainfo->chroma_max_states, wfa, - c->domain_pool->model); - /* - * Don't use a finer partioning for the chrominancy bands than for - * the luminancy band. - */ - for (min_level = MAXLEVEL, state = wfa->basis_states; - state < wfa->states; state++) - { - unsigned lincomb, label; - - for (lincomb = 0, label = 0; label < MAXLABELS; label++) - lincomb += isrange (wfa->tree [state][label]) ? 1 : 0; - if (lincomb) - min_level = min (min_level, - (unsigned) (wfa->level_of_state [state] - - 1)); - } - c->options.lc_min_level = min_level; - if (c->mt->frame_type != I_FRAME) /* subtract mc of luminance */ - subtract_mc (c->mt->original, c->mt->past, c->mt->future, wfa); - } - - memset (&range, 0, sizeof (range_t)); - range.level = wfa->wfainfo->level; - - costs = subdivide (MAXCOSTS, band, tree [Y], &range, wfa, c, - c->mt->frame_type != I_FRAME && band == Y, NO); - if (c->options.progress_meter != FIASCO_PROGRESS_NONE) - message (""); - { - char colors [] = {'Y', 'B', 'R'}; - - print_statistics (colors [band], costs, wfa, - c->mt->original, &range); - } - - if (isrange (range.tree)) /* whole image is approx. by a l.c. */ - error ("No root state generated for color component %d!", band); - else - tree[band] = range.tree; - - if (band == Cb) - { - wfa->tree [wfa->states][0] = tree[Y]; - wfa->tree [wfa->states][1] = tree[Cb]; - YCb_node = wfa->states; - append_state (YES, compute_final_distribution (wfa->states, wfa), - wfa->wfainfo->level + 1, wfa, c); - } + debug_message ("Encoding color component %d", band); + tree [band] = RANGE; + if (band == Cb) + { + unsigned min_level; + + c->domain_pool->chroma (wfa->wfainfo->chroma_max_states, wfa, + c->domain_pool->model); + /* + * Don't use a finer partioning for the chrominancy bands than for + * the luminancy band. + */ + for (min_level = MAXLEVEL, state = wfa->basis_states; + state < wfa->states; state++) + { + unsigned lincomb, label; + + for (lincomb = 0, label = 0; label < MAXLABELS; label++) + lincomb += isrange (wfa->tree [state][label]) ? 1 : 0; + if (lincomb) + min_level = min (min_level, + (unsigned) (wfa->level_of_state [state] + - 1)); + } + c->options.lc_min_level = min_level; + if (c->mt->frame_type != I_FRAME) /* subtract mc of luminance */ + subtract_mc (c->mt->original, c->mt->past, c->mt->future, wfa); + } + + memset (&range, 0, sizeof (range_t)); + range.level = wfa->wfainfo->level; + + costs = subdivide (MAXCOSTS, band, tree [Y], &range, wfa, c, + c->mt->frame_type != I_FRAME && band == Y, NO); + if (c->options.progress_meter != FIASCO_PROGRESS_NONE) + message (""); + { + char colors [] = {'Y', 'B', 'R'}; + + print_statistics (colors [band], costs, wfa, + c->mt->original, &range); + } + + if (isrange (range.tree)) /* whole image is approx. by a l.c. */ + error ("No root state generated for color component %d!", band); + else + tree[band] = range.tree; + + if (band == Cb) + { + wfa->tree [wfa->states][0] = tree[Y]; + wfa->tree [wfa->states][1] = tree[Cb]; + YCb_node = wfa->states; + append_state (YES, compute_final_distribution (wfa->states, wfa), + wfa->wfainfo->level + 1, wfa, c); + } } /* * generate two virtual states (*) @@ -850,11 +632,11 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) wfa->tree [wfa->states][0] = tree[Cr]; wfa->tree [wfa->states][1] = RANGE; append_state (YES, compute_final_distribution (wfa->states, wfa), - wfa->wfainfo->level + 1, wfa, c); + wfa->wfainfo->level + 1, wfa, c); wfa->tree[wfa->states][0] = YCb_node; wfa->tree[wfa->states][1] = wfa->states - 1; append_state (YES, compute_final_distribution (wfa->states, wfa), - wfa->wfainfo->level + 2, wfa, c); + wfa->wfainfo->level + 2, wfa, c); wfa->root_state = wfa->states - 1; } @@ -865,22 +647,22 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) if (c->images_of_state [state]) { - Free (c->images_of_state [state]); - c->images_of_state [state] = NULL; + Free (c->images_of_state [state]); + c->images_of_state [state] = NULL; } if (c->ip_images_state [state]) { - Free (c->ip_images_state [state]); - c->ip_images_state [state] = NULL; + Free (c->ip_images_state [state]); + c->ip_images_state [state] = NULL; } for (level = c->options.images_level + 1; - level <= c->options.lc_max_level; - level++) - if (c->ip_states_state [state][level]) - { - Free (c->ip_states_state [state][level]); - c->ip_states_state [state][level] = NULL; - } + level <= c->options.lc_max_level; + level++) + if (c->ip_states_state [state][level]) + { + Free (c->ip_states_state [state][level]); + c->ip_states_state [state][level] = NULL; + } } @@ -889,11 +671,11 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) bits = bits_processed (output) - bits; debug_message ("Total number of bits written: %d (%d bytes, %5.3f bpp)", - bits, bits >> 3, - bits / (double) (c->mt->original->height - * c->mt->original->width)); + bits, bits >> 3, + bits / (double) (c->mt->original->height + * c->mt->original->width)); debug_message ("Total encoding time (real): %d sec", - prg_timer (&ptimer, STOP) / 1000); + prg_timer (&ptimer, STOP) / 1000); c->domain_pool->free (c->domain_pool); c->d_domain_pool->free (c->d_domain_pool); @@ -902,64 +684,356 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) c->d_coeff->free (c->d_coeff); } + + static void -print_statistics (char c, real_t costs, const wfa_t *wfa, const image_t *image, - const range_t *range) +video_coder(char const * const * const image_template, + bitfile_t * const output, + wfa_t * const wfa, + coding_t * const c, + unsigned int const stdinwidth, + unsigned int const stdinheight, + unsigned int const stdinmaxval, + unsigned int const stdinformat) +/* + * Toplevel function to encode a sequence of video frames specified + * by 'image_template'. The output is written to stream 'output'. + * Coding options are given by 'c'. + * + * No return value. + */ { - unsigned max_level, min_level, state, label, lincomb; + unsigned display; /* picture number in display order */ + int future_display; /* number of future reference */ + int frame; /* current frame number */ + char *image_name; + /* image name of current frame. File name or "-" for Standard Input */ + image_t *reconst = NULL; /* decoded reference image */ + bool_t future_frame = NO; /* YES if last frame was in future */ - for (max_level = 0, min_level = MAXLEVEL, state = wfa->basis_states; - state < wfa->states; state++) - { - for (lincomb = 0, label = 0; label < MAXLABELS; label++) - lincomb += isrange(wfa->tree[state][label]) ? 1 : 0; - - if (lincomb) - { - max_level = max (max_level, - (unsigned) (wfa->level_of_state [state] - 1)); - min_level = min (min_level, - (unsigned) (wfa->level_of_state [state] - 1)); - } - } - debug_message ("Image partitioning: maximum level %d , minimum level %d", - max_level, min_level); - debug_message ("WFA contains %d states (%d basis states).", - wfa->states, wfa->basis_states); - debug_message ("Estimated error: %.2f (RMSE: %.2f, PSNR: %.2f dB).", - (double) range->err, - sqrt (range->err / image->width / image->height), - 10 * log ( 255.0 * 255.0 / - (range->err / image->width / image->height)) - / log (10.0)); - debug_message ("Estimated filesize: %.0f bits (%.0f bytes).", - (double) (range->tree_bits + range->matrix_bits - + range->weights_bits - + range->mv_tree_bits + range->mv_coord_bits - + range->nd_tree_bits + range->nd_weights_bits), - (double) (range->tree_bits + range->matrix_bits - + range->weights_bits + range->mv_tree_bits - + range->mv_coord_bits + range->nd_tree_bits - + range->nd_weights_bits) / 8); - if (c) - debug_message ("(%cT: %.0f, %cM: %.0f, %cW: %.0f, %cMC: %.0f, " - "%cMV: %.0f, %cNT: %.0f, %cNW: %.0f.)", - c, (double) range->tree_bits, - c, (double) range->matrix_bits, - c, (double) range->weights_bits, - c, (double) range->mv_tree_bits, - c, (double) range->mv_coord_bits, - c, (double) range->nd_tree_bits, - c, (double) range->nd_weights_bits); - else - debug_message ("(T: %.0f, M: %.0f, W: %.0f, MC: %.0f, MV: %.0f, " - "NT: %.0f, NW: %.0f.)", - (double) range->tree_bits, - (double) range->matrix_bits, - (double) range->weights_bits, - (double) range->mv_tree_bits, - (double) range->mv_coord_bits, - (double) range->nd_tree_bits, - (double) range->nd_weights_bits); - debug_message ("Total costs : %.2f", (double) costs); + debug_message ("Generating %d WFA's ...", wfa->wfainfo->frames); + + future_display = -1; + frame = -1; + display = 0; + + while ((image_name = get_input_image_name (image_template, display))) + { + frame_type_e type; /* current frame type: I, B, P */ + + /* + * Determine type of next frame. + * Skip already coded frames (future reference!) + */ + if (display == 0 && !c->options.reference_filename) + type = I_FRAME; /* Force first frame to be intra */ + else + type = pattern2type (display, c->options.pattern); + + if (type != I_FRAME && c->options.reference_filename) + /* Load reference from disk */ + { + debug_message ("Reading reference frame `%s'.", + c->options.reference_filename); + reconst = read_image_file (c->options.reference_filename); + c->options.reference_filename = NULL; + } + if ((int) display == future_display) + { + /* Skip already coded future ref */ + display++; + continue; + } + else if (type == B_FRAME && (int) display > future_display) + { + unsigned i = display; + /* + * Search for future reference + */ + while (type == B_FRAME) + { + char *name; /* image name of future frame */ + + i++; + name = get_input_image_name (image_template, i); + + if (!name) /* Force last valid frame to be 'P' */ + { + future_display = i - 1; + type = P_FRAME; + } + else + { + future_display = i; + image_name = name; + type = pattern2type (i, c->options.pattern); + } + frame = future_display; + } + } + else + { + frame = display; + display++; + } + + debug_message ("Coding \'%s\' [%c-frame].", image_name, + type == I_FRAME ? 'I' : (type == P_FRAME ? 'P' : 'B')); + + /* + * Depending on current frame type update past and future frames + * which are needed as reference frames. + */ + c->mt->frame_type = type; + if (type == I_FRAME) + { + if (c->mt->past) /* discard past frame */ + free_image (c->mt->past); + c->mt->past = NULL; + if (c->mt->future) /* discard future frame */ + free_image (c->mt->future); + c->mt->future = NULL; + if (reconst) /* discard current frame */ + free_image (reconst); + reconst = NULL; + } + else if (type == P_FRAME) + { + if (c->mt->past) /* discard past frame */ + free_image (c->mt->past); + c->mt->past = reconst; /* past frame <- current frame */ + reconst = NULL; + if (c->mt->future) /* discard future frame */ + free_image (c->mt->future); + c->mt->future = NULL; + } + else /* B_FRAME */ + { + if (future_frame) /* last frame was future frame */ + { + if (c->mt->future) /* discard future frame */ + free_image (c->mt->future); + c->mt->future = reconst; /* future frame <- current frame */ + reconst = NULL; + } + else + { + if (wfa->wfainfo->B_as_past_ref == YES) + { + if (c->mt->past) /* discard past frame */ + free_image (c->mt->past); + c->mt->past = reconst; /* past frame <- current frame */ + reconst = NULL; + } + else + { + if (reconst) /* discard current frame */ + free_image (reconst); + reconst = NULL; + } + } + } + + /* + * Start WFA coding of current frame + */ + future_frame = frame == future_display; + c->mt->number = frame; + + if (streq(image_name, "-")) + c->mt->original = read_image_stream(stdin, + stdinwidth, stdinheight, + stdinmaxval, stdinformat); + else + c->mt->original = read_image_file(image_name); + + if (c->tiling->exponent && type == I_FRAME) + perform_tiling (c->mt->original, c->tiling); + + frame_coder (wfa, c, output); + + /* + * Regenerate image: + * 1. Compute approximation of WFA ranges (real image bintree order) + * 2. Generate byte image in rasterscan order + * 3. Apply motion compensation + */ + reconst = decode_image (wfa->wfainfo->width, wfa->wfainfo->height, + FORMAT_4_4_4, NULL, wfa); + + if (type != I_FRAME) + restore_mc (0, reconst, c->mt->past, c->mt->future, wfa); + + if (c->mt->original) + free_image (c->mt->original); + c->mt->original = NULL; + + remove_states (wfa->basis_states, wfa); /* Clear WFA structure */ + } + + if (reconst) + free_image (reconst); + if (c->mt->future) + free_image (c->mt->future); + if (c->mt->past) + free_image (c->mt->past); + if (c->mt->original) + free_image (c->mt->original); +} + + + +static void +read_stdin_header(const char * const * const template, + unsigned int * const widthP, + unsigned int * const heightP, + xelval * const maxvalP, + int * const formatP) +/* Read the PNM header from the Standard Input stream, if 'template' says + one of the images is to come from Standard Input. + + Return the contents of that stream as *widthP, etc. +*/ +{ + unsigned int i; + bool endOfList; + bool stdinFound; + + for (i = 0, stdinFound = FALSE, endOfList = FALSE; !endOfList; ++i) { + const char * const name = get_input_image_name(template, i); + + if (!name) + endOfList = TRUE; + else { + if (streq(name, "-")) + stdinFound = TRUE; + } + } + + if (stdinFound) { + int width, height; + + pnm_readpnminit(stdin, &width, &height, maxvalP, formatP); + + *widthP = width; + *heightP = height; + } } + + + +/***************************************************************************** + + public code + +*****************************************************************************/ + +int +fiasco_coder (char const * const *inputname, const char *outputname, + float quality, const fiasco_c_options_t *options) +/* + * FIASCO coder. + * Encode image or video frames given by the array of filenames `inputname' + * and write to the outputfile `outputname'. + * If 'inputname' = NULL or + * 'inputname [0]' == NULL or + * 'inputname [0]' == "-", read standard input. + * If 'outputname' == NULL or "-", write on standard output. + * 'quality' defines the approximation quality and is 1 (worst) to 100 (best). + * + * Return value: + * 1 on success + * 0 otherwise + */ +{ + try + { + char const * const default_input [] = {"-", NULL}; + fiasco_c_options_t *default_options = NULL; + const c_options_t *cop; + char const * const *template; + unsigned int stdinheight, stdinwidth; + xelval stdinmaxval; + int stdinformat; + + /* + * Check parameters + */ + if (!inputname || !inputname [0] || streq (inputname [0], "-")) + template = default_input; + else + template = inputname; + + if (quality <= 0) + { + set_error (_("Compression quality has to be positive.")); + return 0; + } + else if (quality >= 100) + { + warning (_("Quality typically is 1 (worst) to 100 (best).\n" + "Be prepared for a long running time.")); + } + + if (options) + { + cop = cast_c_options ((fiasco_c_options_t *) options); + if (!cop) + return 0; + } + else + { + default_options = fiasco_c_options_new (); + cop = cast_c_options (default_options); + } + + read_stdin_header(template, &stdinwidth, &stdinheight, + &stdinmaxval, &stdinformat); + + /* + * Open output stream and initialize WFA + */ + { + bitfile_t *output = open_bitfile (outputname, "FIASCO_DATA", + WRITE_ACCESS); + if (!output) + { + set_error (_("Can't write outputfile `%s'.\n%s"), + outputname ? outputname : "<stdout>", + get_system_error ()); + if (default_options) + fiasco_c_options_delete (default_options); + return 0; + } + else + { + wfa_t *wfa = alloc_wfa (YES); + coding_t *c = alloc_coder(template, cop, wfa->wfainfo, + stdinwidth, stdinheight, + stdinmaxval, stdinformat); + + read_basis (cop->basis_name, wfa); + append_basis_states (wfa->basis_states, wfa, c); + + c->price = 128 * 64 / quality; + + video_coder (template, output, wfa, c, + stdinwidth, stdinheight, stdinmaxval, + stdinformat); + + close_bitfile (output); + free_wfa (wfa); + free_coder (c); + + if (default_options) + fiasco_c_options_delete (default_options); + } + } + return 1; + } + catch + { + return 0; + } +} + diff --git a/converter/other/fiasco/codec/decoder.c b/converter/other/fiasco/codec/decoder.c index c3982617..ab06dd2e 100644 --- a/converter/other/fiasco/codec/decoder.c +++ b/converter/other/fiasco/codec/decoder.c @@ -1,9 +1,9 @@ /* - * decode.c: Decoding of an image represented by a WFA + * decode.c: Decoding of an image represented by a WFA * - * Written by: Ullrich Hafner - * Michael Unger - * + * Written by: Ullrich Hafner + * Michael Unger + * * This file is part of FIASCO («F»ractal «I»mage «A»nd «S»equence «CO»dec) * Copyright (C) 1994-2000 Ullrich Hafner <hafner@bigfoot.de> */ @@ -15,12 +15,13 @@ * $State: Exp $ */ +#include "pm_config.h" #include "config.h" #if HAVE_STRING_H -# include <string.h> +# include <string.h> #else /* not HAVE_STRING_H */ -# include <strings.h> +# include <strings.h> #endif /* not HAVE_STRING_H */ #include "types.h" @@ -37,33 +38,33 @@ /***************************************************************************** - prototypes + prototypes *****************************************************************************/ static void compute_state_images (unsigned frame_level, word_t **simg, - const u_word_t *offset, const wfa_t *wfa); + const u_word_t *offset, const wfa_t *wfa); static void free_state_images (unsigned max_level, bool_t color, word_t **state_image, - u_word_t *offset, const unsigned *root_state, - unsigned range_state, format_e format, const wfa_t *wfa); + u_word_t *offset, const unsigned *root_state, + unsigned range_state, format_e format, const wfa_t *wfa); static void alloc_state_images (word_t ***images, u_word_t **offsets, const image_t *frame, - const unsigned *root_state, unsigned range_state, - unsigned max_level, format_e format, const wfa_t *wfa); + const unsigned *root_state, unsigned range_state, + unsigned max_level, format_e format, const wfa_t *wfa); static void compute_actual_size (unsigned luminance_root, - unsigned *width, unsigned *height, const wfa_t *wfa); + unsigned *width, unsigned *height, const wfa_t *wfa); static void enlarge_image (int enlarge_factor, format_e format, unsigned y_root, - wfa_t *wfa); + wfa_t *wfa); static word_t * duplicate_state_image (const word_t *domain, unsigned offset, unsigned level); /***************************************************************************** - public code + public code *****************************************************************************/ @@ -75,7 +76,7 @@ alloc_video (bool_t store_wfa) * and future WFA if flag 'store_wfa' is TRUE. * * Return value: - * pointer to the new video structure + * pointer to the new video structure */ { video_t *video = Calloc (1, sizeof (video_t)); @@ -84,7 +85,7 @@ alloc_video (bool_t store_wfa) video->display = 0; video->future = video->sfuture = video->past - = video->frame = video->sframe = NULL; + = video->frame = video->sframe = NULL; if (store_wfa) { @@ -107,7 +108,7 @@ free_video (video_t *video) * No return value. * * Side effects: - * 'video' struct is discarded. + * 'video' struct is discarded. */ { if (video->past) @@ -132,9 +133,9 @@ free_video (video_t *video) image_t * get_next_frame (bool_t store_wfa, int enlarge_factor, - int smoothing, const char *reference_frame, - format_e format, video_t *video, dectimer_t *timer, - wfa_t *orig_wfa, bitfile_t *input) + int smoothing, const char *reference_frame, + format_e format, video_t *video, dectimer_t *timer, + wfa_t *orig_wfa, bitfile_t *input) /* * Get next frame of the WFA 'video' from stream 'input'. * 'orig_wfa' is the constant part of the WFA used by all frames. @@ -148,265 +149,265 @@ get_next_frame (bool_t store_wfa, int enlarge_factor, * If 'timer' is not NULL, then accumulate running time statistics. * * Return value: - * pointer to decoded frame + * pointer to decoded frame * * Side effects: - * 'video' and 'timer' struct are modified. + * 'video' and 'timer' struct are modified. */ { - image_t *frame = NULL; /* current frame */ - image_t *sframe = NULL; /* current smoothed frame */ + image_t *frame = NULL; /* current frame */ + image_t *sframe = NULL; /* current smoothed frame */ bool_t current_frame_is_future_frame = NO; - if (video->future_display == video->display) + if (video->future_display == video->display) { /* * Future frame is already computed since it has been used * as reference frame. So just return the stored frame. */ if (video->frame) /* discard current frame */ - free_image (video->frame); + free_image (video->frame); video->frame = video->future; video->future = NULL; if (video->sframe) /* discard current (smoothed) frame */ - free_image (video->sframe); + free_image (video->sframe); video->sframe = video->sfuture; video->sfuture = NULL; if (store_wfa) - copy_wfa (video->wfa, video->wfa_future); + copy_wfa (video->wfa, video->wfa_future); video->display++; if (!store_wfa) - video->wfa = NULL; + video->wfa = NULL; } else { - do /* compute next frame(s) */ + do /* compute next frame(s) */ { - unsigned frame_number; /* current frame number */ - clock_t ptimer; - unsigned int stop_timer [3]; - wfa_t *tmp_wfa = NULL; - - if (!store_wfa) - video->wfa = orig_wfa; - else - { - tmp_wfa = alloc_wfa (NO); - copy_wfa (tmp_wfa, video->wfa); - copy_wfa (video->wfa, orig_wfa); - } + unsigned frame_number; /* current frame number */ + clock_t ptimer; + unsigned int stop_timer [3]; + wfa_t *tmp_wfa = NULL; + + if (!store_wfa) + video->wfa = orig_wfa; + else + { + tmp_wfa = alloc_wfa (NO); + copy_wfa (tmp_wfa, video->wfa); + copy_wfa (video->wfa, orig_wfa); + } - /* - * First step: read WFA from disk - */ - prg_timer (&ptimer, START); - frame_number = read_next_wfa (video->wfa, input); - stop_timer [0] = prg_timer (&ptimer, STOP); - if (timer) - { - timer->input [video->wfa->frame_type] += stop_timer [0]; - timer->frames [video->wfa->frame_type]++; - } + /* + * First step: read WFA from disk + */ + prg_timer (&ptimer, START); + frame_number = read_next_wfa (video->wfa, input); + stop_timer [0] = prg_timer (&ptimer, STOP); + if (timer) + { + timer->input [video->wfa->frame_type] += stop_timer [0]; + timer->frames [video->wfa->frame_type]++; + } - /* - * Read reference frame from disk if required - * (i.e., 1st frame is of type B or P) - */ - if (video->display == 0 && video->wfa->frame_type != I_FRAME) - { - if (!reference_frame) - error ("First frame is %c-frame but no " - "reference frame is given.", - video->wfa->frame_type == B_FRAME ? 'B' : 'P'); - - video->frame = read_image (reference_frame); - video->sframe = NULL; - } + /* + * Read reference frame from disk if required + * (i.e., 1st frame is of type B or P) + */ + if (video->display == 0 && video->wfa->frame_type != I_FRAME) + { + if (!reference_frame) + error ("First frame is %c-frame but no " + "reference frame is given.", + video->wfa->frame_type == B_FRAME ? 'B' : 'P'); + + video->frame = read_image_file (reference_frame); + video->sframe = NULL; + } - /* - * Depending on current frame type update past and future frames - */ - if (video->wfa->frame_type == I_FRAME) - { - if (video->past) /* discard past frame */ - free_image (video->past); - video->past = NULL; - if (video->future) /* discard future frame */ - free_image (video->future); - video->future = NULL; - if (video->sfuture) /* discard (smoothed) future frame */ - free_image (video->sfuture); - video->sfuture = NULL; - if (video->frame) /* discard current frame */ - free_image (video->frame); - video->frame = NULL; - if (video->sframe) /* discard current (smoothed) frame */ - free_image (video->sframe); - video->sframe = NULL; - } - else if (video->wfa->frame_type == P_FRAME) - { - if (video->past) /* discard past frame */ - free_image (video->past); - video->past = video->frame; /* past <- current frame */ - video->frame = NULL; - if (video->sframe) /* discard current (smoothed) frame */ - free_image (video->sframe); - video->sframe = NULL; - if (store_wfa) - copy_wfa (video->wfa_past, tmp_wfa); - if (video->future) /* discard future frame */ - free_image (video->future); - video->future = NULL; - if (video->sfuture) /* discard (smoothed) future frame */ - free_image (video->sfuture); - video->sfuture = NULL; - } - else /* B_FRAME */ - { - if (current_frame_is_future_frame) - { - if (video->future) /* discard future frame */ - free_image (video->future); - video->future = frame; /* future <- current frame */ - if (video->sfuture) /* discard (smoothed) future frame */ - free_image (video->sfuture); - video->sfuture = sframe; /* future <- current (smoothed) */ - if (store_wfa) - copy_wfa (video->wfa_future, tmp_wfa); - if (video->frame) /* discard current frame */ - free_image (video->frame); - video->frame = NULL; - if (video->sframe) /* discard current (smoothed) frame */ - free_image (video->sframe); - video->sframe = NULL; - frame = NULL; - sframe = NULL; - } - else - { - if (video->wfa->wfainfo->B_as_past_ref == YES) - { - if (video->past) /* discard past frame */ - free_image (video->past); - video->past = video->frame; /* past <- current frame */ - video->frame = NULL; - if (video->sframe) /* discard current (smoothed) frame */ - free_image (video->sframe); - video->sframe = NULL; - if (store_wfa) - copy_wfa (video->wfa_past, tmp_wfa); - } - else - { - if (video->frame) /* discard current */ - free_image (video->frame); - video->frame = NULL; - if (video->sframe) /* discard current (smoothed) frame */ - free_image (video->sframe); - video->sframe = NULL; - } - } - } - if (tmp_wfa) - free_wfa (tmp_wfa); - - current_frame_is_future_frame = NO; - /* - * Second step: decode image - * Optionally enlarge image if specified by option 'enlarge_factor'. - */ - { - unsigned orig_width, orig_height; - - stop_timer [0] = stop_timer [1] = stop_timer [2] = 0; - - enlarge_image (enlarge_factor, format, - (video->wfa->wfainfo->color - && format == FORMAT_4_2_0) - ? video->wfa->tree [video->wfa->tree [video->wfa->root_state][0]][0] : -1, video->wfa); - - if (enlarge_factor > 0) - { - orig_width = video->wfa->wfainfo->width << enlarge_factor; - orig_height = video->wfa->wfainfo->height << enlarge_factor; - } - else - { - orig_width = video->wfa->wfainfo->width >> - enlarge_factor; - orig_height = video->wfa->wfainfo->height >> - enlarge_factor; - if (orig_width & 1) - orig_width++; - if (orig_height & 1) - orig_height++; - } - - frame = decode_image (orig_width, orig_height, format, - timer != NULL ? stop_timer : NULL, - video->wfa); - if (timer) - { - timer->preprocessing [video->wfa->frame_type] += stop_timer [0]; - timer->decoder [video->wfa->frame_type] += stop_timer [1]; - timer->cleanup [video->wfa->frame_type] += stop_timer [2]; - } - } - - /* - * Third step: restore motion compensation - */ - if (video->wfa->frame_type != I_FRAME) - { - prg_timer (&ptimer, START); - restore_mc (enlarge_factor, frame, video->past, video->future, - video->wfa); - stop_timer [0] = prg_timer (&ptimer, STOP); - if (timer) - timer->motion [video->wfa->frame_type] += stop_timer [0]; - } - - /* - * Fourth step: smooth image along partitioning borders - */ - prg_timer (&ptimer, START); - if (smoothing < 0) /* smoothing not changed by user */ - smoothing = video->wfa->wfainfo->smoothing; - if (smoothing > 0 && smoothing <= 100) - { - sframe = clone_image (frame); - smooth_image (smoothing, video->wfa, sframe); - } - else - sframe = NULL; - - stop_timer [0] = prg_timer (&ptimer, STOP); - if (timer) - timer->smooth [video->wfa->frame_type] += stop_timer [0]; - - if (frame_number == video->display) - { - video->display++; - video->frame = frame; - video->sframe = sframe; - frame = NULL; - sframe = NULL; - } - else if (frame_number > video->display) - { - video->future_display = frame_number; - current_frame_is_future_frame = YES; - } + /* + * Depending on current frame type update past and future frames + */ + if (video->wfa->frame_type == I_FRAME) + { + if (video->past) /* discard past frame */ + free_image (video->past); + video->past = NULL; + if (video->future) /* discard future frame */ + free_image (video->future); + video->future = NULL; + if (video->sfuture) /* discard (smoothed) future frame */ + free_image (video->sfuture); + video->sfuture = NULL; + if (video->frame) /* discard current frame */ + free_image (video->frame); + video->frame = NULL; + if (video->sframe) /* discard current (smoothed) frame */ + free_image (video->sframe); + video->sframe = NULL; + } + else if (video->wfa->frame_type == P_FRAME) + { + if (video->past) /* discard past frame */ + free_image (video->past); + video->past = video->frame; /* past <- current frame */ + video->frame = NULL; + if (video->sframe) /* discard current (smoothed) frame */ + free_image (video->sframe); + video->sframe = NULL; + if (store_wfa) + copy_wfa (video->wfa_past, tmp_wfa); + if (video->future) /* discard future frame */ + free_image (video->future); + video->future = NULL; + if (video->sfuture) /* discard (smoothed) future frame */ + free_image (video->sfuture); + video->sfuture = NULL; + } + else /* B_FRAME */ + { + if (current_frame_is_future_frame) + { + if (video->future) /* discard future frame */ + free_image (video->future); + video->future = frame; /* future <- current frame */ + if (video->sfuture) /* discard (smoothed) future frame */ + free_image (video->sfuture); + video->sfuture = sframe; /* future <- current (smoothed) */ + if (store_wfa) + copy_wfa (video->wfa_future, tmp_wfa); + if (video->frame) /* discard current frame */ + free_image (video->frame); + video->frame = NULL; + if (video->sframe) /* discard current (smoothed) frame */ + free_image (video->sframe); + video->sframe = NULL; + frame = NULL; + sframe = NULL; + } + else + { + if (video->wfa->wfainfo->B_as_past_ref == YES) + { + if (video->past) /* discard past frame */ + free_image (video->past); + video->past = video->frame; /* past <- current frame */ + video->frame = NULL; + if (video->sframe) /* discard current (smoothed) frame */ + free_image (video->sframe); + video->sframe = NULL; + if (store_wfa) + copy_wfa (video->wfa_past, tmp_wfa); + } + else + { + if (video->frame) /* discard current */ + free_image (video->frame); + video->frame = NULL; + if (video->sframe) /* discard current (smoothed) frame */ + free_image (video->sframe); + video->sframe = NULL; + } + } + } + if (tmp_wfa) + free_wfa (tmp_wfa); + + current_frame_is_future_frame = NO; + /* + * Second step: decode image + * Optionally enlarge image if specified by option 'enlarge_factor'. + */ + { + unsigned orig_width, orig_height; + + stop_timer [0] = stop_timer [1] = stop_timer [2] = 0; + + enlarge_image (enlarge_factor, format, + (video->wfa->wfainfo->color + && format == FORMAT_4_2_0) + ? video->wfa->tree [video->wfa->tree [video->wfa->root_state][0]][0] : -1, video->wfa); + + if (enlarge_factor > 0) + { + orig_width = video->wfa->wfainfo->width << enlarge_factor; + orig_height = video->wfa->wfainfo->height << enlarge_factor; + } + else + { + orig_width = video->wfa->wfainfo->width >> - enlarge_factor; + orig_height = video->wfa->wfainfo->height >> - enlarge_factor; + if (orig_width & 1) + orig_width++; + if (orig_height & 1) + orig_height++; + } + + frame = decode_image (orig_width, orig_height, format, + timer != NULL ? stop_timer : NULL, + video->wfa); + if (timer) + { + timer->preprocessing [video->wfa->frame_type] += stop_timer [0]; + timer->decoder [video->wfa->frame_type] += stop_timer [1]; + timer->cleanup [video->wfa->frame_type] += stop_timer [2]; + } + } + + /* + * Third step: restore motion compensation + */ + if (video->wfa->frame_type != I_FRAME) + { + prg_timer (&ptimer, START); + restore_mc (enlarge_factor, frame, video->past, video->future, + video->wfa); + stop_timer [0] = prg_timer (&ptimer, STOP); + if (timer) + timer->motion [video->wfa->frame_type] += stop_timer [0]; + } + + /* + * Fourth step: smooth image along partitioning borders + */ + prg_timer (&ptimer, START); + if (smoothing < 0) /* smoothing not changed by user */ + smoothing = video->wfa->wfainfo->smoothing; + if (smoothing > 0 && smoothing <= 100) + { + sframe = clone_image (frame); + smooth_image (smoothing, video->wfa, sframe); + } + else + sframe = NULL; + + stop_timer [0] = prg_timer (&ptimer, STOP); + if (timer) + timer->smooth [video->wfa->frame_type] += stop_timer [0]; + + if (frame_number == video->display) + { + video->display++; + video->frame = frame; + video->sframe = sframe; + frame = NULL; + sframe = NULL; + } + else if (frame_number > video->display) + { + video->future_display = frame_number; + current_frame_is_future_frame = YES; + } - if (!store_wfa) - remove_states (video->wfa->basis_states, video->wfa); + if (!store_wfa) + remove_states (video->wfa->basis_states, video->wfa); } while (!video->frame); if (!store_wfa) - video->wfa = NULL; + video->wfa = NULL; } return video->sframe ? video->sframe : video->frame; @@ -414,7 +415,7 @@ get_next_frame (bool_t store_wfa, int enlarge_factor, image_t * decode_image (unsigned orig_width, unsigned orig_height, format_e format, - unsigned *dec_timer, const wfa_t *wfa) + unsigned *dec_timer, const wfa_t *wfa) /* * Compute image which is represented by the given 'wfa'. * 'orig_width'x'orig_height' gives the resolution of the image at @@ -422,20 +423,20 @@ decode_image (unsigned orig_width, unsigned orig_height, format_e format, * If 'dec_timer' is given, accumulate running time statistics. * * Return value: - * pointer to decoded image + * pointer to decoded image * * Side effects: - * '*dectimer' is changed if 'dectimer' != NULL. + * '*dectimer' is changed if 'dectimer' != NULL. */ { - unsigned root_state [3]; /* root of bintree for each band */ - unsigned width, height; /* computed image size */ - image_t *frame; /* regenerated frame */ - word_t **images; /* pointer to array of pointers - to state images */ - u_word_t *offsets; /* pointer to array of state image - offsets */ - unsigned max_level; /* max. level of state with approx. */ + unsigned root_state [3]; /* root of bintree for each band */ + unsigned width, height; /* computed image size */ + image_t *frame; /* regenerated frame */ + word_t **images; /* pointer to array of pointers + to state images */ + u_word_t *offsets; /* pointer to array of state image + offsets */ + unsigned max_level; /* max. level of state with approx. */ unsigned state; clock_t ptimer; @@ -458,14 +459,14 @@ decode_image (unsigned orig_width, unsigned orig_height, format_e format, */ for (max_level = 0, state = wfa->basis_states; state < wfa->states; state++) if (isedge (wfa->into [state][0][0]) || isedge (wfa->into [state][1][0])) - max_level = max (max_level, wfa->level_of_state [state]); + max_level = max (max_level, wfa->level_of_state [state]); /* * Allocate frame buffer for decoded image */ compute_actual_size (format == FORMAT_4_2_0 ? root_state [Y] : MAXSTATES, - &width, &height, wfa); + &width, &height, wfa); width = max (width, orig_width); height = max (height, orig_height); frame = alloc_image (width, height, wfa->wfainfo->color, format); @@ -480,7 +481,7 @@ decode_image (unsigned orig_width, unsigned orig_height, format_e format, wfa->level_of_state [wfa->tree[wfa->root_state][1]] = 128; } alloc_state_images (&images, &offsets, frame, root_state, 0, max_level, - format, wfa); + format, wfa); if (dec_timer) dec_timer [0] += prg_timer (&ptimer, STOP); @@ -498,38 +499,38 @@ decode_image (unsigned orig_width, unsigned orig_height, format_e format, */ prg_timer (&ptimer, START); free_state_images (max_level, frame->color, images, offsets, root_state, 0, - format, wfa); + format, wfa); /* * Crop decoded image if the image size differs. */ if (orig_width != width || orig_height != height) { - frame->height = orig_height; - frame->width = orig_width; - if (orig_width != width) + frame->height = orig_height; + frame->width = orig_width; + if (orig_width != width) { - color_e band; /* current color band */ - word_t *src, *dst; /* source and destination pointers */ - unsigned y; /* current row */ - - for (band = first_band (frame->color); - band <= last_band (frame->color); band++) - { - src = dst = frame->pixels [band]; - for (y = orig_height; y; y--) - { - memmove (dst, src, orig_width * sizeof (word_t)); - dst += orig_width; - src += width; - } - if (format == FORMAT_4_2_0 && band == Y) - { - orig_width >>= 1; - orig_height >>= 1; - width >>= 1; - } - } + color_e band; /* current color band */ + word_t *src, *dst; /* source and destination pointers */ + unsigned y; /* current row */ + + for (band = first_band (frame->color); + band <= last_band (frame->color); band++) + { + src = dst = frame->pixels [band]; + for (y = orig_height; y; y--) + { + memmove (dst, src, orig_width * sizeof (word_t)); + dst += orig_width; + src += width; + } + if (format == FORMAT_4_2_0 && band == Y) + { + orig_width >>= 1; + orig_height >>= 1; + width >>= 1; + } + } } } if (dec_timer) @@ -544,10 +545,10 @@ decode_state (unsigned state, unsigned level, wfa_t *wfa) * Decode 'state' image of 'wfa' at given 'level'. * * Return value. - * pointer to decoded state image + * pointer to decoded state image * * Side effects: - * 'wfa' states > 'state' are removed. + * 'wfa' states > 'state' are removed. */ { word_t *domains [2]; @@ -571,15 +572,15 @@ decode_state (unsigned state, unsigned level, wfa_t *wfa) */ { word_t *src, *dst; - unsigned y; - + unsigned y; + src = domains [0]; dst = img->pixels [GRAY]; for (y = img->height; y; y--) { - memcpy (dst, src, width_of_level (level) * sizeof (word_t)); - src += width_of_level (level); - dst += img->width; + memcpy (dst, src, width_of_level (level) * sizeof (word_t)); + src += width_of_level (level); + dst += img->width; } Free (domains [0]); } @@ -589,87 +590,87 @@ decode_state (unsigned state, unsigned level, wfa_t *wfa) word_t * decode_range (unsigned range_state, unsigned range_label, unsigned range_level, - word_t **domain, wfa_t *wfa) + word_t **domain, wfa_t *wfa) /* * Compute 'wfa' image of range (identified by 'state' and 'label') * at 'range_level (works as function decode_image()). * * Return value: - * pointer to the pixels in SHORT format + * pointer to the pixels in SHORT format * * Side effects: - * if 'domain' != NULL then also the domain blocks - * of the corresponding range blocks are generated + * if 'domain' != NULL then also the domain blocks + * of the corresponding range blocks are generated * and returned in domain[] - * 'wfa->level_of_state []' is changed + * 'wfa->level_of_state []' is changed */ { - unsigned root_state [3]; /* dummy (for alloc_state_images) */ - image_t *state_image; /* regenerated state image */ - word_t **images; /* pointer to array of pointers - to state images */ - u_word_t *offsets; /* pointer to array of state image - offsets */ + unsigned root_state [3]; /* dummy (for alloc_state_images) */ + image_t *state_image; /* regenerated state image */ + word_t **images; /* pointer to array of pointers + to state images */ + u_word_t *offsets; /* pointer to array of state image + offsets */ word_t *range; enlarge_image (range_level - (wfa->level_of_state [range_state] - 1), - FORMAT_4_4_4, -1, wfa); + FORMAT_4_4_4, -1, wfa); root_state [0] = range_state; state_image = alloc_image (width_of_level (range_level + 1), - height_of_level (range_level + 1), - NO, FORMAT_4_4_4); + height_of_level (range_level + 1), + NO, FORMAT_4_4_4); alloc_state_images (&images, &offsets, state_image, NULL, range_state, - range_level + 1, NO, wfa); + range_level + 1, NO, wfa); compute_state_images (range_level + 1, images, offsets, wfa); range = Calloc (size_of_level (range_level), sizeof (word_t)); - if ((range_level & 1) == 0) /* square image */ + if ((range_level & 1) == 0) /* square image */ { memcpy (range, - images [range_state + (range_level + 1) * wfa->states] - + range_label * size_of_level (range_level), - size_of_level (range_level) * sizeof (word_t)); + images [range_state + (range_level + 1) * wfa->states] + + range_label * size_of_level (range_level), + size_of_level (range_level) * sizeof (word_t)); } - else /* rectangle */ + else /* rectangle */ { word_t *src, *dst; unsigned y; src = images [range_state + (range_level + 1) * wfa->states] - + range_label * width_of_level (range_level); + + range_label * width_of_level (range_level); dst = range; for (y = height_of_level (range_level); y; y--) { - memcpy (dst, src, width_of_level (range_level) * sizeof (word_t)); - dst += width_of_level (range_level); - src += width_of_level (range_level + 1); + memcpy (dst, src, width_of_level (range_level) * sizeof (word_t)); + dst += width_of_level (range_level); + src += width_of_level (range_level + 1); } } - if (domain != NULL) /* copy domain images */ + if (domain != NULL) /* copy domain images */ { - int s; /* domain state */ - unsigned edge; /* counter */ - + int s; /* domain state */ + unsigned edge; /* counter */ + if (ischild (s = wfa->tree [range_state][range_label])) - *domain++ = duplicate_state_image (images [s + (range_level) - * wfa->states], - offsets [s + (range_level) - * wfa->states], - range_level); + *domain++ = duplicate_state_image (images [s + (range_level) + * wfa->states], + offsets [s + (range_level) + * wfa->states], + range_level); for (edge = 0; isedge (s = wfa->into[range_state][range_label][edge]); - edge++) - *domain++ = duplicate_state_image (images [s + (range_level) - * wfa->states], - offsets [s + (range_level) - * wfa->states], - range_level); + edge++) + *domain++ = duplicate_state_image (images [s + (range_level) + * wfa->states], + offsets [s + (range_level) + * wfa->states], + range_level); *domain = NULL; } free_state_images (range_level + 1, NO, images, offsets, NULL, range_state, - NO, wfa); + NO, wfa); free_image (state_image); return range; @@ -684,102 +685,102 @@ smooth_image (unsigned sf, const wfa_t *wfa, image_t *image) * No return value. * * Side effects: - * pixel values of the 'image' are modified with respect to 's' + * pixel values of the 'image' are modified with respect to 's' */ { - int is, inegs; /* integer factors of s and 1 - s*/ - unsigned state; + int is, inegs; /* integer factors of s and 1 - s*/ + unsigned state; unsigned img_width = image->width; unsigned img_height = image->height; - real_t s = 1.0 - sf / 200.0; + real_t s = 1.0 - sf / 200.0; - if (s < 0.5 || s >= 1) /* value out of range */ + if (s < 0.5 || s >= 1) /* value out of range */ return; - is = s * 512 + .5; /* integer representation of s */ - inegs = (1 - s) * 512 + .5; /* integer representation of 1 - s */ + is = s * 512 + .5; /* integer representation of s */ + inegs = (1 - s) * 512 + .5; /* integer representation of 1 - s */ for (state = wfa->basis_states; - state < (wfa->wfainfo->color - ? wfa->tree [wfa->root_state][0] - : wfa->states); state++) + state < (wfa->wfainfo->color + ? wfa->tree [wfa->root_state][0] + : wfa->states); state++) { word_t *bptr = image->pixels [Y]; /* pointer to right or - lower line */ + lower line */ unsigned level = wfa->level_of_state[state]; /* level of state image */ unsigned width = width_of_level (level); /* size of state image */ unsigned height = height_of_level (level); /* size of state image */ if (wfa->y [state][1] >= img_height || wfa->x [state][1] >= img_width) - continue; /* outside visible area */ - - if (level % 2) /* horizontal smoothing */ + continue; /* outside visible area */ + + if (level % 2) /* horizontal smoothing */ { - unsigned i; /* line counter */ - word_t *img1; /* pointer to left or upper line */ - word_t *img2; /* pointer to right or lower line */ - - img1 = bptr + (wfa->y [state][1] - 1) * img_width - + wfa->x [state][1]; - img2 = bptr + wfa->y [state][1] * img_width + wfa->x [state][1]; - - for (i = min (width, img_width - wfa->x [state][1]); i; - i--, img1++, img2++) - { - int tmp = *img1; - + unsigned i; /* line counter */ + word_t *img1; /* pointer to left or upper line */ + word_t *img2; /* pointer to right or lower line */ + + img1 = bptr + (wfa->y [state][1] - 1) * img_width + + wfa->x [state][1]; + img2 = bptr + wfa->y [state][1] * img_width + wfa->x [state][1]; + + for (i = min (width, img_width - wfa->x [state][1]); i; + i--, img1++, img2++) + { + int tmp = *img1; + #ifdef HAVE_SIGNED_SHIFT - *img1 = (((is * tmp) >> 10) << 1) - + (((inegs * (int) *img2) >> 10) << 1); - *img2 = (((is * (int) *img2) >> 10) << 1) - + (((inegs * tmp) >> 10) << 1); + *img1 = (((is * tmp) >> 10) << 1) + + (((inegs * (int) *img2) >> 10) << 1); + *img2 = (((is * (int) *img2) >> 10) << 1) + + (((inegs * tmp) >> 10) << 1); #else /* not HAVE_SIGNED_SHIFT */ - *img1 = (((is * tmp) / 1024) * 2) - + (((inegs * (int) *img2) / 1024) * 2); - *img2 = (((is * (int) *img2) / 1024) * 2) - + (((inegs * tmp) / 1024) *2); + *img1 = (((is * tmp) / 1024) * 2) + + (((inegs * (int) *img2) / 1024) * 2); + *img2 = (((is * (int) *img2) / 1024) * 2) + + (((inegs * tmp) / 1024) *2); #endif /* not HAVE_SIGNED_SHIFT */ - } + } } - else /* vertical smoothing */ + else /* vertical smoothing */ { - unsigned i; /* line counter */ - word_t *img1; /* pointer to left or upper line */ - word_t *img2; /* pointer to right or lower line */ - - img1 = bptr + wfa->y [state][1] * img_width + wfa->x [state][1] - 1; - img2 = bptr + wfa->y [state][1] * img_width + wfa->x [state][1]; - - for (i = min (height, img_height - wfa->y [state][1]); i; - i--, img1 += img_width, img2 += img_width) - { - int tmp = *img1; - + unsigned i; /* line counter */ + word_t *img1; /* pointer to left or upper line */ + word_t *img2; /* pointer to right or lower line */ + + img1 = bptr + wfa->y [state][1] * img_width + wfa->x [state][1] - 1; + img2 = bptr + wfa->y [state][1] * img_width + wfa->x [state][1]; + + for (i = min (height, img_height - wfa->y [state][1]); i; + i--, img1 += img_width, img2 += img_width) + { + int tmp = *img1; + #ifdef HAVE_SIGNED_SHIFT - *img1 = (((is * tmp) >> 10) << 1) - + (((inegs * (int) *img2) >> 10) << 1); - *img2 = (((is * (int) *img2) >> 10) << 1) - + (((inegs * tmp) >> 10) << 1); + *img1 = (((is * tmp) >> 10) << 1) + + (((inegs * (int) *img2) >> 10) << 1); + *img2 = (((is * (int) *img2) >> 10) << 1) + + (((inegs * tmp) >> 10) << 1); #else /* not HAVE_SIGNED_SHIFT */ - *img1 = (((is * tmp) / 1024) * 2) - + (((inegs * (int) *img2) / 1024) * 2); - *img2 = (((is * (int) *img2) / 1024) * 2) - + (((inegs * tmp) / 1024) *2); + *img1 = (((is * tmp) / 1024) * 2) + + (((inegs * (int) *img2) / 1024) * 2); + *img2 = (((is * (int) *img2) / 1024) * 2) + + (((inegs * tmp) / 1024) *2); #endif /* not HAVE_SIGNED_SHIFT */ - } + } } } } /***************************************************************************** - private code + private code *****************************************************************************/ static void enlarge_image (int enlarge_factor, format_e format, unsigned y_root, - wfa_t *wfa) + wfa_t *wfa) /* * Enlarge or reduce size of state images by factor 2^'enlarge_factor'. * Use 4:2:0 subsampling if specified by 'format', else use 4:4:4 format. @@ -788,8 +789,8 @@ enlarge_image (int enlarge_factor, format_e format, unsigned y_root, * No return value. * * Side effects: - * coordinates of ranges and motion blocks in the WFA structure 'wfa' - * are modified. + * coordinates of ranges and motion blocks in the WFA structure 'wfa' + * are modified. */ { @@ -799,53 +800,53 @@ enlarge_image (int enlarge_factor, format_e format, unsigned y_root, if (enlarge_factor == 0) { - state = y_root + 1; - enlarge_factor = -1; + state = y_root + 1; + enlarge_factor = -1; } else - state = wfa->basis_states; + state = wfa->basis_states; for (; state < wfa->states; state++) { - unsigned label, n; - - wfa->level_of_state [state] - = max (wfa->level_of_state [state] + enlarge_factor * 2, 0); - - for (label = 0; label < MAXLABELS; label++) - if (enlarge_factor > 0) - { - wfa->x [state][label] <<= enlarge_factor; - wfa->y [state][label] <<= enlarge_factor; - for (n = enlarge_factor; n; n--) - { - wfa->mv_tree [state][label].fx *= 2; - wfa->mv_tree [state][label].fy *= 2; - wfa->mv_tree [state][label].bx *= 2; - wfa->mv_tree [state][label].by *= 2; - } - } - else /* enlarge_factor < 0 */ - { - wfa->x [state][label] >>= - enlarge_factor; - wfa->y [state][label] >>= - enlarge_factor; - for (n = - enlarge_factor; n; n--) - { - wfa->mv_tree [state][label].fx /= 2; - wfa->mv_tree [state][label].fy /= 2; - wfa->mv_tree [state][label].bx /= 2; - wfa->mv_tree [state][label].by /= 2; - } - } - if (format == FORMAT_4_2_0 && state == y_root) - enlarge_factor--; + unsigned label, n; + + wfa->level_of_state [state] + = max (wfa->level_of_state [state] + enlarge_factor * 2, 0); + + for (label = 0; label < MAXLABELS; label++) + if (enlarge_factor > 0) + { + wfa->x [state][label] <<= enlarge_factor; + wfa->y [state][label] <<= enlarge_factor; + for (n = enlarge_factor; n; n--) + { + wfa->mv_tree [state][label].fx *= 2; + wfa->mv_tree [state][label].fy *= 2; + wfa->mv_tree [state][label].bx *= 2; + wfa->mv_tree [state][label].by *= 2; + } + } + else /* enlarge_factor < 0 */ + { + wfa->x [state][label] >>= - enlarge_factor; + wfa->y [state][label] >>= - enlarge_factor; + for (n = - enlarge_factor; n; n--) + { + wfa->mv_tree [state][label].fx /= 2; + wfa->mv_tree [state][label].fy /= 2; + wfa->mv_tree [state][label].bx /= 2; + wfa->mv_tree [state][label].by /= 2; + } + } + if (format == FORMAT_4_2_0 && state == y_root) + enlarge_factor--; } } } static void compute_actual_size (unsigned luminance_root, - unsigned *width, unsigned *height, const wfa_t *wfa) + unsigned *width, unsigned *height, const wfa_t *wfa) /* * Compute actual size of the frame represented by the given 'wfa'. * (The reconstructed frame may get larger than the original due @@ -853,24 +854,24 @@ compute_actual_size (unsigned luminance_root, * If 'luminance_root' < MAXSTATES then the size of chroma ranges (4:2:0). * * Return values: - * actual 'width' and 'height' of the decoded frame. + * actual 'width' and 'height' of the decoded frame. */ { - unsigned x = 0, y = 0; /* maximum coordinates */ - unsigned state; /* counter */ + unsigned x = 0, y = 0; /* maximum coordinates */ + unsigned state; /* counter */ for (state = wfa->basis_states; state < wfa->states; state++) if (isedge (wfa->into [state][0][0]) || isedge (wfa->into [state][1][0])) { - unsigned mult = state > luminance_root ? 2 : 1; - - x = max ((wfa->x [state][0] - + width_of_level (wfa->level_of_state [state])) * mult, x); - y = max ((wfa->y [state][0] - + height_of_level (wfa->level_of_state [state])) * mult, y); + unsigned mult = state > luminance_root ? 2 : 1; + + x = max ((wfa->x [state][0] + + width_of_level (wfa->level_of_state [state])) * mult, x); + y = max ((wfa->y [state][0] + + height_of_level (wfa->level_of_state [state])) * mult, y); } - if (x & 1) /* ensure that image size is even */ + if (x & 1) /* ensure that image size is even */ x++; if (y & 1) y++; @@ -880,8 +881,8 @@ compute_actual_size (unsigned luminance_root, static void alloc_state_images (word_t ***images, u_word_t **offsets, const image_t *frame, - const unsigned *root_state, unsigned range_state, - unsigned max_level, format_e format, const wfa_t *wfa) + const unsigned *root_state, unsigned range_state, + unsigned max_level, format_e format, const wfa_t *wfa) /* * Generate list of 'wfa' state images which have to be computed for * each level to obtain the decoded 'frame'. 'root_state[]' denotes the @@ -893,24 +894,24 @@ alloc_state_images (word_t ***images, u_word_t **offsets, const image_t *frame, * image of 'wfa->root_state'. * * Return values: - * '*images' Pointer to array of state image pointers - * '*offsets' Pointer to array of state image offsets. + * '*images' Pointer to array of state image pointers + * '*offsets' Pointer to array of state image offsets. * * Side effects: - * The arrays given above are filled with useful values. + * The arrays given above are filled with useful values. */ { - word_t **simg; /* ptr to list of state image ptr's */ - u_word_t *offs; /* ptr to list of offsets */ - unsigned level; /* counter */ + word_t **simg; /* ptr to list of state image ptr's */ + u_word_t *offs; /* ptr to list of offsets */ + unsigned level; /* counter */ - simg = Calloc (wfa->states * (max_level + 1), sizeof (word_t *)); - offs = Calloc (wfa->states * (max_level + 1), sizeof (u_word_t)); + simg = Calloc (wfa->states * (max_level + 1), sizeof (word_t *)); + offs = Calloc (wfa->states * (max_level + 1), sizeof (u_word_t)); /* * Initialize buffers for those state images which are at 'max_level'. */ - if (range_state > 0) /* a range is given */ + if (range_state > 0) /* a range is given */ { simg [range_state + max_level * wfa->states] = frame->pixels [GRAY]; offs [range_state + max_level * wfa->states] = frame->width; @@ -920,25 +921,25 @@ alloc_state_images (word_t ***images, u_word_t **offsets, const image_t *frame, unsigned state; for (state = wfa->basis_states; state <= root_state [Y]; state++) - if (wfa->level_of_state [state] == max_level) - { - simg [state + max_level * wfa->states] - = (frame->pixels [Y] + wfa->y [state][0] * frame->width - + wfa->x [state][0]); - offs [state + max_level * wfa->states] = frame->width; - } + if (wfa->level_of_state [state] == max_level) + { + simg [state + max_level * wfa->states] + = (frame->pixels [Y] + wfa->y [state][0] * frame->width + + wfa->x [state][0]); + offs [state + max_level * wfa->states] = frame->width; + } if (frame->color) { - unsigned width = format == FORMAT_4_2_0 ? - (frame->width >> 1) : frame->width; - for (; state < wfa->states; state++) - if (wfa->level_of_state [state] == max_level) - { - simg [state + max_level * wfa->states] - = (frame->pixels [state > root_state [Cb] ? Cr : Cb] - + wfa->y [state][0] * width + wfa->x [state][0]); - offs [state + max_level * wfa->states] = width; - } + unsigned width = format == FORMAT_4_2_0 ? + (frame->width >> 1) : frame->width; + for (; state < wfa->states; state++) + if (wfa->level_of_state [state] == max_level) + { + simg [state + max_level * wfa->states] + = (frame->pixels [state > root_state [Cb] ? Cr : Cb] + + wfa->y [state][0] * width + wfa->x [state][0]); + offs [state + max_level * wfa->states] = width; + } } } @@ -954,63 +955,63 @@ alloc_state_images (word_t ***images, u_word_t **offsets, const image_t *frame, * Range approximation with child. */ for (state = 1; state < (range_state > 0 ? - range_state + 1 : wfa->states); state++) - if (simg [state + level * wfa->states]) - for (label = 0; label < MAXLABELS; label++) - if (ischild (child = wfa->tree[state][label])) - { - if (isedge (wfa->into[state][label][0])) - { - /* - * Allocate new image block. - */ - simg [child + (level - 1) * wfa->states] - = Calloc (size_of_level (level - 1), sizeof (word_t)); - offs [child + (level - 1) * wfa->states] - = width_of_level (level - 1); - } - else - { - /* - * Use image block and offset of parent. - */ - if (level & 1) /* split vertically */ - { - simg [child + (level - 1) * wfa->states] - = (simg [state + level * wfa->states] - + label * (height_of_level (level - 1) - * offs [state - + level * wfa->states])); - } - else /* split horizontally */ - { - simg [child + (level - 1) * wfa->states] - = (simg [state + level * wfa->states] - + label * width_of_level (level - 1)); - } - offs [child + (level - 1) * wfa->states] - = offs [state + level * wfa->states]; - } - } + range_state + 1 : wfa->states); state++) + if (simg [state + level * wfa->states]) + for (label = 0; label < MAXLABELS; label++) + if (ischild (child = wfa->tree[state][label])) + { + if (isedge (wfa->into[state][label][0])) + { + /* + * Allocate new image block. + */ + simg [child + (level - 1) * wfa->states] + = Calloc (size_of_level (level - 1), sizeof (word_t)); + offs [child + (level - 1) * wfa->states] + = width_of_level (level - 1); + } + else + { + /* + * Use image block and offset of parent. + */ + if (level & 1) /* split vertically */ + { + simg [child + (level - 1) * wfa->states] + = (simg [state + level * wfa->states] + + label * (height_of_level (level - 1) + * offs [state + + level * wfa->states])); + } + else /* split horizontally */ + { + simg [child + (level - 1) * wfa->states] + = (simg [state + level * wfa->states] + + label * width_of_level (level - 1)); + } + offs [child + (level - 1) * wfa->states] + = offs [state + level * wfa->states]; + } + } /* * Range approximation with linear combination */ for (state = 1; state < (range_state > 0 ? - range_state + 1 : wfa->states); state++) - if (simg [state + level * wfa->states]) - for (label = 0; label < MAXLABELS; label++) - for (edge = 0; isedge (domain = wfa->into[state][label][edge]); - edge++) - { - if (domain > 0 /* don't allocate memory for state 0 */ - && !simg [domain + (level - 1) * wfa->states]) - { - simg [domain + (level - 1) * wfa->states] - = Calloc (size_of_level (level - 1), sizeof (word_t)); - offs [domain + (level - 1) * wfa->states] - = width_of_level (level - 1); - } - } + range_state + 1 : wfa->states); state++) + if (simg [state + level * wfa->states]) + for (label = 0; label < MAXLABELS; label++) + for (edge = 0; isedge (domain = wfa->into[state][label][edge]); + edge++) + { + if (domain > 0 /* don't allocate memory for state 0 */ + && !simg [domain + (level - 1) * wfa->states]) + { + simg [domain + (level - 1) * wfa->states] + = Calloc (size_of_level (level - 1), sizeof (word_t)); + offs [domain + (level - 1) * wfa->states] + = width_of_level (level - 1); + } + } } @@ -1020,8 +1021,8 @@ alloc_state_images (word_t ***images, u_word_t **offsets, const image_t *frame, static void free_state_images (unsigned max_level, bool_t color, word_t **state_image, - u_word_t *offset, const unsigned *root_state, - unsigned range_state, format_e format, const wfa_t *wfa) + u_word_t *offset, const unsigned *root_state, + unsigned range_state, format_e format, const wfa_t *wfa) /* * Free memory of state images. * For more details refer to the inverse function 'alloc_state_images()'. @@ -1029,10 +1030,10 @@ free_state_images (unsigned max_level, bool_t color, word_t **state_image, * No return value. * * Side effects: - * arrays 'state_image' and 'offset' are discarded. + * arrays 'state_image' and 'offset' are discarded. */ { - word_t marker; /* ptr is required as a marker */ + word_t marker; /* ptr is required as a marker */ unsigned level; if (range_state > 0) @@ -1047,19 +1048,19 @@ free_state_images (unsigned max_level, bool_t color, word_t **state_image, * Initialize state image array with states at 'max_level' */ for (state = wfa->basis_states; state <= root_state [Y]; state++) - if (wfa->level_of_state [state] == max_level) - state_image [state + max_level * wfa->states] = ▮ + if (wfa->level_of_state [state] == max_level) + state_image [state + max_level * wfa->states] = ▮ if (color) { - if (format == FORMAT_4_2_0) - level = max_level - 2; - else - level = max_level; + if (format == FORMAT_4_2_0) + level = max_level - 2; + else + level = max_level; - for (; state < wfa->states; state++) - if (wfa->level_of_state [state] == level) - state_image [state + level * wfa->states] = ▮ + for (; state < wfa->states; state++) + if (wfa->level_of_state [state] == level) + state_image [state + level * wfa->states] = ▮ } } @@ -1071,37 +1072,37 @@ free_state_images (unsigned max_level, bool_t color, word_t **state_image, * Range approximation with child. */ for (state = 1; state < (range_state > 0 ? - range_state + 1 : wfa->states); state++) - if (state_image [state + level * wfa->states]) - for (label = 0; label < MAXLABELS; label++) - if (ischild (child = wfa->tree[state][label])) - { - if (isedge (wfa->into[state][label][0]) - && (state_image [child + (level - 1) * wfa->states] - != &marker)) - Free (state_image [child + (level - 1) * wfa->states]); - state_image [child + (level - 1) * wfa->states] = ▮ - } + range_state + 1 : wfa->states); state++) + if (state_image [state + level * wfa->states]) + for (label = 0; label < MAXLABELS; label++) + if (ischild (child = wfa->tree[state][label])) + { + if (isedge (wfa->into[state][label][0]) + && (state_image [child + (level - 1) * wfa->states] + != &marker)) + Free (state_image [child + (level - 1) * wfa->states]); + state_image [child + (level - 1) * wfa->states] = ▮ + } /* * Range approximation with linear combination */ for (state = 1; state < (range_state > 0 ? - range_state + 1 : wfa->states); - state++) - if (state_image [state + level * wfa->states]) - for (label = 0; label < MAXLABELS; label++) - for (edge = 0; isedge (domain = wfa->into[state][label][edge]); - edge++) - if (domain > 0 - && (state_image [domain + (level - 1) * wfa->states] - != NULL) - && (state_image [domain + (level - 1) * wfa->states] - != &marker)) - { - Free (state_image [domain + (level - 1) * wfa->states]); - state_image [domain + (level - 1) * wfa->states] - = ▮ - } + range_state + 1 : wfa->states); + state++) + if (state_image [state + level * wfa->states]) + for (label = 0; label < MAXLABELS; label++) + for (edge = 0; isedge (domain = wfa->into[state][label][edge]); + edge++) + if (domain > 0 + && (state_image [domain + (level - 1) * wfa->states] + != NULL) + && (state_image [domain + (level - 1) * wfa->states] + != &marker)) + { + Free (state_image [domain + (level - 1) * wfa->states]); + state_image [domain + (level - 1) * wfa->states] + = ▮ + } } Free (state_image); Free (offset); @@ -1109,7 +1110,7 @@ free_state_images (unsigned max_level, bool_t color, word_t **state_image, static void compute_state_images (unsigned max_level, word_t **simg, - const u_word_t *offset, const wfa_t *wfa) + const u_word_t *offset, const wfa_t *wfa) /* * Compute all state images of the 'wfa' at level {1, ... , 'max_level'} * which are marked in the array 'simg' (offsets of state images @@ -1121,8 +1122,8 @@ compute_state_images (unsigned max_level, word_t **simg, * No return value. * * Side effects: - * state images (given by pointers in the array 'state_image') - * are computed. + * state images (given by pointers in the array 'state_image') + * are computed. */ { unsigned level, state; @@ -1132,8 +1133,8 @@ compute_state_images (unsigned max_level, word_t **simg, */ for (state = 1; state < wfa->states; state++) - if (simg [state] != NULL) /* compute image at level 0 */ - *simg [state] = (int) (wfa->final_distribution[state] * 8 + .5) * 2; + if (simg [state] != NULL) /* compute image at level 0 */ + *simg [state] = (int) (wfa->final_distribution[state] * 8 + .5) * 2; /* * Compute images of states @@ -1153,351 +1154,351 @@ compute_state_images (unsigned max_level, word_t **simg, unsigned height = height_of_level (level - 1); for (state = 1; state < wfa->states; state++) - if (simg [state + level * wfa->states] != NULL) - for (label = 0; label < MAXLABELS; label++) - if (isedge (wfa->into [state][label][0])) - { - unsigned edge; - int domain; - word_t *range; /* address of current range */ - bool_t prediction_used; /* ND prediction found ? */ - - /* - * Compute address of range image - */ - if (level & 1) /* split vertically */ - { - range = simg [state + level * wfa->states] - + label * (height_of_level (level - 1) - * offset [state - + level * wfa->states]); - } - else /* split horizontally */ - { - range = simg [state + level * wfa->states] - + label * width_of_level (level - 1); - } - - /* - * Generate the state images by adding the corresponding - * weighted state images: - * subimage [label] = - * weight_1 * image_1 + ... + weight_n * image_n - */ - if (!ischild (domain = wfa->tree[state][label])) - prediction_used = NO; - else - { - unsigned y; - word_t *src; - word_t *dst; - unsigned src_offset; - unsigned dst_offset; - - prediction_used = YES; - /* - * Copy child image - */ - src = simg [domain + (level - 1) * wfa->states]; - src_offset = offset [domain + (level - 1) * wfa->states] ; - dst = range; - dst_offset = offset [state + level * wfa->states]; - for (y = height; y; y--) - { - memcpy (dst, src, width * sizeof (word_t)); - src += src_offset; - dst += dst_offset; - } - } - - if (!prediction_used - && isedge (domain = wfa->into[state][label][0])) - { - /* - * If prediction is not used then the range is - * filled with the first domain. No addition is needed. - */ - edge = 0; - if (domain != 0) - { - int weight; - word_t *src; - unsigned src_offset; - - src = simg [domain + ((level - 1) - * wfa->states)]; - src_offset = offset [domain + ((level - 1) - * wfa->states)] - width; - weight = wfa->int_weight [state][label][edge]; - - if (width == 1) /* can't add two-pixels in a row */ - { - word_t *dst; - unsigned dst_offset; - - dst = range; - dst_offset = offset [state + level * wfa->states] - - width; + if (simg [state + level * wfa->states] != NULL) + for (label = 0; label < MAXLABELS; label++) + if (isedge (wfa->into [state][label][0])) + { + unsigned edge; + int domain; + word_t *range; /* address of current range */ + bool_t prediction_used; /* ND prediction found ? */ + + /* + * Compute address of range image + */ + if (level & 1) /* split vertically */ + { + range = simg [state + level * wfa->states] + + label * (height_of_level (level - 1) + * offset [state + + level * wfa->states]); + } + else /* split horizontally */ + { + range = simg [state + level * wfa->states] + + label * width_of_level (level - 1); + } + + /* + * Generate the state images by adding the corresponding + * weighted state images: + * subimage [label] = + * weight_1 * image_1 + ... + weight_n * image_n + */ + if (!ischild (domain = wfa->tree[state][label])) + prediction_used = NO; + else + { + unsigned y; + word_t *src; + word_t *dst; + unsigned src_offset; + unsigned dst_offset; + + prediction_used = YES; + /* + * Copy child image + */ + src = simg [domain + (level - 1) * wfa->states]; + src_offset = offset [domain + (level - 1) * wfa->states] ; + dst = range; + dst_offset = offset [state + level * wfa->states]; + for (y = height; y; y--) + { + memcpy (dst, src, width * sizeof (word_t)); + src += src_offset; + dst += dst_offset; + } + } + + if (!prediction_used + && isedge (domain = wfa->into[state][label][0])) + { + /* + * If prediction is not used then the range is + * filled with the first domain. No addition is needed. + */ + edge = 0; + if (domain != 0) + { + int weight; + word_t *src; + unsigned src_offset; + + src = simg [domain + ((level - 1) + * wfa->states)]; + src_offset = offset [domain + ((level - 1) + * wfa->states)] - width; + weight = wfa->int_weight [state][label][edge]; + + if (width == 1) /* can't add two-pixels in a row */ + { + word_t *dst; + unsigned dst_offset; + + dst = range; + dst_offset = offset [state + level * wfa->states] + - width; #ifdef HAVE_SIGNED_SHIFT - *dst++ = ((weight * (int) *src++) >> 10) << 1; -#else /* not HAVE_SIGNED_SHIFT */ - *dst++ = ((weight * (int) *src++) / 1024) * 2; + *dst++ = ((weight * (int) *src++) >> 10) << 1; +#else /* not HAVE_SIGNED_SHIFT */ + *dst++ = ((weight * (int) *src++) / 1024) * 2; #endif /* not HAVE_SIGNED_SHIFT */ - if (height == 2) - { - src += src_offset; - dst += dst_offset; + if (height == 2) + { + src += src_offset; + dst += dst_offset; #ifdef HAVE_SIGNED_SHIFT - *dst++ = ((weight * (int) *src++) >> 10) << 1; + *dst++ = ((weight * (int) *src++) >> 10) << 1; #else /* not HAVE_SIGNED_SHIFT */ - *dst++ = ((weight * (int) *src++) / 1024) * 2; + *dst++ = ((weight * (int) *src++) / 1024) * 2; #endif /* not HAVE_SIGNED_SHIFT */ - } - } - else - { - unsigned y; - int *idst; - unsigned idst_offset; - - idst = (int *) range; - idst_offset = (offset [state + level * wfa->states] - - width) / 2; - for (y = height; y; y--) - { - int *comp_dst = idst + (width >> 1); - - for (; idst != comp_dst; ) - { - int tmp; /* temp. value of adjacent pixels */ + } + } + else + { + unsigned y; + int *idst; + unsigned idst_offset; + + idst = (int *) range; + idst_offset = (offset [state + level * wfa->states] + - width) / 2; + for (y = height; y; y--) + { + int *comp_dst = idst + (width >> 1); + + for (; idst != comp_dst; ) + { + int tmp; /* temp. value of adjacent pixels */ #ifdef HAVE_SIGNED_SHIFT -# if BYTE_ORDER == LITTLE_ENDIAN - tmp = (((weight * (int) src [1]) >> 10) << 17) - | (((weight * (int) src [0]) >> 9) - & 0xfffe); -# else - tmp = (((weight * (int) src [0]) >> 10) << 17) - | (((weight * (int) src [1]) >> 9) - & 0xfffe); -# endif +# if BYTE_ORDER == LITTLE_ENDIAN + tmp = (((weight * (int) src [1]) >> 10) << 17) + | (((weight * (int) src [0]) >> 9) + & 0xfffe); +# else + tmp = (((weight * (int) src [0]) >> 10) << 17) + | (((weight * (int) src [1]) >> 9) + & 0xfffe); +# endif #else /* not HAVE_SIGNED_SHIFT */ -# if BYTE_ORDER == LITTLE_ENDIAN - tmp = (((weight * (int) src [1]) / 1024) - * 131072) - | (((weight * (int) src [0])/ 512) - & 0xfffe); -# else - tmp = (((weight * (int) src [0]) / 1024) - * 131072) - | (((weight * (int) src [1]) / 512) - & 0xfffe); -# endif /* not WORDS_BIGENDIAN */ -#endif - src += 2; - *idst++ = tmp & 0xfffefffe; - } - src += src_offset; - idst += idst_offset; - } - } - } - else - { - int weight = (int) (wfa->weight[state][label][edge] - * wfa->final_distribution[0] - * 8 + .5) * 2; - /* - * Range needs domain 0 - * (the constant function f(x, y) = 1), - * hence a faster algorithm is used. - */ - if (width == 1) /* can't add two-pixels in a row */ - { - word_t *dst; - unsigned dst_offset; - - dst = range; - dst_offset = offset [state + level * wfa->states] - - width; - - *dst++ = weight; - if (height == 2) - { - dst += dst_offset; - *dst++ = weight; - } - } - else - { - unsigned x, y; - int *idst; - unsigned idst_offset; - - weight = (weight * 65536) | (weight & 0xffff); - idst = (int *) range; - idst_offset = offset [state + level * wfa->states] - / 2; - for (x = width >> 1; x; x--) - *idst++ = weight & 0xfffefffe; - idst += (offset [state + level * wfa->states] - - width) / 2; - - for (y = height - 1; y; y--) - { - memcpy (idst, idst - idst_offset, - width * sizeof (word_t)); - idst += idst_offset; - } - } - } - edge = 1; - } - else - edge = 0; - - /* - * Add remaining weighted domain images to current range - */ - for (; isedge (domain = wfa->into[state][label][edge]); - edge++) - { - if (domain != 0) - { - word_t *src; - unsigned src_offset; - int weight; - - src = simg [domain + (level - 1) * wfa->states]; - src_offset = offset [domain + ((level - 1) - * wfa->states)] - width; - weight = wfa->int_weight [state][label][edge]; - - if (width == 1) /* can't add two-pixels in a row */ - { - word_t *dst; - unsigned dst_offset; - - dst = range; - dst_offset = offset [state + level * wfa->states] - - width; +# if BYTE_ORDER == LITTLE_ENDIAN + tmp = (((weight * (int) src [1]) / 1024) + * 131072) + | (((weight * (int) src [0])/ 512) + & 0xfffe); +# else + tmp = (((weight * (int) src [0]) / 1024) + * 131072) + | (((weight * (int) src [1]) / 512) + & 0xfffe); +# endif +#endif /* not HAVE_SIGNED_SHIFT */ + src += 2; + *idst++ = tmp & 0xfffefffe; + } + src += src_offset; + idst += idst_offset; + } + } + } + else + { + int weight = (int) (wfa->weight[state][label][edge] + * wfa->final_distribution[0] + * 8 + .5) * 2; + /* + * Range needs domain 0 + * (the constant function f(x, y) = 1), + * hence a faster algorithm is used. + */ + if (width == 1) /* can't add two-pixels in a row */ + { + word_t *dst; + unsigned dst_offset; + + dst = range; + dst_offset = offset [state + level * wfa->states] + - width; + + *dst++ = weight; + if (height == 2) + { + dst += dst_offset; + *dst++ = weight; + } + } + else + { + unsigned x, y; + int *idst; + unsigned idst_offset; + + weight = (weight * 65536) | (weight & 0xffff); + idst = (int *) range; + idst_offset = offset [state + level * wfa->states] + / 2; + for (x = width >> 1; x; x--) + *idst++ = weight & 0xfffefffe; + idst += (offset [state + level * wfa->states] + - width) / 2; + + for (y = height - 1; y; y--) + { + memcpy (idst, idst - idst_offset, + width * sizeof (word_t)); + idst += idst_offset; + } + } + } + edge = 1; + } + else + edge = 0; + + /* + * Add remaining weighted domain images to current range + */ + for (; isedge (domain = wfa->into[state][label][edge]); + edge++) + { + if (domain != 0) + { + word_t *src; + unsigned src_offset; + int weight; + + src = simg [domain + (level - 1) * wfa->states]; + src_offset = offset [domain + ((level - 1) + * wfa->states)] - width; + weight = wfa->int_weight [state][label][edge]; + + if (width == 1) /* can't add two-pixels in a row */ + { + word_t *dst; + unsigned dst_offset; + + dst = range; + dst_offset = offset [state + level * wfa->states] + - width; #ifdef HAVE_SIGNED_SHIFT - *dst++ += ((weight * (int) *src++) >> 10) << 1; + *dst++ += ((weight * (int) *src++) >> 10) << 1; #else /* not HAVE_SIGNED_SHIFT */ - *dst++ += ((weight * (int) *src++) / 1024) * 2; + *dst++ += ((weight * (int) *src++) / 1024) * 2; #endif /* not HAVE_SIGNED_SHIFT */ - if (height == 2) - { - src += src_offset; - dst += dst_offset; + if (height == 2) + { + src += src_offset; + dst += dst_offset; #ifdef HAVE_SIGNED_SHIFT - *dst++ += ((weight * (int) *src++) >> 10) << 1; + *dst++ += ((weight * (int) *src++) >> 10) << 1; #else /* not HAVE_SIGNED_SHIFT */ - *dst++ += ((weight * (int) *src++) / 1024) * 2; + *dst++ += ((weight * (int) *src++) / 1024) * 2; #endif /* not HAVE_SIGNED_SHIFT */ - } - } - else - { - int *idst; - unsigned idst_offset; - unsigned y; - - idst = (int *) range; - idst_offset = (offset [state + level * wfa->states] - - width) / 2; - - for (y = height; y; y--) - { - int *comp_dst = idst + (width >> 1); - - for (; idst != comp_dst;) - { - int tmp; /* temp. value of adjacent pixels */ + } + } + else + { + int *idst; + unsigned idst_offset; + unsigned y; + + idst = (int *) range; + idst_offset = (offset [state + level * wfa->states] + - width) / 2; + + for (y = height; y; y--) + { + int *comp_dst = idst + (width >> 1); + + for (; idst != comp_dst;) + { + int tmp; /* temp. value of adjacent pixels */ #ifdef HAVE_SIGNED_SHIFT -# if BYTE_ORDER == LITTLE_ENDIAN - tmp = (((weight * (int) src [1]) >> 10) << 17) - | (((weight * (int) src [0]) >> 9) - & 0xfffe); -# else - tmp = (((weight * (int)src [0]) >> 10) << 17) - | (((weight * (int)src [1]) >> 9) - & 0xfffe); -# endif +# if BYTE_ORDER == LITTLE_ENDIAN + tmp = (((weight * (int) src [1]) >> 10) << 17) + | (((weight * (int) src [0]) >> 9) + & 0xfffe); +# else + tmp = (((weight * (int)src [0]) >> 10) << 17) + | (((weight * (int)src [1]) >> 9) + & 0xfffe); +# endif #else /* not HAVE_SIGNED_SHIFT */ -# if BYTE_ORDER == LITTLE_ENDIAN - tmp = (((weight * (int) src [1]) / 1024) - * 131072) - | (((weight * (int) src [0])/ 512) - & 0xfffe); -# else - tmp = (((weight * (int) src [0]) / 1024) - * 131072) - | (((weight * (int) src [1])/ 512) - & 0xfffe); -# endif /* not WORDS_BIGENDIAN */ -#endif - src += 2; - *idst = (*idst + tmp) & 0xfffefffe; - idst++; - } - src += src_offset; - idst += idst_offset; - } - } - } - else - { - int weight = (int) (wfa->weight[state][label][edge] - * wfa->final_distribution[0] - * 8 + .5) * 2; - /* - * Range needs domain 0 - * (the constant function f(x, y) = 1), - * hence a faster algorithm is used. - */ - if (width == 1) /* can't add two-pixels in a row */ - { - word_t *dst; - unsigned dst_offset; - - dst = range; - dst_offset = offset [state + level * wfa->states] - - width; - - *dst++ += weight; - if (height == 2) - { - dst += dst_offset; - *dst++ += weight; - } - } - else - { - int *idst; - unsigned idst_offset; - unsigned y; - - weight = (weight * 65536) | (weight & 0xffff); - idst = (int *) range; - idst_offset = (offset [state + level * wfa->states] - - width) /2; - - for (y = height; y; y--) - { - int *comp_dst = idst + (width >> 1); - - for (; idst != comp_dst; ) - { - *idst = (*idst + weight) & 0xfffefffe; +# if BYTE_ORDER == LITTLE_ENDIAN + tmp = (((weight * (int) src [1]) / 1024) + * 131072) + | (((weight * (int) src [0])/ 512) + & 0xfffe); +# else + tmp = (((weight * (int) src [0]) / 1024) + * 131072) + | (((weight * (int) src [1])/ 512) + & 0xfffe); +# endif +#endif /* not HAVE_SIGNED_SHIFT */ + src += 2; + *idst = (*idst + tmp) & 0xfffefffe; + idst++; + } + src += src_offset; + idst += idst_offset; + } + } + } + else + { + int weight = (int) (wfa->weight[state][label][edge] + * wfa->final_distribution[0] + * 8 + .5) * 2; + /* + * Range needs domain 0 + * (the constant function f(x, y) = 1), + * hence a faster algorithm is used. + */ + if (width == 1) /* can't add two-pixels in a row */ + { + word_t *dst; + unsigned dst_offset; + + dst = range; + dst_offset = offset [state + level * wfa->states] + - width; + + *dst++ += weight; + if (height == 2) + { + dst += dst_offset; + *dst++ += weight; + } + } + else + { + int *idst; + unsigned idst_offset; + unsigned y; + + weight = (weight * 65536) | (weight & 0xffff); + idst = (int *) range; + idst_offset = (offset [state + level * wfa->states] + - width) /2; + + for (y = height; y; y--) + { + int *comp_dst = idst + (width >> 1); + + for (; idst != comp_dst; ) + { + *idst = (*idst + weight) & 0xfffefffe; idst++; - } - idst += idst_offset; - } - } - } - } - } + } + idst += idst_offset; + } + } + } + } + } } } @@ -1509,24 +1510,24 @@ duplicate_state_image (const word_t *domain, unsigned offset, unsigned level) * to the lock 'pixels'. * * Return value: - * pointer to the new domain block + * pointer to the new domain block */ { word_t *dst, *pixels; - int y, n; + int y, n; dst = pixels = Calloc (size_of_level (level), sizeof (word_t)); if (domain) for (y = height_of_level (level); y; y--) { - memcpy (dst, domain, width_of_level (level) * sizeof (word_t)); - dst += width_of_level (level); - domain += offset; + memcpy (dst, domain, width_of_level (level) * sizeof (word_t)); + dst += width_of_level (level); + domain += offset; } - else /* state 0 */ + else /* state 0 */ for (n = size_of_level (level); n; n--) - *dst++ = (int) (128 * 8 + .5) * 2; + *dst++ = (int) (128 * 8 + .5) * 2; return pixels; } diff --git a/converter/other/fiasco/codec/dfiasco.c b/converter/other/fiasco/codec/dfiasco.c index 1cdfc672..48c222aa 100644 --- a/converter/other/fiasco/codec/dfiasco.c +++ b/converter/other/fiasco/codec/dfiasco.c @@ -16,6 +16,8 @@ #include <string.h> +#include "nstring.h" + #include "config.h" #include "types.h" diff --git a/converter/other/fiasco/codec/options.c b/converter/other/fiasco/codec/options.c index 77dbaf00..6018a16c 100644 --- a/converter/other/fiasco/codec/options.c +++ b/converter/other/fiasco/codec/options.c @@ -26,6 +26,8 @@ #include <stdio.h> +#include "nstring.h" + #include "types.h" #include "macros.h" #include "error.h" diff --git a/converter/other/fiasco/fiasco.h b/converter/other/fiasco/fiasco.h index 235b1279..59367bb8 100644 --- a/converter/other/fiasco/fiasco.h +++ b/converter/other/fiasco/fiasco.h @@ -28,6 +28,8 @@ * $State: Exp $ */ +#include "pnm.h" + #undef __BEGIN_DECLS #undef __END_DECLS #ifdef __cplusplus @@ -260,8 +262,17 @@ fiasco_decoder_get_comment (fiasco_decoder_t *decoder); image functions ****************************************************************************/ -/* Read FIASCO image (raw ppm or pgm format) */ -fiasco_image_t * fiasco_image_new (const char *filename); +/* Create FIASCO image (from PNM image file) */ +fiasco_image_t * +fiasco_image_new_file(const char * const filename); + +/* Create FIASCO image (from PNM image stream) */ +fiasco_image_t * +fiasco_image_new_stream(FILE * const ifP, + unsigned int const width, + unsigned int const height, + xelval const maxval, + int const format); /* Discard FIASCO image */ void fiasco_image_delete (fiasco_image_t *image); diff --git a/converter/other/fiasco/fiascotopnm.c b/converter/other/fiasco/fiascotopnm.c index 6d8b6f7f..43340b06 100644 --- a/converter/other/fiasco/fiascotopnm.c +++ b/converter/other/fiasco/fiascotopnm.c @@ -25,6 +25,8 @@ #include <string.h> #include <math.h> +#include "nstring.h" + #include "types.h" #include "macros.h" diff --git a/converter/other/fiasco/input/basis.c b/converter/other/fiasco/input/basis.c index cef075e6..4a748f61 100644 --- a/converter/other/fiasco/input/basis.c +++ b/converter/other/fiasco/input/basis.c @@ -16,6 +16,8 @@ #include "config.h" +#include "nstring.h" + #include "types.h" #include "macros.h" #include "error.h" diff --git a/converter/other/fiasco/input/read.c b/converter/other/fiasco/input/read.c index 26bae7e4..23f92070 100644 --- a/converter/other/fiasco/input/read.c +++ b/converter/other/fiasco/input/read.c @@ -23,6 +23,8 @@ #include <string.h> +#include "nstring.h" + #include "types.h" #include "macros.h" #include "error.h" diff --git a/converter/other/fiasco/lib/bit-io.c b/converter/other/fiasco/lib/bit-io.c index 364a1c05..04017c31 100644 --- a/converter/other/fiasco/lib/bit-io.c +++ b/converter/other/fiasco/lib/bit-io.c @@ -24,6 +24,8 @@ # include <stdlib.h> #endif /* not STDC_HEADERS */ +#include "nstring.h" + #include "macros.h" #include "types.h" #include "error.h" diff --git a/converter/other/fiasco/lib/image.c b/converter/other/fiasco/lib/image.c index 019ba03c..30fefdd2 100644 --- a/converter/other/fiasco/lib/image.c +++ b/converter/other/fiasco/lib/image.c @@ -1,8 +1,8 @@ /* - * image.c: Input and output of PNM images. + * image.c: Input and output of PNM images. * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO («F»ractal «I»mage «A»nd «S»equence «CO»dec) * Copyright (C) 1994-2000 Ullrich Hafner <hafner@bigfoot.de> */ @@ -18,6 +18,8 @@ #include <string.h> +#include "nstring.h" + #include "types.h" #include "macros.h" #include "error.h" @@ -28,7 +30,7 @@ /***************************************************************************** - prototypes + prototypes *****************************************************************************/ @@ -37,7 +39,7 @@ init_chroma_tables (void); /***************************************************************************** - local variables + local variables *****************************************************************************/ static int *Cr_r_tab = NULL; @@ -47,41 +49,80 @@ static int *Cb_b_tab = NULL; /***************************************************************************** - public code + public code *****************************************************************************/ +static fiasco_image_t * +make_image_base(void) +{ + fiasco_image_t * const imageP = Calloc (1, sizeof (fiasco_image_t)); + + if (imageP == NULL) + pm_error("Failed to allocate memory for image object"); + else { + imageP->delete = fiasco_image_delete; + imageP->get_width = fiasco_image_get_width; + imageP->get_height = fiasco_image_get_height; + imageP->is_color = fiasco_image_is_color; + } + return imageP; +} + + + fiasco_image_t * -fiasco_image_new (const char *filename) +fiasco_image_new_file(const char * const filename) /* * FIASCO image constructor. * Allocate memory for the FIASCO image structure and - * load the specified image `filename'. The image has to be in - * raw pgm or ppm format. + * load the image from PNM file `filename'. * * Return value: - * pointer to the new image structure - * or NULL in case of an error + * pointer to the new image structure + * or NULL in case of an error */ { - try - { - fiasco_image_t *image = Calloc (1, sizeof (fiasco_image_t)); + fiasco_image_t * imageP; - image->private = read_image (filename); - image->delete = fiasco_image_delete; - image->get_width = fiasco_image_get_width; - image->get_height = fiasco_image_get_height; - image->is_color = fiasco_image_is_color; + imageP = make_image_base(); - return image; - } - catch - { - return NULL; - } + imageP->private = read_image_file(filename); + + return imageP; +} + + + +fiasco_image_t * +fiasco_image_new_stream(FILE * const ifP, + unsigned int const width, + unsigned int const height, + xelval const maxval, + int const format) +/* + * FIASCO image constructor. + * Allocate memory for the FIASCO image structure and + * load the image from the PNM stream in *ifP, which is positioned just + * after the header. 'width', 'height', 'maxval', and 'format' are the + * parameters of the image, i.e. the contents of that header. + * + * Return value: + * pointer to the new image structure + * or NULL in case of an error + */ +{ + fiasco_image_t * imageP; + + imageP = make_image_base(); + + imageP->private = read_image_stream(ifP, width, height, maxval, format); + + return imageP; } + + void fiasco_image_delete (fiasco_image_t *image) /* @@ -91,7 +132,7 @@ fiasco_image_delete (fiasco_image_t *image) * No return value. * * Side effects: - * structure 'image' is discarded. + * structure 'image' is discarded. */ { image_t *this = cast_image (image); @@ -149,7 +190,7 @@ cast_image (fiasco_image_t *image) * Check whether `image' is a valid object of type image_t. * * Return value: - * pointer to dfiasco_t struct on success + * pointer to dfiasco_t struct on success * NULL otherwise */ { @@ -158,8 +199,8 @@ cast_image (fiasco_image_t *image) { if (!streq (this->id, "IFIASCO")) { - set_error (_("Parameter `image' doesn't match required type.")); - return NULL; + set_error (_("Parameter `image' doesn't match required type.")); + return NULL; } } else @@ -182,7 +223,7 @@ alloc_image (unsigned width, unsigned height, bool_t color, format_e format) * are stored in 4:4:4 or 4:2:0 format. * * Return value: - * pointer to the new image structure. + * pointer to the new image structure. */ { image_t *image; @@ -193,21 +234,21 @@ alloc_image (unsigned width, unsigned height, bool_t color, format_e format) if (!color) format = FORMAT_4_4_4; - image = Calloc (1, sizeof (image_t)); - image->width = width; - image->height = height; - image->color = color; - image->format = format; + image = Calloc (1, sizeof (image_t)); + image->width = width; + image->height = height; + image->color = color; + image->format = format; image->reference_count = 1; strcpy (image->id, "IFIASCO"); for (band = first_band (color); band <= last_band (color); band++) if (format == FORMAT_4_2_0 && band != Y) - image->pixels [band] = Calloc ((width * height) >> 2, - sizeof (word_t)); + image->pixels [band] = Calloc ((width * height) >> 2, + sizeof (word_t)); else - image->pixels [band] = Calloc (width * height, sizeof (word_t)); + image->pixels [band] = Calloc (width * height, sizeof (word_t)); return image; } @@ -219,23 +260,23 @@ clone_image (image_t *image) * Construct new image by copying the given `image'. * * Return value: - * pointer to the new image structure. + * pointer to the new image structure. */ { image_t *new = alloc_image (image->width, image->height, image->color, - image->format); + image->format); color_e band; for (band = first_band (new->color); band <= last_band (new->color); band++) if (new->format == FORMAT_4_2_0 && band != Y) { - memcpy (new->pixels [band], image->pixels [band], - ((new->width * new->height) >> 2) * sizeof (word_t)); + memcpy (new->pixels [band], image->pixels [band], + ((new->width * new->height) >> 2) * sizeof (word_t)); } else { - memcpy (new->pixels [band], image->pixels [band], - new->width * new->height * sizeof (word_t)); + memcpy (new->pixels [band], image->pixels [band], + new->width * new->height * sizeof (word_t)); } return new; @@ -250,22 +291,22 @@ free_image (image_t *image) * No return value. * * Side effects: - * structure 'image' is discarded. + * structure 'image' is discarded. */ { if (image != NULL) { if (--image->reference_count) - return; /* image is still referenced */ + return; /* image is still referenced */ else { - color_e band; + color_e band; - for (band = first_band (image->color); - band <= last_band (image->color); band++) - if (image->pixels [band]) - Free (image->pixels [band]); - Free (image); + for (band = first_band (image->color); + band <= last_band (image->color); band++) + if (image->pixels [band]) + Free (image->pixels [band]); + Free (image); } } else @@ -327,27 +368,19 @@ read_image_data(image_t * const image, FILE *input, const bool_t color, image_t * -read_image (const char *image_name) +read_image_stream(FILE * const ifP, + unsigned int const width, + unsigned int const height, + xelval const maxval, + int const format) /* - * Read image 'image_name'. - * - * Return value: - * pointer to the image structure. + * Read one PNM image from stream *ifP, which is positioned just after the + * header. 'width', 'height', 'maxval', and 'format' are the parameters of + * the image (i.e. the contents of that header). */ { - FILE *input; /* input stream */ - image_t *image; /* pointer to new image structure */ - int width, height; /* image size */ - xelval maxval; /* Maxval of image */ - int format; /* Image's format code */ - bool_t color; /* color image ? (YES/NO) */ - - if (image_name == NULL) - input = stdin; - else - input = pm_openr((char*)image_name); - - pnm_readpnminit(input, &width, &height, &maxval, &format); + image_t *image; /* pointer to new image structure */ + bool_t color; /* color image ? (YES/NO) */ if (PNM_FORMAT_TYPE(format) == PPM_FORMAT) color = YES; @@ -362,12 +395,40 @@ read_image (const char *image_name) image = alloc_image (width, height, color, FORMAT_4_4_4); - read_image_data(image, input, color, width, height, maxval, format); + read_image_data(image, ifP, color, width, height, maxval, format); - pm_close(input); - return image; -} +} + + + +image_t * +read_image_file(const char * const filename) +/* + * Read the PNM image from the file named 'filename'. + * + * Return value: + * pointer to the image structure. + */ +{ + FILE * ifP; + int width, height; /* image dimensions */ + xelval maxval; /* Maxval of image */ + int format; /* Image's format code */ + image_t * imageP; /* pointer to new image structure */ + + ifP = pm_openr(filename); + + pnm_readpnminit(ifP, &width, &height, &maxval, &format); + + imageP = read_image_stream(ifP, width, height, maxval, format); + + pm_close(ifP); + + return imageP; +} + + void write_image (const char *image_name, const image_t *image) @@ -377,12 +438,12 @@ write_image (const char *image_name, const image_t *image) * No return value. */ { - FILE *output; /* output stream */ + FILE *output; /* output stream */ int format; int row; int i; /* Cursor into image->pixel arrays */ xel * xelrow; - unsigned *gray_clip; /* clipping table */ + unsigned *gray_clip; /* clipping table */ assert (image && image_name); @@ -394,12 +455,12 @@ write_image (const char *image_name, const image_t *image) if (image_name == NULL) output = stdout; - else if (strcmp(image_name, "-") == 0) + else if (streq(image_name, "-")) output = stdout; else output = pm_openw((char*)image_name); - gray_clip = init_clipping (); /* mapping of int -> unsigned */ + gray_clip = init_clipping (); /* mapping of int -> unsigned */ if (!gray_clip) error (fiasco_get_error_message ()); init_chroma_tables (); @@ -445,21 +506,21 @@ same_image_type (const image_t *img1, const image_t *img2) * Check whether the given images 'img1' and `img2' are of the same type. * * Return value: - * YES if images 'img1' and `img2' are of the same type - * NO otherwise. + * YES if images 'img1' and `img2' are of the same type + * NO otherwise. */ { assert (img1 && img2); return ((img1->width == img2->width) - && (img1->height == img2->height) - && (img1->color == img2->color) - && (img1->format == img2->format)); + && (img1->height == img2->height) + && (img1->color == img2->color) + && (img1->format == img2->format)); } /***************************************************************************** - private code + private code *****************************************************************************/ @@ -509,4 +570,3 @@ init_chroma_tables (void) Cb_g_tab += 256 + 128; Cb_b_tab += 256 + 128; } - diff --git a/converter/other/fiasco/lib/image.h b/converter/other/fiasco/lib/image.h index 958049f6..00978526 100644 --- a/converter/other/fiasco/lib/image.h +++ b/converter/other/fiasco/lib/image.h @@ -20,6 +20,7 @@ #include <stdio.h> #include "types.h" #include "fiasco.h" +#include "pnm.h" typedef enum {FORMAT_4_4_4, FORMAT_4_2_0} format_e; @@ -48,8 +49,17 @@ free_image (image_t *image); FILE * read_pnmheader (const char *image_name, unsigned *width, unsigned *height, bool_t *color); + +image_t * +read_image_stream(FILE * const ifP, + unsigned int const width, + unsigned int const height, + xelval const maxval, + int const format); + image_t * -read_image (const char *image_name); +read_image_file(const char * const filename); + void write_image (const char *image_name, const image_t *image); bool_t diff --git a/converter/other/fiasco/pnmtofiasco.c b/converter/other/fiasco/pnmtofiasco.c index 2218256d..07b97d7e 100644 --- a/converter/other/fiasco/pnmtofiasco.c +++ b/converter/other/fiasco/pnmtofiasco.c @@ -1,8 +1,8 @@ /* - * cwfa.c: FIASCO coder + * cwfa.c: FIASCO coder * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO («F»ractal «I»mage «A»nd «S»equence «CO»dec) * Copyright (C) 1994-2000 Ullrich Hafner <hafner@bigfoot.de> */ @@ -18,14 +18,14 @@ #include "pnm.h" #if STDC_HEADERS -# include <stdlib.h> -# include <string.h> +# include <stdlib.h> +# include <string.h> #else /* not STDC_HEADERS */ -# if HAVE_STRING_H -# include <string.h> -# else /* not HAVE_STRING_H */ -# include <strings.h> -# endif /* not HAVE_STRING_H */ +# if HAVE_STRING_H +# include <string.h> +# else /* not HAVE_STRING_H */ +# include <strings.h> +# endif /* not HAVE_STRING_H */ #endif /* not STDC_HEADERS */ #include "types.h" @@ -38,7 +38,7 @@ /***************************************************************************** - local variables + local variables *****************************************************************************/ @@ -144,27 +144,27 @@ static param_t params [] = /***************************************************************************** - prototypes + prototypes *****************************************************************************/ static void checkargs (int argc, char **argv, char const ***image_template, - char **wfa_name, float *quality, fiasco_c_options_t **options); + char **wfa_name, float *quality, fiasco_c_options_t **options); /***************************************************************************** - public code + public code *****************************************************************************/ 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 */ + 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); @@ -184,228 +184,228 @@ main (int argc, char **argv) /***************************************************************************** - private code + private code *****************************************************************************/ static void checkargs (int argc, char **argv, char const ***image_template, - char **wfa_name, float *quality, fiasco_c_options_t **options) + 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 + * 1 on success + * 0 otherwise * * * Side effects: - * 'image_template', 'wfa_name', 'quality' and 'options' are set. + * 'image_template', 'wfa_name', 'quality' and 'options' are set. */ { - int optind; /* last processed commandline param */ - char *image_name; /* filename given by option '-i' */ - int i; /* counter */ + 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"); + 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): "); - } + /* + * 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 -i %s already specified!", image_name); + 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 (); + *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"); + { + char *pattern = (char *) parameter_value (params, "pattern"); - if (!fiasco_c_options_set_frame_pattern (*options, pattern)) - error (fiasco_get_error_message ()); - } + 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 ()); - } + { + 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"); + { + 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 ()); - } + 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, "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; + { + 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 ()); - } + 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 *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"); + { + char *c = (char *) parameter_value (params, "comment"); - if (strlen (c) > 0 && !fiasco_c_options_set_comment (*options, c)) - error (fiasco_get_error_message ()); - } + 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"); + { + 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 (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 ()); - } + 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"); + { + 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 (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); - } -} + if (fiasco_get_verbosity () == FIASCO_ULTIMATE_VERBOSITY) + write_parameters (params, stderr); + } +} diff --git a/converter/other/fitstopnm.c b/converter/other/fitstopnm.c index 0d8753e5..92ecfb78 100644 --- a/converter/other/fitstopnm.c +++ b/converter/other/fitstopnm.c @@ -34,10 +34,16 @@ The official specification of FITS format (which is for more than just visual images) is at ftp://legacy.gsfc.nasa.gov/fits_info/fits_office/fits_standard.pdf + + An example FITS file is at + + http://fits.gsfc.nasa.gov/nrao_data/tests/incunabula/mndrll-8.fits + */ #include <string.h> #include <float.h> +#include <assert.h> #include "pm_config.h" #include "pm_c_util.h" @@ -145,7 +151,10 @@ parseCommandLine(int argc, char ** argv, struct FITS_Header { int simple; /* basic format or not */ - int bitpix; /* number of bits per pixel */ + int bitpix; + /* number of bits per pixel, positive for integer, negative + for floating point + */ int naxis; /* number of axes */ int naxis1; /* number of points on axis 1 */ int naxis2; /* number of points on axis 2 */ @@ -157,6 +166,16 @@ struct FITS_Header { }; +typedef enum { + VF_CHAR, VF_SHORT, VF_LONG, VF_FLOAT, VF_DOUBLE +} valFmt; + +struct fitsRasterInfo { + valFmt valFmt; + double bzer; + double bscale; +}; + /* This code deals properly with integers, no matter what the byte order or integer size of the host machine. We handle sign extension manually to prevent problems with signed/unsigned characters. We read floating point @@ -276,34 +295,56 @@ readFitsDouble(FILE * const ifP, +static valFmt +valFmtFromBitpix(int const bitpix) { +/*---------------------------------------------------------------------------- + Return the format of a "value" in the FITS file, given the value + of the BITPIX header in the FITS file. + + BITPIX has a stupid format wherein it is fundamentally the number + of bits per value, but its sign indicates whether it is integer + or floating point. +-----------------------------------------------------------------------------*/ + switch (bitpix) { + case +8: return VF_CHAR; + case +16: return VF_SHORT; + case +32: return VF_LONG; + case -32: return VF_FLOAT; + case -64: return VF_DOUBLE; + default: + /* Every possibility is covered above. */ + assert(false); + return 0; /* quiet compiler warning */ + } +} + + + static void readVal(FILE * const ifP, - int const bitpix, + valFmt const fmt, double * const vP) { - switch (bitpix) { - case 8: + switch (fmt) { + case VF_CHAR: readFitsChar(ifP, vP); break; - case 16: + case VF_SHORT: readFitsShort(ifP, vP); break; - case 32: + case VF_LONG: readFitsLong(ifP, vP); break; - case -32: + case VF_FLOAT: readFitsFloat(ifP, vP); break; - case -64: + case VF_DOUBLE: readFitsDouble(ifP, vP); break; - - default: - pm_error("Strange bitpix value %d in readVal()", bitpix); } } @@ -419,7 +460,7 @@ scanImageForMinMax(FILE * const ifP, unsigned int const images, int const cols, int const rows, - unsigned int const bitpix, + valFmt const valFmt, double const bscale, double const bzer, unsigned int const imagenum, @@ -436,14 +477,12 @@ scanImageForMinMax(FILE * const ifP, pm_message("Scanning file for scaling parameters"); - switch (bitpix) { - case 8: fmaxval = 255.0; break; - case 16: fmaxval = 65535.0; break; - case 32: fmaxval = 4294967295.0; break; - case -32: fmaxval = FLT_MAX; break; - case -64: fmaxval = DBL_MAX; break; - default: - pm_error("unusual bits per pixel (%u), can't read", bitpix); + switch (valFmt) { + case VF_CHAR: fmaxval = 255.0; break; + case VF_SHORT: fmaxval = 65535.0; break; + case VF_LONG: fmaxval = 4294967295.0; break; + case VF_FLOAT: fmaxval = FLT_MAX; break; + case VF_DOUBLE: fmaxval = DBL_MAX; break; } dmax = -fmaxval; @@ -454,7 +493,7 @@ scanImageForMinMax(FILE * const ifP, unsigned int col; for (col = 0; col < cols; ++col) { double val; - readVal(ifP, bitpix, &val); + readVal(ifP, valFmt, &val); if (image == imagenum || multiplane ) { dmax = MAX(dmax, val); dmin = MIN(dmin, val); @@ -509,7 +548,8 @@ computeMinMax(FILE * const ifP, if (datamin == -DBL_MAX || datamax == DBL_MAX) { double scannedDatamin, scannedDatamax; - scanImageForMinMax(ifP, images, cols, rows, h.bitpix, h.bscale, h.bzer, + scanImageForMinMax(ifP, images, cols, rows, + valFmtFromBitpix(h.bitpix), h.bscale, h.bzer, imagenum, multiplane, &scannedDatamin, &scannedDatamax); @@ -526,7 +566,7 @@ computeMinMax(FILE * const ifP, static xelval determineMaxval(struct cmdlineInfo const cmdline, - struct FITS_Header const fitsHeader, + valFmt const valFmt, double const datamax, double const datamin) { @@ -535,7 +575,7 @@ determineMaxval(struct cmdlineInfo const cmdline, if (cmdline.omaxvalSpec) retval = cmdline.omaxval; else { - if (fitsHeader.bitpix < 0) { + if (valFmt == VF_FLOAT || valFmt == VF_DOUBLE) { /* samples are floating point, which means the resolution could be anything. So we just pick a convenient maxval of 255. Before Netpbm 10.20 (January 2004), we did @@ -561,16 +601,16 @@ determineMaxval(struct cmdlineInfo const cmdline, static void -convertPgmRaster(FILE * const ifP, - unsigned int const cols, - unsigned int const rows, - xelval const maxval, - unsigned int const desiredImage, - unsigned int const imageCount, - struct FITS_Header const fitsHdr, - double const scale, - double const datamin, - xel ** const xels) { +convertPgmRaster(FILE * const ifP, + unsigned int const cols, + unsigned int const rows, + xelval const maxval, + unsigned int const desiredImage, + unsigned int const imageCount, + struct fitsRasterInfo const rasterInfo, + double const scale, + double const datamin, + xel ** const xels) { /* Note: the FITS specification does not give the association between file position and image position (i.e. is the first pixel in the @@ -593,10 +633,10 @@ convertPgmRaster(FILE * const ifP, unsigned int col; for (col = 0; col < cols; ++col) { double val; - readVal(ifP, fitsHdr.bitpix, &val); + readVal(ifP, rasterInfo.valFmt, &val); { double const t = scale * - (val * fitsHdr.bscale + fitsHdr.bzer - datamin); + (val * rasterInfo.bscale + rasterInfo.bzer - datamin); xelval const tx = MAX(0, MIN(t, maxval)); if (image == desiredImage) PNM_ASSIGN1(xels[row][col], tx); @@ -609,14 +649,14 @@ convertPgmRaster(FILE * const ifP, static void -convertPpmRaster(FILE * const ifP, - unsigned int const cols, - unsigned int const rows, - xelval const maxval, - struct FITS_Header const fitsHdr, - double const scale, - double const datamin, - xel ** const xels) { +convertPpmRaster(FILE * const ifP, + unsigned int const cols, + unsigned int const rows, + xelval const maxval, + struct fitsRasterInfo const rasterInfo, + double const scale, + double const datamin, + xel ** const xels) { /*---------------------------------------------------------------------------- Read the FITS raster from file *ifP into xels[][]. Image dimensions are 'cols' by 'rows'. The FITS raster is 3 planes composing one @@ -634,10 +674,10 @@ convertPpmRaster(FILE * const ifP, unsigned int col; for (col = 0; col < cols; ++col) { double val; - readVal(ifP, fitsHdr.bitpix, &val); + readVal(ifP, rasterInfo.valFmt, &val); { double const t = scale * - (val * fitsHdr.bscale + fitsHdr.bzer - datamin); + (val * rasterInfo.bscale + rasterInfo.bzer - datamin); xelval const sample = MAX(0, MIN(t, maxval)); switch (plane) { @@ -654,17 +694,17 @@ convertPpmRaster(FILE * const ifP, static void -convertRaster(FILE * const ifP, - unsigned int const cols, - unsigned int const rows, - xelval const maxval, - bool const forceplain, - bool const multiplane, - unsigned int const desiredImage, - unsigned int const imageCount, - struct FITS_Header const fitsHdr, - double const scale, - double const datamin) { +convertRaster(FILE * const ifP, + unsigned int const cols, + unsigned int const rows, + xelval const maxval, + bool const forceplain, + bool const multiplane, + unsigned int const desiredImage, + unsigned int const imageCount, + struct fitsRasterInfo const rasterInfo, + double const scale, + double const datamin) { xel ** xels; int format; @@ -673,12 +713,12 @@ convertRaster(FILE * const ifP, if (multiplane) { format = PPM_FORMAT; - convertPpmRaster(ifP, cols, rows, maxval, fitsHdr, scale, datamin, + convertPpmRaster(ifP, cols, rows, maxval, rasterInfo, scale, datamin, xels); } else { format = PGM_FORMAT; convertPgmRaster(ifP, cols, rows, maxval, - desiredImage, imageCount, fitsHdr, scale, datamin, + desiredImage, imageCount, rasterInfo, scale, datamin, xels); } pnm_writepnm(stdout, xels, cols, rows, maxval, format, forceplain); @@ -697,6 +737,7 @@ main(int argc, char * argv[]) { double scale; double datamin, datamax; struct FITS_Header fitsHeader; + struct fitsRasterInfo rasterInfo; unsigned int imageCount; unsigned int desiredImage; @@ -725,6 +766,10 @@ main(int argc, char * argv[]) { cols = fitsHeader.naxis1; rows = fitsHeader.naxis2; + rasterInfo.bscale = fitsHeader.bscale; + rasterInfo.bzer = fitsHeader.bzer; + rasterInfo.valFmt = valFmtFromBitpix(fitsHeader.bitpix); + interpretPlanes(fitsHeader, cmdline.image, cmdline.verbose, &imageCount, &multiplane, &desiredImage); @@ -734,7 +779,7 @@ main(int argc, char * argv[]) { cmdline.min, cmdline.max, &datamin, &datamax); - maxval = determineMaxval(cmdline, fitsHeader, datamax, datamin); + maxval = determineMaxval(cmdline, rasterInfo.valFmt, datamax, datamin); if (datamax - datamin == 0) scale = 1.0; @@ -746,7 +791,7 @@ main(int argc, char * argv[]) { else convertRaster(ifP, cols, rows, maxval, cmdline.noraw, multiplane, desiredImage, imageCount, - fitsHeader, scale, datamin); + rasterInfo, scale, datamin); pm_close(ifP); pm_close(stdout); diff --git a/converter/other/jpeg2000/jpeg2ktopam.c b/converter/other/jpeg2000/jpeg2ktopam.c index e6db7658..d3768a0e 100644 --- a/converter/other/jpeg2000/jpeg2ktopam.c +++ b/converter/other/jpeg2000/jpeg2ktopam.c @@ -41,7 +41,7 @@ parseCommandLine(int argc, char ** argv, struct cmdlineInfo * const cmdlineP) { /*---------------------------------------------------------------------------- Note that many of the strings that this function returns in the - *cmdline_p structure are actually in the supplied argv array. And + *cmdlineP structure are actually in the supplied argv array. And sometimes, one of these strings is actually just a suffix of an entry in argv! -----------------------------------------------------------------------------*/ @@ -82,36 +82,57 @@ parseCommandLine(int argc, char ** argv, static void -readJpc(const char * const inputFilename, +validateJ2k(jas_stream_t * const instreamP) { +/*---------------------------------------------------------------------------- + Abort program with error message if *instreamP is not a JPEG-2000 code + stream (JPC) or image file (JP2). +-----------------------------------------------------------------------------*/ + assert(jas_image_lookupfmtbyname("jpc")); + assert(jas_image_lookupfmtbyname("jp2")); + + if (jas_image_lookupfmtbyname("jpc")->ops.validate(instreamP) != 0 && + jas_image_lookupfmtbyname("jp2")->ops.validate(instreamP) != 0) { + + pm_error("Input is not JPEG-2000 image file (JP2) " + "or code stream (JPC). " + "(the first few bytes of the file are not the required " + "signature)"); + } +} + + + + +static void +readJ2k(const char * const inputFilename, jas_image_t ** const jasperPP) { jas_image_t * jasperP; - jas_stream_t *instream; + jas_stream_t * instreamP; const char * options; if ( strcmp(inputFilename, "-") == 0) { /* The input image is to be read from standard input. */ - instream = jas_stream_fdopen(fileno(stdin), "rb"); - if (instream == NULL) + instreamP = jas_stream_fdopen(fileno(stdin), "rb"); + if (instreamP == NULL) pm_error("error: cannot reopen standard input"); } else { - instream = jas_stream_fopen(inputFilename, "rb"); - if (instream == NULL ) + instreamP = jas_stream_fopen(inputFilename, "rb"); + if (instreamP == NULL ) pm_error("cannot open input image file '%s'", inputFilename); } - if (jas_image_getfmt(instream) != jas_image_strtofmt((char*)"jpc")) - pm_error("Input is not JPEG-2000 code stream"); + validateJ2k(instreamP); options = ""; - jasperP = jas_image_decode(instream, jas_image_strtofmt((char*)"jpc"), + jasperP = jas_image_decode(instreamP, jas_image_getfmt(instreamP), (char*)options); if (jasperP == NULL) pm_error("Unable to interpret JPEG-2000 input. " "The Jasper library jas_image_decode() subroutine failed."); - jas_stream_close(instream); + jas_stream_close(instreamP); *jasperPP = jasperP; } @@ -189,7 +210,7 @@ static void validateComponentsAlike(jas_image_t * const jasperP) { /*---------------------------------------------------------------------------- JPC allows each component to have its own width and height. But - PAM requires all planes to the same shape. So we validate now that + PAM requires all planes to have the same shape. So we validate now that all the channels are the same, and abort the program if not. -----------------------------------------------------------------------------*/ int cmptNo; @@ -479,7 +500,7 @@ main(int argc, char **argv) jas_setdbglevel(cmdline.debuglevel); - readJpc(cmdline.inputFilename, &jasperP); + readJ2k(cmdline.inputFilename, &jasperP); outpam.file = stdout; outpam.size = sizeof(outpam); diff --git a/converter/other/jpeg2000/libjasper/README b/converter/other/jpeg2000/libjasper/README index ad3e019b..b0512fe8 100644 --- a/converter/other/jpeg2000/libjasper/README +++ b/converter/other/jpeg2000/libjasper/README @@ -6,10 +6,12 @@ The adaptation was done by Bryan Henderson on 2002.10.26. The adaptation involved: - - remove stuff for formats other than PNM. + - Remove stuff for formats other than JPEG-2000. - Replace build stuff (Jasper uses GNU Autoconf/Automake/Libtool). + - Make JP2 decoder not dump the box to stderr unless debug is turned on. + See <http://www.ece.uvic.ca/~mdadams/jasper/>. diff --git a/converter/other/jpeg2000/libjasper/jp2/jp2_cod.c b/converter/other/jpeg2000/libjasper/jp2/jp2_cod.c index cb70fd24..f8fc013b 100644 --- a/converter/other/jpeg2000/libjasper/jp2/jp2_cod.c +++ b/converter/other/jpeg2000/libjasper/jp2/jp2_cod.c @@ -337,8 +337,9 @@ jp2_box_t *jp2_box_get(jas_stream_t *in) jas_stream_close(tmpstream); } - jp2_box_dump(box, stderr); - + if (jas_getdbglevel() > 0) { + jp2_box_dump(box, stderr); + } return box; abort(); diff --git a/converter/other/jpeg2000/libjasper/jp2/jp2_dec.c b/converter/other/jpeg2000/libjasper/jp2/jp2_dec.c index 3cce9278..aaebf411 100644 --- a/converter/other/jpeg2000/libjasper/jp2/jp2_dec.c +++ b/converter/other/jpeg2000/libjasper/jp2/jp2_dec.c @@ -340,7 +340,8 @@ jas_image_t *jp2_decode(jas_stream_t *in, char *optstr) iccp = dec->colr->data.colr.iccp; cs = (iccp[16] << 24) | (iccp[17] << 16) | (iccp[18] << 8) | iccp[19]; - jas_eprintf("ICC Profile CS %08x\n", cs); + if (jas_getdbglevel() > 1) + jas_eprintf("ICC Profile CS %08x\n", cs); jas_image_setcolorspace(dec->image, fromiccpcs(cs)); break; } @@ -454,7 +455,6 @@ jas_image_t *jp2_decode(jas_stream_t *in, char *optstr) jas_eprintf("error: no components\n"); goto error; } -fprintf(stderr, "no of components is %d\n", jas_image_numcmpts(dec->image)); /* Prevent the image from being destroyed later. */ image = dec->image; diff --git a/converter/other/pamtopfm.c b/converter/other/pamtopfm.c index 129b8eee..882f75c3 100644 --- a/converter/other/pamtopfm.c +++ b/converter/other/pamtopfm.c @@ -150,12 +150,12 @@ floatToPfmSample(float const input, Type converter -----------------------------------------------------------------------------*/ if (machineEndianness == pfmEndianness) { - *(float *)outputP->bytes = input; + MEMSCPY(&outputP->bytes, &input); } else { unsigned char reversed[sizeof(pfmSample)]; unsigned int i, j; - *(float *)reversed = input; + MEMSCPY(&reversed, &input); for (i = 0, j = sizeof(pfmSample)-1; i < sizeof(pfmSample); diff --git a/converter/other/pgmtopbm.c b/converter/other/pgmtopbm.c index f828b716..dfc6c865 100644 --- a/converter/other/pgmtopbm.c +++ b/converter/other/pgmtopbm.c @@ -585,6 +585,7 @@ createDither8Converter(unsigned int const cols, converter.convertRow = &dither8ConvertRow; converter.destroy = dither8Destroy; converter.stateP = stateP; + converter.maxval = maxval; /* Scale dither matrix. */ for (row = 0; row < 16; ++row) { @@ -660,6 +661,7 @@ createClusterConverter(unsigned int const radius, unsigned int row; converter.cols = cols; + converter.maxval = maxval; converter.convertRow = &clusterConvertRow; converter.destroy = &clusterDestroy; diff --git a/converter/other/pnmtopng.c b/converter/other/pnmtopng.c index 6cef96ad..200cca44 100644 --- a/converter/other/pnmtopng.c +++ b/converter/other/pnmtopng.c @@ -493,9 +493,10 @@ parseCommandLine(int argc, char ** argv, static png_color_16 -xelToPngColor_16(xel const input, +xelToPngColor_16(xel const input, xelval const maxval, xelval const pngMaxval) { + png_color_16 retval; xel scaled; @@ -1926,6 +1927,10 @@ computeColorMap(FILE * const ifP, palette_pnm[] and trans_pnm[], allocated by Caller, with sizes *paletteSizeP and *transSizeP. + 'pfP' is a handle to the file that the user requested be used for the + palette (it's a Netpbm image whose colors are the colors of the palette). + 'pfP' is null if the user did not request a particular palette. + 'background' means the image is to have a background color, and that color is 'backcolor'. 'backcolor' is meaningless when 'background' is false. @@ -2559,11 +2564,11 @@ doSbitChunk(png_info * const pngInfoP, static void convertpnm(struct cmdlineInfo const cmdline, - FILE * const ifp, - FILE * const ofp, - FILE * const afp, - FILE * const pfp, - FILE * const tfp, + FILE * const ifP, + FILE * const ofP, + FILE * const afP, + FILE * const pfP, + FILE * const tfP, int * const errorLevelP ) { /*---------------------------------------------------------------------------- @@ -2654,8 +2659,8 @@ convertpnm(struct cmdlineInfo const cmdline, pngx_create(&pngxP, PNGX_WRITE, &jmpbuf); - pnm_readpnminit(ifp, &cols, &rows, &maxval, &format); - pm_tell2(ifp, &rasterPos, sizeof(rasterPos)); + pnm_readpnminit(ifP, &cols, &rows, &maxval, &format); + pm_tell2(ifP, &rasterPos, sizeof(rasterPos)); pnm_type = PNM_FORMAT_TYPE(format); xelrow = pnm_allocrow(cols); @@ -2669,8 +2674,8 @@ convertpnm(struct cmdlineInfo const cmdline, pm_message ("reading a PPM file (maxval=%d)", maxval); } - determineTransparency(cmdline, ifp, rasterPos, cols, rows, maxval, format, - afp, + determineTransparency(cmdline, ifP, rasterPos, cols, rows, maxval, format, + afP, &alpha, &transparent, &transcolor, &transexact, &alpha_mask, &alpha_maxval); @@ -2683,10 +2688,10 @@ convertpnm(struct cmdlineInfo const cmdline, bool isgray; isgray = TRUE; /* initial assumption */ - pm_seek2(ifp, &rasterPos, sizeof(rasterPos)); + pm_seek2(ifP, &rasterPos, sizeof(rasterPos)); for (row = 0; row < rows && isgray; ++row) { unsigned int col; - pnm_readpnmrow(ifp, xelrow, cols, maxval, format); + pnm_readpnmrow(ifP, xelrow, cols, maxval, format); for (col = 0; col < cols && isgray; ++col) { p = xelrow[col]; if (PPM_GETR(p) != PPM_GETG(p) || PPM_GETG(p) != PPM_GETB(p)) @@ -2704,11 +2709,11 @@ convertpnm(struct cmdlineInfo const cmdline, "(use -downscale to override"); } - findRedundantBits(ifp, rasterPos, cols, rows, maxval, format, alpha, + findRedundantBits(ifP, rasterPos, cols, rows, maxval, format, alpha, cmdline.force, &pnm_meaningful_bits); - computeColorMap(ifp, rasterPos, cols, rows, maxval, format, - cmdline.force, pfp, + computeColorMap(ifP, rasterPos, cols, rows, maxval, format, + cmdline.force, pfP, alpha, transparent >= 0, transcolor, transexact, !!cmdline.background, backcolor, alpha_mask, alpha_maxval, pnm_meaningful_bits, @@ -2716,7 +2721,7 @@ convertpnm(struct cmdlineInfo const cmdline, &background_index, &noColormapReason); if (noColormapReason) { - if (pfp) + if (pfP) pm_error("You specified a particular palette, but this image " "cannot be represented by any palette. %s", noColormapReason); @@ -2775,7 +2780,7 @@ convertpnm(struct cmdlineInfo const cmdline, pngxP->info_ptr->palette = palette; pngxP->info_ptr->num_palette = palette_size; - doHistChunk(cmdline.hist, palette_pnm, ifp, rasterPos, + doHistChunk(cmdline.hist, palette_pnm, ifP, rasterPos, cols, rows, maxval, format, pngxP->info_ptr, cmdline.verbose); } @@ -2791,7 +2796,7 @@ convertpnm(struct cmdlineInfo const cmdline, /* tEXT and zTXT chunks */ if (cmdline.text || cmdline.ztxt) - pnmpng_read_text(pngxP->info_ptr, tfp, !!cmdline.ztxt, cmdline.verbose); + pnmpng_read_text(pngxP->info_ptr, tfP, !!cmdline.ztxt, cmdline.verbose); doTimeChunk(cmdline, pngxP->info_ptr); @@ -2800,7 +2805,7 @@ convertpnm(struct cmdlineInfo const cmdline, setZlibCompression(pngxP->png_ptr, cmdline.zlibCompression); - png_init_io(pngxP->png_ptr, ofp); + png_init_io(pngxP->png_ptr, ofP); /* write the png-info struct */ png_write_info(pngxP->png_ptr, pngxP->info_ptr); @@ -2816,7 +2821,7 @@ convertpnm(struct cmdlineInfo const cmdline, /* let libpng take care of, e.g., bit-depth conversions */ png_set_packing(pngxP->png_ptr); - writeRaster(pngxP, ifp, rasterPos, + writeRaster(pngxP, ifP, rasterPos, cols, rows, maxval, format, png_maxval, depth, alpha, alpha_mask, cht, caht); diff --git a/converter/ppm/xpmtoppm.c b/converter/ppm/xpmtoppm.c index 67a76eab..b13f2cad 100644 --- a/converter/ppm/xpmtoppm.c +++ b/converter/ppm/xpmtoppm.c @@ -31,6 +31,7 @@ #define _BSD_SOURCE /* Make sure strdup() is in string.h */ #define _XOPEN_SOURCE 500 /* Make sure strdup() is in string.h */ +#include <assert.h> #include <string.h> #include "pm_c_util.h" @@ -159,15 +160,36 @@ getline(char * const line, static unsigned int -getNumber(char * const p, unsigned int const size) { +getColorNumber(const char * const pArg, + unsigned int const bytesPerPixel, + unsigned int const ncolors) { +/*---------------------------------------------------------------------------- + Return the color number (palette index) at 'p'. + + It occupies 'bytesPerPixel' bytes. + + Abort program if the number is too large for the format described + by 'bytesPerPixel' and 'ncolors'. + +-----------------------------------------------------------------------------*/ + /* Color number is encoded as pure binary, big-endian, unsigned. + (which is stupid, since the rest of the file is text) + */ + const unsigned char * const p = (const unsigned char *)pArg; unsigned int retval; - unsigned char * q; + const unsigned char * q; + + assert(bytesPerPixel <= sizeof(unsigned int)); - retval = 0; - for (q = p; q < p+size; ++q) + for (q = p, retval = 0; q < p + bytesPerPixel; ++q) retval = (retval << 8) + *q; + if (bytesPerPixel > 2 && retval >= ncolors) + pm_error("Color number %u in color map is too large, as the " + "header says there are only %u colors in the image", + retval, ncolors); + return retval; } @@ -191,11 +213,13 @@ getword(char * const output, char ** const cursorP) { static void -addToColorMap(unsigned int const seqNum, - unsigned int const colorNumber, - pixel * const colors, int * const ptab, - char colorspec[], int const isTransparent, - int * const transparentP) { +addToColorMap(unsigned int const seqNum, + unsigned int const colorNumber, + pixel * const colors, + unsigned int * const ptab, + char const colorspec[], + bool const isTransparent, + int * const transparentP) { /*---------------------------------------------------------------------------- Add the color named by colorspec[] to the colormap contained in 'colors' and 'ptab', as the color associated with XPM color number @@ -223,14 +247,17 @@ addToColorMap(unsigned int const seqNum, static void -interpretXpm3ColorTableLine(char line[], int const seqNum, - int const chars_per_pixel, - pixel * const colors, int * const ptab, - int * const transparentP) { +interpretXpm3ColorTableLine(char const line[], + unsigned int const seqNum, + unsigned int const charsPerPixel, + pixel * const colors, + unsigned int * const ptab, + unsigned int const ncolors, + int * const transparentP) { /*---------------------------------------------------------------------------- Interpret one line of the color table in the XPM header. 'line' is the line from the XPM file. It is the seqNum'th color table entry in - the file. The file uses 'chars_per_pixel' characters per pixel. + the file. The file uses 'charsPerPixel' characters per pixel. Add the information from this color table entry to the color table 'colors' and, if it isn't NULL, the corresponding lookup shadow table @@ -259,22 +286,22 @@ interpretXpm3ColorTableLine(char line[], int const seqNum, at least one token. */ char curbuf[BUFSIZ]; /* current buffer */ - int isTransparent; + bool isTransparent; - int colorNumber; + unsigned int colorNumber; /* A color number that appears in the raster */ /* read the chars */ t1 = strchr(line, '"'); if (t1 == NULL) pm_error("A line that is supposed to be an entry in the color " "table does not start with a quote. The line is '%s'. " - "It is the %dth entry in the color table.", + "It is the %uth entry in the color table.", line, seqNum); else t1++; /* Points now to first color number character */ - colorNumber = getNumber(t1, chars_per_pixel); - t1 += chars_per_pixel; + colorNumber = getColorNumber(t1, charsPerPixel, ncolors); + t1 += charsPerPixel; /* * read color keys and values @@ -350,10 +377,14 @@ interpretXpm3ColorTableLine(char line[], int const seqNum, static void -readXpm3Header(FILE * const stream, int * const widthP, int * const heightP, - int * const chars_per_pixelP, int * const ncolorsP, - pixel ** const colorsP, int ** const ptabP, - int * const transparentP) { +readXpm3Header(FILE * const stream, + int * const widthP, + int * const heightP, + unsigned int * const charsPerPixelP, + int * const nColorsP, + pixel ** const colorsP, + unsigned int ** const ptabP, + int * const transparentP) { /*---------------------------------------------------------------------------- Read the header of the XPM file on stream 'stream'. Assume the getline() stream is presently positioned to the beginning of the @@ -384,7 +415,12 @@ readXpm3Header(FILE * const stream, int * const widthP, int * const heightP, char line[MAX_LINE+1]; const char * xpm3_signature = "/* XPM */"; - *widthP = *heightP = *ncolorsP = *chars_per_pixelP = -1; + unsigned int colormapSize; + unsigned int width, height; + unsigned int nColors; + unsigned int charsPerPixel; + pixel * colors; + unsigned int * ptab; /* Read the XPM signature comment */ getline(line, sizeof(line), stream); @@ -407,54 +443,65 @@ readXpm3Header(FILE * const stream, int * const widthP, int * const heightP, getline(line, sizeof(line), stream); getline(line, sizeof(line), stream); } - if (sscanf(line, "\"%d %d %d %d\",", widthP, heightP, - ncolorsP, chars_per_pixelP) != 4) + if (sscanf(line, "\"%u %u %u %u\",", &width, &height, + &nColors, &charsPerPixel) != 4) pm_error("error scanning hints line"); - if (verbose == 1) - { - pm_message("Width x Height: %d x %d", *widthP, *heightP); - pm_message("no. of colors: %d", *ncolorsP); - pm_message("chars per pixel: %d", *chars_per_pixelP); + if (verbose == 1) { + pm_message("Width x Height: %u x %u", width, height); + pm_message("no. of colors: %u", nColors); + pm_message("chars per pixel: %u", charsPerPixel); } /* Allocate space for color table. */ - if (*chars_per_pixelP <= 2) { + if (charsPerPixel <= 2) { /* Set up direct index (see above) */ - *colorsP = ppm_allocrow(*chars_per_pixelP == 1 ? 256 : 256*256); - *ptabP = NULL; + colormapSize = charsPerPixel == 1 ? 256 : 256*256; + ptab = NULL; } else { /* Set up lookup table (see above) */ - *colorsP = ppm_allocrow(*ncolorsP); - MALLOCARRAY(*ptabP, *ncolorsP); - if (*ptabP == NULL) - pm_error("Unable to allocate memory for %d colors", *ncolorsP); + colormapSize = nColors; + MALLOCARRAY(ptab, nColors); + if (ptab == NULL) + pm_error("Unable to allocate memory for %u colors", nColors); } + colors = ppm_allocrow(colormapSize); { /* Read the color table */ - int seqNum; + unsigned int seqNum; /* Sequence number of entry within color table in XPM header */ *transparentP = -1; /* initial value */ - for (seqNum = 0; seqNum < *ncolorsP; seqNum++) { + for (seqNum = 0; seqNum < nColors; ++seqNum) { getline(line, sizeof(line), stream); /* skip the comment line if any */ if (!strncmp(line, "/*", 2)) getline(line, sizeof(line), stream); - interpretXpm3ColorTableLine(line, seqNum, *chars_per_pixelP, - *colorsP, *ptabP, transparentP); + interpretXpm3ColorTableLine(line, seqNum, charsPerPixel, + colors, ptab, nColors, transparentP); } } + *widthP = width; + *heightP = height; + *charsPerPixelP = charsPerPixel; + *nColorsP = nColors; + *colorsP = colors; + *ptabP = ptab; } + static void -readXpm1Header(FILE * const stream, int * const widthP, int * const heightP, - int * const chars_per_pixelP, int * const ncolorsP, - pixel ** const colorsP, int ** const ptabP) { +readXpm1Header(FILE * const stream, + int * const widthP, + int * const heightP, + unsigned int * const charsPerPixelP, + int * const ncolorsP, + pixel ** const colorsP, + unsigned int ** const ptabP) { /*---------------------------------------------------------------------------- Read the header of the XPM file on stream 'stream'. Assume the getline() stream is presently positioned to the beginning of the @@ -466,13 +513,14 @@ readXpm1Header(FILE * const stream, int * const widthP, int * const heightP, char line[MAX_LINE+1], str1[MAX_LINE+1], str2[MAX_LINE+1]; char *t1; char *t2; - int format; - unsigned int v; + int format, v; int i, j; bool processedStaticChar; /* We have read up to and interpreted the "static char..." line */ + bool gotPixel; - *widthP = *heightP = *ncolorsP = *chars_per_pixelP = format = -1; + *widthP = *heightP = *ncolorsP = format = -1; + gotPixel = false; /* Read the initial defines. */ processedStaticChar = FALSE; @@ -493,8 +541,10 @@ readXpm1Header(FILE * const stream, int * const widthP, int * const heightP, *heightP = v; else if (streq(t1, "ncolors")) *ncolorsP = v; - else if (streq(t1, "pixel")) - *chars_per_pixelP = v; + else if (streq(t1, "pixel")) { + gotPixel = TRUE; + *charsPerPixelP = v; + } } else if (!strncmp(line, "static char", 11)) { if ((t1 = strrchr(line, '_')) == NULL) t1 = line; @@ -507,6 +557,8 @@ readXpm1Header(FILE * const stream, int * const widthP, int * const heightP, t1 points to position of last "_" in the line, or the beginning of the line if there is no "_" */ + if (!gotPixel) + pm_error("No 'pixel' value (characters per pixel)"); if (format == -1) pm_error("missing or invalid format"); if (format != 1) @@ -517,10 +569,9 @@ readXpm1Header(FILE * const stream, int * const widthP, int * const heightP, pm_error("missing or invalid height"); if (*ncolorsP == -1) pm_error("missing or invalid ncolors"); - if (*chars_per_pixelP == -1) - pm_error("missing or invalid *chars_per_pixelP"); - if (*chars_per_pixelP > 2) - pm_message("WARNING: *chars_per_pixelP > 2 uses a lot of memory"); + + if (*charsPerPixelP > 2) + pm_message("WARNING: > 2 characters per pixel uses a lot of memory"); /* If there's a monochrome color table, skip it. */ if (!strncmp(t1, "mono", 4)) { @@ -531,10 +582,10 @@ readXpm1Header(FILE * const stream, int * const widthP, int * const heightP, } } /* Allocate space for color table. */ - if (*chars_per_pixelP <= 2) { + if (*charsPerPixelP <= 2) { /* Up to two chars per pixel, we can use an indexed table. */ v = 1; - for (i = 0; i < *chars_per_pixelP; ++i) + for (i = 0; i < *charsPerPixelP; ++i) v *= 256; *colorsP = ppm_allocrow(v); *ptabP = NULL; @@ -554,7 +605,7 @@ readXpm1Header(FILE * const stream, int * const widthP, int * const heightP, pm_error("D error scanning color table"); if ((t2 = strchr(t1 + 1, '"')) == NULL) pm_error("E error scanning color table"); - if (t2 - t1 - 1 != *chars_per_pixelP) + if (t2 - t1 - 1 != *charsPerPixelP) pm_error("wrong number of chars per pixel in color table"); strncpy(str1, t1 + 1, t2 - t1 - 1); str1[t2 - t1 - 1] = '\0'; @@ -567,9 +618,9 @@ readXpm1Header(FILE * const stream, int * const widthP, int * const heightP, str2[t2 - t1 - 1] = '\0'; v = 0; - for (j = 0; j < *chars_per_pixelP; ++j) + for (j = 0; j < *charsPerPixelP; ++j) v = (v << 8) + str1[j]; - if (*chars_per_pixelP <= 2) + if (*charsPerPixelP <= 2) /* Index into table. */ (*colorsP)[v] = ppm_parsecolor(str2, (pixval) PPM_MAXMAXVAL); @@ -593,15 +644,15 @@ readXpm1Header(FILE * const stream, int * const widthP, int * const heightP, static void -interpretXpmLine(char const line[], - int const chars_per_pixel, - int const ncolors, - int * const ptab, - int ** const cursorP, - int * const maxCursor) { +interpretXpmLine(char const line[], + unsigned int const charsPerPixel, + int const ncolors, + unsigned int * const ptab, + int ** const cursorP, + int * const maxCursor) { /*---------------------------------------------------------------------------- Interpret one line of XPM input. The line is in 'line', and its - format is 'chars_per_pixel' characters per pixel. 'ptab' is the + format is 'charsPerPixel' characters per pixel. 'ptab' is the color table that applies to the line, which table has 'ncolors' colors. @@ -632,22 +683,24 @@ interpretXpmLine(char const line[], the pixels Caller wants. */ while (*lineCursor && *lineCursor != '"' && *cursorP <= maxCursor) { - int colorNumber; - int i; + unsigned int colorNumber; + unsigned int i; colorNumber = 0; /* initial value */ - for (i = 0; i < chars_per_pixel; ++i) - colorNumber = (colorNumber << 8) + *(lineCursor++); + for (i = 0; i < charsPerPixel; ++i) { + unsigned char const byte = (unsigned char)(*lineCursor++); + colorNumber = (colorNumber << 8) + byte; + } if (ptab == NULL) /* colormap is indexed directly by XPM color number */ *(*cursorP)++ = colorNumber; else { /* colormap shadows ptab[]. Find this color # in ptab[] */ - int i; + unsigned int i; for (i = 0; i < ncolors && ptab[i] != colorNumber; ++i); if (i < ncolors) *(*cursorP)++ = i; else - pm_error("Color number %d is in raster, but not in " + pm_error("Color number %u is in raster, but not in " "colormap. Line it's in: '%s'", colorNumber, line); } @@ -678,12 +731,12 @@ ReadXPMFile(FILE * const stream, int * const widthP, int * const heightP, -----------------------------------------------------------------------------*/ char line[MAX_LINE+1], str1[MAX_LINE+1]; int totalpixels; - int *cursor; /* cursor into *dataP */ - int *maxcursor; /* value of above cursor for last pixel in image */ - int *ptab; /* colormap - malloc'ed */ + int * cursor; /* cursor into *dataP */ + int * maxcursor; /* value of above cursor for last pixel in image */ + unsigned int * ptab; /* colormap - malloc'ed */ int rc; int ncolors; - int chars_per_pixel; + unsigned int charsPerPixel; backup = FALSE; @@ -694,11 +747,11 @@ ReadXPMFile(FILE * const stream, int * const widthP, int * const heightP, rc = sscanf(line, "/* %s */", str1); if (rc == 1 && strncmp(str1, "XPM", 3) == 0) { /* It's an XPM version 3 file */ - readXpm3Header(stream, widthP, heightP, &chars_per_pixel, + readXpm3Header(stream, widthP, heightP, &charsPerPixel, &ncolors, colorsP, &ptab, transparentP); } else { /* try as an XPM version 1 file */ /* Assume it's an XPM version 1 file */ - readXpm1Header(stream, widthP, heightP, &chars_per_pixel, + readXpm1Header(stream, widthP, heightP, &charsPerPixel, &ncolors, colorsP, &ptab); *transparentP = -1; /* No transparency in version 1 */ } @@ -714,7 +767,7 @@ ReadXPMFile(FILE * const stream, int * const widthP, int * const heightP, if (strncmp(line, "/*", 2) == 0) { /* It's a comment. Ignore it. */ } else { - interpretXpmLine(line, chars_per_pixel, + interpretXpmLine(line, charsPerPixel, ncolors, ptab, &cursor, maxcursor); } if (cursor <= maxcursor) |