diff options
| author | giraffedata <giraffedata@9d0c8265-081b-0410-96cb-a4ca84ce46f8> | 2019-12-30 05:05:58 +0000 |
|---|---|---|
| committer | giraffedata <giraffedata@9d0c8265-081b-0410-96cb-a4ca84ce46f8> | 2019-12-30 05:05:58 +0000 |
| commit | 4b896dbdd5d76d1457f67b04c0903d4210cea874 (patch) | |
| tree | 29ee6394de1647061d56bbe710d9a88478e58410 | |
| parent | ef169d7bad450fd906e843169278c693730a8b2b (diff) | |
| download | netpbm-mirror-4b896dbdd5d76d1457f67b04c0903d4210cea874.tar.gz netpbm-mirror-4b896dbdd5d76d1457f67b04c0903d4210cea874.tar.xz netpbm-mirror-4b896dbdd5d76d1457f67b04c0903d4210cea874.zip | |
Fix typos in comments and messages, whitespace
git-svn-id: http://svn.code.sf.net/p/netpbm/code/trunk@3728 9d0c8265-081b-0410-96cb-a4ca84ce46f8
46 files changed, 699 insertions, 684 deletions
diff --git a/analyzer/pamgetcolor.c b/analyzer/pamgetcolor.c index 430f3b07..d1ea3799 100644 --- a/analyzer/pamgetcolor.c +++ b/analyzer/pamgetcolor.c @@ -37,7 +37,7 @@ typedef struct { uint regN; /* number of regions */ uint maxLbLen; /* maximum label length */ RegSpec * regSpecs; - /* list of points to sample, dymamically allocated*/ + /* list of points to sample, dynamically allocated*/ const char * formatStr; /* output color format as string */ uint formatId; /* the Id of the selected color format */ uint formatArg; /* the argument to the color formatting function */ @@ -45,9 +45,9 @@ typedef struct { } CmdLineInfo; /* Generic pointer to a color-formatting function. Returns the textual - representation of the color <tuple> in terms of the image pointed-to + representation of the color <tuple> in terms of the image pointed to by <pamP>. <param> is a generic integer parameter that depends on the - specific funcion and may denote precison or maxval. + specific function and may denote precision or maxval. */ typedef const char * (*FormatColor)(struct pam * const pamP, diff --git a/buildtools/README.pkg b/buildtools/README.pkg index d642dee8..71afc000 100644 --- a/buildtools/README.pkg +++ b/buildtools/README.pkg @@ -114,7 +114,7 @@ The parts to be installed are: replacement for the classic Man program that can access both traditional man pages and worldwide web documentation in the Netpbm style with the familiar 'man jpegtopnm' kind of command. The package contains the files - necessary to use Manweb to access Netpbm documention on the web (on + necessary to use Manweb to access Netpbm documentation on the web (on netpbm.sourceforge.net). These files are the contents of the man/web directory and the file 'bin/doc.url'. You should install the 'bin/doc.url' file if you are installing the Netpbm executables in a diff --git a/buildtools/debian/mkdeb b/buildtools/debian/mkdeb index 684ca0fb..6fb8d2e7 100755 --- a/buildtools/debian/mkdeb +++ b/buildtools/debian/mkdeb @@ -3,7 +3,7 @@ # mkdeb ############################################################################### # -# This generates a Debian packge file (.deb) to install Sourceforge +# This generates a Debian package file (.deb) to install Sourceforge # Netpbm on a Debian system. # # This is especially useful because Debian does not have a good Debian diff --git a/converter/other/fiasco/codec/coder.c b/converter/other/fiasco/codec/coder.c index 1e21994d..dc774a19 100644 --- a/converter/other/fiasco/codec/coder.c +++ b/converter/other/fiasco/codec/coder.c @@ -2,7 +2,7 @@ * coder.c: WFA coder toplevel functions * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -56,7 +56,7 @@ /***************************************************************************** global variables - + *****************************************************************************/ const real_t MAXCOSTS = 1e20; @@ -64,7 +64,7 @@ const real_t MAXCOSTS = 1e20; /***************************************************************************** private code - + *****************************************************************************/ static char * @@ -109,44 +109,44 @@ get_input_image_name (char const * const *templptr, unsigned ith_image) 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 == '-') + + 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) || + + if ((increment > 0 && (unsigned) image_num > last) || (increment <= 0 && (unsigned) image_num < last)) { /* TODO: check this */ @@ -158,7 +158,7 @@ get_input_image_name (char const * const *templptr, unsigned ith_image) /* 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); @@ -167,7 +167,7 @@ get_input_image_name (char const * const *templptr, unsigned ith_image) } } return NULL; -} +} @@ -191,7 +191,7 @@ alloc_coder (char const * const * const inputname, coding_t * c; c = NULL; /* initial value */ - + /* * Check whether all specified image frames are readable and of same type */ @@ -200,7 +200,7 @@ alloc_coder (char const * const * const inputname, 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++) { xelval maxval; @@ -220,7 +220,7 @@ alloc_coder (char const * const * const inputname, pm_close(file); } color = (PNM_FORMAT_TYPE(format) == PPM_FORMAT) ? TRUE: FALSE; - + if (n > 0) { if (w != width || h != height || c != color) @@ -249,13 +249,13 @@ alloc_coder (char const * const * const inputname, */ { unsigned lx, ly; - + 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); } - + c = Calloc (1, sizeof (coding_t)); c->options = *options; @@ -278,10 +278,10 @@ alloc_coder (char const * const * const inputname, 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; - + /* * 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] ! @@ -293,7 +293,7 @@ alloc_coder (char const * const * const inputname, 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), @@ -301,7 +301,7 @@ alloc_coder (char const * const * const inputname, 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", @@ -309,7 +309,7 @@ alloc_coder (char const * const * const inputname, 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 ... */ @@ -333,7 +333,7 @@ alloc_coder (char const * const * const inputname, */ wi->title = strdup (options->title); wi->comment = strdup (options->comment); - + /* * Reduced precision format */ @@ -345,7 +345,7 @@ alloc_coder (char const * const * const inputname, = 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 ... */ @@ -361,7 +361,7 @@ alloc_coder (char const * const * const inputname, 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); return c; @@ -383,7 +383,7 @@ free_coder (coding_t *c) { free_tiling (c->tiling); free_motion (c->mt); - + Free (c->pixels); Free (c->images_of_state); Free (c->ip_images_state); @@ -424,13 +424,13 @@ 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, @@ -483,10 +483,10 @@ print_statistics (char c, real_t costs, const wfa_t *wfa, const image_t *image, -static void +static void frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) /* - * + * * WFA Coding of next frame. All important coding parameters are * stored in 'c'. The generated 'wfa' is written to stream 'output' * immediately after coding. @@ -499,11 +499,11 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) real_t costs; /* total costs (minimized quantity) */ unsigned bits; /* number of bits written on disk */ clock_t ptimer; - + prg_timer (&ptimer, START); bits = bits_processed (output); - + init_tree_model (&c->tree); init_tree_model (&c->p_tree); @@ -552,9 +552,9 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) int YCb_node = -1; int tree [3]; /* 3 root states of each color comp. */ color_e band; - + /* - * When compressing color images, the three color components (YCbCr) + * When compressing color images, the three color components (YCbCr) * are copied into a large image: * [ Y Cr ] * [ Cb 0 ] @@ -573,14 +573,14 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) 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. + * Don't use a finer partitioning 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) @@ -596,23 +596,23 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) 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]; @@ -623,13 +623,13 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) } } /* - * generate two virtual states (*) + * generate two virtual states (*) * * * * / \ * + * - * / \ / - * Y CbCr + * / \ / + * Y CbCr */ wfa->tree [wfa->states][0] = tree[Cr]; wfa->tree [wfa->states][1] = RANGE; @@ -646,7 +646,7 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) for (state = wfa->basis_states; state < MAXSTATES; state++) { unsigned level; - + if (c->images_of_state [state]) { Free (c->images_of_state [state]); @@ -665,12 +665,12 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) Free (c->ip_states_state [state][level]); c->ip_states_state [state][level] = NULL; } - + } - + locate_delta_images (wfa); write_next_wfa (wfa, c, output); - + bits = bits_processed (output) - bits; debug_message ("Total number of bits written: %d (%d bytes, %5.3f bpp)", bits, bits >> 3, @@ -712,7 +712,7 @@ video_coder(char const * const * const image_template, /* 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 */ - + debug_message ("Generating %d WFA's ...", wfa->wfainfo->frames); future_display = -1; @@ -722,7 +722,7 @@ video_coder(char const * const * const image_template, 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!) @@ -731,7 +731,7 @@ video_coder(char const * const * const image_template, 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 */ { @@ -741,12 +741,12 @@ video_coder(char const * const * const image_template, 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) + } + else if (type == B_FRAME && (int) display > future_display) { unsigned i = display; /* @@ -758,7 +758,7 @@ video_coder(char const * const * const image_template, i++; name = get_input_image_name (image_template, i); - + if (!name) /* Force last valid frame to be 'P' */ { future_display = i - 1; @@ -766,7 +766,7 @@ video_coder(char const * const * const image_template, } else { - future_display = i; + future_display = i; image_name = name; type = pattern2type (i, c->options.pattern); } @@ -781,7 +781,7 @@ video_coder(char const * const * const image_template, 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. @@ -846,10 +846,10 @@ video_coder(char const * const * const image_template, c->mt->original = read_image_stream(stdin, stdinwidth, stdinheight, stdinmaxval, stdinformat); - else + else c->mt->original = read_image_file(image_name); - if (c->tiling->exponent && type == I_FRAME) + if (c->tiling->exponent && type == I_FRAME) perform_tiling (c->mt->original, c->tiling); frame_coder (wfa, c, output); @@ -869,7 +869,7 @@ video_coder(char const * const * const image_template, if (c->mt->original) free_image (c->mt->original); c->mt->original = NULL; - + remove_states (wfa->basis_states, wfa); /* Clear WFA structure */ } @@ -927,7 +927,7 @@ read_stdin_header(const char * const * const template, /***************************************************************************** public code - + *****************************************************************************/ int @@ -957,7 +957,7 @@ fiasco_coder (char const * const *inputname, const char *outputname, unsigned int stdinheight, stdinwidth; xelval stdinmaxval; int stdinformat; - + /* * Check parameters */ @@ -965,7 +965,7 @@ fiasco_coder (char const * const *inputname, const char *outputname, template = default_input; else template = inputname; - + if (quality <= 0) { set_error (_("Compression quality has to be positive.")); @@ -1013,20 +1013,20 @@ fiasco_coder (char const * const *inputname, const char *outputname, 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); } diff --git a/converter/other/fiasco/codec/cwfa.h b/converter/other/fiasco/codec/cwfa.h index dd86fbfc..e8e2d474 100644 --- a/converter/other/fiasco/codec/cwfa.h +++ b/converter/other/fiasco/codec/cwfa.h @@ -33,7 +33,7 @@ extern const real_t MAXCOSTS; typedef struct motion { image_t *original; /* Current image */ - image_t *past; /* Preceeding image */ + image_t *past; /* Preceding image */ image_t *future; /* Succeeding image */ frame_type_e frame_type; /* frame type: B_, P_ I_FRAME */ unsigned number; /* display number of frame */ diff --git a/converter/other/fiasco/codec/dfiasco.c b/converter/other/fiasco/codec/dfiasco.c index d45c9e39..ce25654a 100644 --- a/converter/other/fiasco/codec/dfiasco.c +++ b/converter/other/fiasco/codec/dfiasco.c @@ -2,11 +2,11 @@ * dfiasco.c: Decoder public interface * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ - + /* * $Date: 2000/10/28 17:39:30 $ * $Author: hafner $ @@ -38,7 +38,7 @@ /***************************************************************************** prototypes - + *****************************************************************************/ static dfiasco_t * @@ -52,7 +52,7 @@ alloc_dfiasco (wfa_t *wfa, video_t *video, bitfile_t *input, /***************************************************************************** public code - + *****************************************************************************/ fiasco_decoder_t * @@ -79,7 +79,7 @@ fiasco_decoder_new (const char *filename, const fiasco_d_options_t *options) default_options = fiasco_d_options_new (); dop = cast_d_options (default_options); } - + wfa = alloc_wfa (NO); video = alloc_video (NO); input = open_wfa (filename, wfa->wfainfo); @@ -102,7 +102,7 @@ fiasco_decoder_new (const char *filename, const fiasco_d_options_t *options) dop->magnification, dop->smoothing, dop->image_format); - + if (default_options) fiasco_d_options_delete (default_options); if (dfiasco->enlarge_factor >= 0) @@ -115,7 +115,7 @@ fiasco_decoder_new (const char *filename, const fiasco_d_options_t *options) if (pixels << (n << 1) > 2048 * 2048) { set_error (_("Magnifaction factor `%d' is too large. " - "Maximium value is %d."), + "Maximum value is %d."), dfiasco->enlarge_factor, MAX(0, n - 1)); fiasco_decoder_delete (decoder); return NULL; @@ -152,7 +152,7 @@ fiasco_decoder_write_frame (fiasco_decoder_t *decoder, const char *filename) { dfiasco_t *dfiasco = cast_dfiasco (decoder); - + if (!dfiasco) return 0; else @@ -177,7 +177,7 @@ fiasco_image_t * fiasco_decoder_get_frame (fiasco_decoder_t *decoder) { dfiasco_t *dfiasco = cast_dfiasco (decoder); - + if (!dfiasco) return NULL; else @@ -197,7 +197,7 @@ fiasco_decoder_get_frame (fiasco_decoder_t *decoder) image->get_width = fiasco_image_get_width; image->get_height = fiasco_image_get_height; image->is_color = fiasco_image_is_color; - + return image; } catch @@ -211,7 +211,7 @@ unsigned fiasco_decoder_get_length (fiasco_decoder_t *decoder) { dfiasco_t *dfiasco = cast_dfiasco (decoder); - + if (!dfiasco) return 0; else @@ -222,7 +222,7 @@ unsigned fiasco_decoder_get_rate (fiasco_decoder_t *decoder) { dfiasco_t *dfiasco = cast_dfiasco (decoder); - + if (!dfiasco) return 0; else @@ -239,12 +239,12 @@ fiasco_decoder_get_width (fiasco_decoder_t *decoder) else { unsigned width; - + if (dfiasco->enlarge_factor >= 0) width = dfiasco->wfa->wfainfo->width << dfiasco->enlarge_factor; else width = dfiasco->wfa->wfainfo->width >> - dfiasco->enlarge_factor; - + return width & 1 ? width + 1 : width; } } @@ -259,7 +259,7 @@ fiasco_decoder_get_height (fiasco_decoder_t *decoder) else { unsigned height; - + if (dfiasco->enlarge_factor >= 0) height = dfiasco->wfa->wfainfo->height << dfiasco->enlarge_factor; else @@ -306,10 +306,10 @@ int fiasco_decoder_delete (fiasco_decoder_t *decoder) { dfiasco_t *dfiasco = cast_dfiasco (decoder); - + if (!dfiasco) return 1; - + try { free_wfa (dfiasco->wfa); @@ -330,7 +330,7 @@ fiasco_decoder_delete (fiasco_decoder_t *decoder) /***************************************************************************** private code - + *****************************************************************************/ static dfiasco_t * @@ -347,14 +347,14 @@ alloc_dfiasco (wfa_t *wfa, video_t *video, bitfile_t *input, dfiasco_t *dfiasco = Calloc (1, sizeof (dfiasco_t)); strcpy (dfiasco->id, "DFIASCO"); - + dfiasco->wfa = wfa; dfiasco->video = video; dfiasco->input = input; dfiasco->enlarge_factor = enlarge_factor; dfiasco->smoothing = smoothing; dfiasco->image_format = image_format; - + return dfiasco; } diff --git a/converter/other/fiasco/codec/ip.c b/converter/other/fiasco/codec/ip.c index 56b0ae9a..18257a06 100644 --- a/converter/other/fiasco/codec/ip.c +++ b/converter/other/fiasco/codec/ip.c @@ -2,7 +2,7 @@ * ip.c: Computation of inner products * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -27,40 +27,40 @@ /***************************************************************************** prototypes - + *****************************************************************************/ -static real_t +static real_t standard_ip_image_state (unsigned address, unsigned level, unsigned domain, const coding_t *c); -static real_t +static real_t standard_ip_state_state (unsigned domain1, unsigned domain2, unsigned level, const coding_t *c); /***************************************************************************** public code - + *****************************************************************************/ -real_t +real_t get_ip_image_state (unsigned image, unsigned address, unsigned level, unsigned domain, const coding_t *c) /* * Return value: * Inner product between 'image' ('address') and - * 'domain' at given 'level' + * 'domain' at given 'level' */ { if (level <= c->options.images_level) { /* - * Compute the inner product in the standard way by multiplying + * Compute the inner product in the standard way by multiplying * the pixel-values of the given domain and range image. - */ + */ return standard_ip_image_state (address, level, domain, c); } - else + else { /* * Use the already computed inner products stored in 'ip_images_states' @@ -69,29 +69,29 @@ get_ip_image_state (unsigned image, unsigned address, unsigned level, } } -void +void compute_ip_images_state (unsigned image, unsigned address, unsigned level, unsigned n, unsigned from, const wfa_t *wfa, coding_t *c) /* * Compute the inner products between all states * 'from', ... , 'wfa->max_states' and the range images 'image' - * (and childs) up to given level. + * (and children) up to given level. * * No return value. * * Side effects: * inner product tables 'c->ip_images_states' are updated - */ + */ { - if (level > c->options.images_level) + if (level > c->options.images_level) { unsigned state, label; if (level > c->options.images_level + 1) /* recursive computation */ compute_ip_images_state (MAXLABELS * image + 1, address * MAXLABELS, level - 1, MAXLABELS * n, from, wfa, c); - + /* * Compute inner product <f, Phi_i> */ @@ -102,7 +102,7 @@ compute_ip_images_state (unsigned image, unsigned address, unsigned level, unsigned edge, count; int domain; real_t *dst, *src; - + if (ischild (domain = wfa->tree [state][label])) { if (level > c->options.images_level + 1) @@ -116,9 +116,9 @@ compute_ip_images_state (unsigned image, unsigned address, unsigned level, else { unsigned newadr = address * MAXLABELS + label; - + dst = c->ip_images_state [state] + image; - + for (count = n; count; count--, newadr += MAXLABELS) *dst++ += standard_ip_image_state (newadr, level - 1, domain, c); @@ -128,7 +128,7 @@ compute_ip_images_state (unsigned image, unsigned address, unsigned level, edge++) { real_t weight = wfa->weight [state][label][edge]; - + if (level > c->options.images_level + 1) { dst = c->ip_images_state [state] + image; @@ -142,7 +142,7 @@ compute_ip_images_state (unsigned image, unsigned address, unsigned level, unsigned newadr = address * MAXLABELS + label; dst = c->ip_images_state [state] + image; - + for (count = n; count; count--, newadr += MAXLABELS) *dst++ += weight * standard_ip_image_state (newadr, level - 1, @@ -153,7 +153,7 @@ compute_ip_images_state (unsigned image, unsigned address, unsigned level, } } -real_t +real_t get_ip_state_state (unsigned domain1, unsigned domain2, unsigned level, const coding_t *c) /* @@ -164,12 +164,12 @@ get_ip_state_state (unsigned domain1, unsigned domain2, unsigned level, if (level <= c->options.images_level) { /* - * Compute the inner product in the standard way by multiplying + * Compute the inner product in the standard way by multiplying * the pixel-values of both state-images - */ + */ return standard_ip_state_state (domain1, domain2, level, c); } - else + else { /* * Use already computed inner products stored in 'ip_images_states' @@ -181,7 +181,7 @@ get_ip_state_state (unsigned domain1, unsigned domain2, unsigned level, } } -void +void compute_ip_states_state (unsigned from, unsigned to, const wfa_t *wfa, coding_t *c) /* @@ -192,7 +192,7 @@ compute_ip_states_state (unsigned from, unsigned to, * * Side effects: * inner product tables 'c->ip_states_state' are computed. - */ + */ { unsigned level; unsigned state1, state2; @@ -204,25 +204,25 @@ compute_ip_states_state (unsigned from, unsigned to, for (level = c->options.images_level + 1; level <= c->options.lc_max_level; level++) for (state1 = from; state1 <= to; state1++) - for (state2 = 0; state2 <= state1; state2++) + for (state2 = 0; state2 <= state1; state2++) if (need_image (state2, wfa)) { unsigned label; real_t ip = 0; - + for (label = 0; label < MAXLABELS; label++) { int domain1, domain2; unsigned edge1, edge2; real_t sum, weight2; - + if (ischild (domain1 = wfa->tree [state1][label])) { sum = 0; if (ischild (domain2 = wfa->tree [state2][label])) sum = get_ip_state_state (domain1, domain2, level - 1, c); - + for (edge2 = 0; isedge (domain2 = wfa->into [state2][label][edge2]); edge2++) @@ -238,12 +238,12 @@ compute_ip_states_state (unsigned from, unsigned to, edge1++) { real_t weight1 = wfa->weight [state1][label][edge1]; - + sum = 0; if (ischild (domain2 = wfa->tree [state2][label])) sum = get_ip_state_state (domain1, domain2, level - 1, c); - + for (edge2 = 0; isedge (domain2 = wfa->into [state2][label][edge2]); edge2++) @@ -262,10 +262,10 @@ compute_ip_states_state (unsigned from, unsigned to, /***************************************************************************** private code - + *****************************************************************************/ -static real_t +static real_t standard_ip_image_state (unsigned address, unsigned level, unsigned domain, const coding_t *c) /* @@ -283,18 +283,18 @@ standard_ip_image_state (unsigned address, unsigned level, unsigned domain, if (level > c->options.images_level) error ("We cannot interpret a Level %d image.", level); - + imageptr = &c->pixels [address * size_of_level (level)]; stateptr = c->images_of_state [domain] + address_of_level (level); - + for (i = size_of_level (level); i; i--) ip += *imageptr++ * *stateptr++; return ip; } -static real_t +static real_t standard_ip_state_state (unsigned domain1, unsigned domain2, unsigned level, const coding_t *c) /* @@ -315,7 +315,7 @@ standard_ip_state_state (unsigned domain1, unsigned domain2, unsigned level, state1ptr = c->images_of_state [domain1] + address_of_level (level); state2ptr = c->images_of_state [domain2] + address_of_level (level); - + for (i = size_of_level (level); i; i--) ip += *state1ptr++ * *state2ptr++; diff --git a/converter/other/fiasco/codec/prediction.c b/converter/other/fiasco/codec/prediction.c index e78e5acc..c592baa5 100644 --- a/converter/other/fiasco/codec/prediction.c +++ b/converter/other/fiasco/codec/prediction.c @@ -1,9 +1,9 @@ /* - * prediction.c: Range image prediction with MC or ND + * prediction.c: Range image prediction with MC or ND * * Written by: Ullrich Hafner * Michael Unger - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -41,7 +41,7 @@ /***************************************************************************** local variables - + *****************************************************************************/ typedef struct state_data @@ -71,7 +71,7 @@ typedef struct state_data /***************************************************************************** prototypes - + *****************************************************************************/ static real_t @@ -90,9 +90,9 @@ restore_state_data (unsigned from, unsigned to, unsigned max_level, /***************************************************************************** public code - + *****************************************************************************/ - + real_t predict_range (real_t max_costs, real_t price, range_t *range, wfa_t *wfa, coding_t *c, unsigned band, int y_state, unsigned states, @@ -124,11 +124,11 @@ predict_range (real_t max_costs, real_t price, range_t *range, wfa_t *wfa, rec_d_coeff_model = c->d_coeff->model; rec_tree_model = c->tree; rec_p_tree_model = c->p_tree; - rec_states = wfa->states; + rec_states = wfa->states; rec_pixels = c->pixels; rec_state_data = store_state_data (states, rec_states - 1, c->options.lc_max_level, wfa, c); - + /* * Restore probability models to the state before the recursive subdivision * has been started. @@ -141,14 +141,14 @@ predict_range (real_t max_costs, real_t price, range_t *range, wfa_t *wfa, c->coeff->model = c->coeff->model_duplicate (c->coeff, coeff_model); c->d_coeff->model = c->d_coeff->model_duplicate (c->d_coeff, d_coeff_model); - + if (c->mt->frame_type == I_FRAME) - costs = nd_prediction (max_costs, price, band, y_state, range, wfa, c); + costs = nd_prediction (max_costs, price, band, y_state, range, wfa, c); else costs = mc_prediction (max_costs, price, band, y_state, range, wfa, c); - + c->pixels = rec_pixels; - + if (costs < MAXCOSTS) { /* @@ -187,25 +187,25 @@ predict_range (real_t max_costs, real_t price, range_t *range, wfa_t *wfa, c->d_domain_pool->model_free (c->d_domain_pool->model); c->coeff->model_free (c->coeff->model); c->d_coeff->model_free (c->d_coeff->model); - + c->domain_pool->model = rec_domain_model; c->d_domain_pool->model = rec_d_domain_model; c->coeff->model = rec_coeff_model; c->d_coeff->model = rec_d_coeff_model; c->tree = rec_tree_model; c->p_tree = rec_p_tree_model; - + range->prediction = NO; - + if (wfa->states != states) remove_states (states, wfa); restore_state_data (states, rec_states - 1, c->options.lc_max_level, rec_state_data, wfa, c); costs = MAXCOSTS; } - + return costs; -} +} void clear_norms_table (unsigned level, const wfa_info_t *wi, motion_t *mt) @@ -238,11 +238,11 @@ update_norms_table (unsigned level, const wfa_info_t *wi, motion_t *mt) unsigned range_size = wi->half_pixel ? square (wi->search_range) : square (2 * wi->search_range); - + if (level > wi->p_min_level) { unsigned index; /* index of motion vector */ - + for (index = 0; index < range_size; index++) mt->mc_forward_norms [level][index] += mt->mc_forward_norms [level - 1][index]; @@ -256,7 +256,7 @@ update_norms_table (unsigned level, const wfa_info_t *wi, motion_t *mt) /***************************************************************************** private code - + *****************************************************************************/ static real_t @@ -273,7 +273,7 @@ mc_prediction (real_t max_costs, real_t price, unsigned band, int y_state, * If we are at the bottom level of the mc tree: * Fill in the norms table */ - if (prange.level == wfa->wfainfo->p_min_level) + if (prange.level == wfa->wfainfo->p_min_level) fill_norms_table (prange.x, prange.y, prange.level, wfa->wfainfo, c->mt); /* * Predict 'range' with motion compensation according to frame type. @@ -283,19 +283,19 @@ mc_prediction (real_t max_costs, real_t price, unsigned band, int y_state, find_P_frame_mc (mcpe, price, &prange, wfa->wfainfo, c->mt); else find_B_frame_mc (mcpe, price, &prange, wfa->wfainfo, c->mt); - + costs = (prange.mv_tree_bits + prange.mv_coord_bits) * price; - + if (costs < max_costs) /* motion vector not too expensive */ { unsigned last_state; /* last WFA state before recursion */ real_t *ipi [MAXSTATES]; /* inner products pointers */ unsigned state; real_t mvt, mvc; - + c->pixels = Calloc (width * height, sizeof (real_t)); cut_to_bintree (c->pixels, mcpe, width, height, 0, 0, width, height); - + /* * Approximate MCPE recursively. */ @@ -310,7 +310,7 @@ mc_prediction (real_t max_costs, real_t price, unsigned band, int y_state, mvc = prange.mv_coord_bits; mvt = prange.mv_tree_bits; - + prange.image = 0; prange.address = 0; prange.tree_bits = 0; @@ -329,7 +329,7 @@ mc_prediction (real_t max_costs, real_t price, unsigned band, int y_state, if (costs < max_costs) /* use motion compensation */ { unsigned img, adr; /* temp. values */ - + img = range->image; adr = range->address; *range = prange; @@ -362,7 +362,7 @@ mc_prediction (real_t max_costs, real_t price, unsigned band, int y_state, } else costs = MAXCOSTS; - + Free (mcpe); return costs; @@ -374,7 +374,7 @@ nd_prediction (real_t max_costs, real_t price, unsigned band, int y_state, { real_t costs; /* current approximation costs */ range_t lrange = *range; - + /* * Predict 'range' with DC component approximation */ @@ -397,11 +397,11 @@ nd_prediction (real_t max_costs, real_t price, unsigned band, int y_state, lrange.weights_bits = c->coeff->bits (&w, s, range->level, c->coeff); } costs = price * (lrange.weights_bits + lrange.nd_tree_bits); - + /* - * Recursive aproximation of difference image + * Recursive approximation of difference image */ - if (costs < max_costs) + if (costs < max_costs) { unsigned state; range_t rrange; /* range: recursive subdivision */ @@ -418,14 +418,14 @@ nd_prediction (real_t max_costs, real_t price, unsigned band, int y_state, unsigned n; real_t *src, *dst; /* pointers to image data */ real_t w = - lrange.weight [0] * c->images_of_state [0][0]; - - src = c->pixels + range->address * size_of_level (range->level); + + src = c->pixels + range->address * size_of_level (range->level); dst = c->pixels = pixels = Calloc (width * height, sizeof (real_t)); for (n = width * height; n; n--) *dst++ = *src++ + w; } - + /* * Approximate difference recursively. */ @@ -448,13 +448,13 @@ nd_prediction (real_t max_costs, real_t price, unsigned band, int y_state, c->ip_images_state[state] = Calloc (size_of_tree (c->products_level), sizeof (real_t)); } - + compute_ip_images_state (rrange.image, rrange.address, rrange.level, 1, 0, wfa, c); - + costs += subdivide (max_costs - costs, band, y_state, &rrange, wfa, c, NO, YES); - + Free (pixels); if (costs < max_costs && ischild (rrange.tree)) /* use prediction */ @@ -469,7 +469,7 @@ nd_prediction (real_t max_costs, real_t price, unsigned band, int y_state, range->address = adr; range->nd_tree_bits += lrange.nd_tree_bits; range->nd_weights_bits += lrange.weights_bits; - + for (edge = 0; isedge (lrange.into [edge]); edge++) { range->into [edge] = lrange.into [edge]; @@ -485,7 +485,7 @@ nd_prediction (real_t max_costs, real_t price, unsigned band, int y_state, } else costs = MAXCOSTS; - + for (state = 0; state <= last_state; state++) if (need_image (state, wfa)) { @@ -515,9 +515,9 @@ store_state_data (unsigned from, unsigned to, unsigned max_level, if (to < from) return NULL; /* nothing to do */ - + data = Calloc (to - from + 1, sizeof (state_data_t)); - + for (state = from; state <= to; state++) { sd = &data [state - from]; @@ -527,12 +527,12 @@ store_state_data (unsigned from, unsigned to, unsigned max_level, sd->domain_type = wfa->domain_type [state]; sd->images_of_state = c->images_of_state [state]; sd->inner_products = c->ip_images_state [state]; - + wfa->domain_type [state] = 0; c->images_of_state [state] = NULL; c->ip_images_state [state] = NULL; - - for (label = 0; label < MAXLABELS; label++) + + for (label = 0; label < MAXLABELS; label++) { sd->tree [label] = wfa->tree [state][label]; sd->y_state [label] = wfa->y_state [state][label]; @@ -542,11 +542,11 @@ store_state_data (unsigned from, unsigned to, unsigned max_level, sd->y [label] = wfa->y [state][label]; sd->prediction [label] = wfa->prediction [state][label]; - memcpy (sd->weight [label], wfa->weight [state][label], + memcpy (sd->weight [label], wfa->weight [state][label], sizeof (real_t) * (MAXEDGES + 1)); - memcpy (sd->int_weight [label], wfa->int_weight [state][label], + memcpy (sd->int_weight [label], wfa->int_weight [state][label], sizeof (word_t) * (MAXEDGES + 1)); - memcpy (sd->into [label], wfa->into [state][label], + memcpy (sd->into [label], wfa->into [state][label], sizeof (word_t) * (MAXEDGES + 1)); wfa->into [state][label][0] = NO_EDGE; @@ -569,7 +569,7 @@ restore_state_data (unsigned from, unsigned to, unsigned max_level, state_data_t *data, wfa_t *wfa, coding_t *c) /* * Restore all state data starting from state 'from'. - * + * * No return value. */ { @@ -578,15 +578,15 @@ restore_state_data (unsigned from, unsigned to, unsigned max_level, if (to < from) return; /* nothing to do */ - + for (state = from; state <= to; state++) { sd = &data [state - from]; - + wfa->final_distribution [state] = sd->final_distribution; wfa->level_of_state [state] = sd->level_of_state; wfa->domain_type [state] = sd->domain_type; - + if (c->images_of_state [state] != NULL) Free (c->images_of_state [state]); c->images_of_state [state] = sd->images_of_state; @@ -603,14 +603,14 @@ restore_state_data (unsigned from, unsigned to, unsigned max_level, wfa->x [state][label] = sd->x [label]; wfa->y [state][label] = sd->y [label]; wfa->prediction [state][label] = sd->prediction [label]; - - memcpy (wfa->weight [state][label], sd->weight [label], + + memcpy (wfa->weight [state][label], sd->weight [label], sizeof(real_t) * (MAXEDGES + 1)); - memcpy (wfa->int_weight [state][label], sd->int_weight [label], + memcpy (wfa->int_weight [state][label], sd->int_weight [label], sizeof(word_t) * (MAXEDGES + 1)); - memcpy (wfa->into [state][label], sd->into [label], + memcpy (wfa->into [state][label], sd->into [label], sizeof(word_t) * (MAXEDGES + 1)); - } + } for (level = c->options.images_level + 1; level <= max_level; level++) { diff --git a/converter/other/fiasco/codec/subdivide.c b/converter/other/fiasco/codec/subdivide.c index 348f838a..3ddf1ffc 100644 --- a/converter/other/fiasco/codec/subdivide.c +++ b/converter/other/fiasco/codec/subdivide.c @@ -2,7 +2,7 @@ * subdivide.c: Recursive subdivision of range images * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -56,10 +56,10 @@ init_range (range_t *range, const image_t *image, unsigned band, /***************************************************************************** public code - + *****************************************************************************/ -real_t +real_t subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, wfa_t *wfa, coding_t *c, bool_t prediction, bool_t delta) /* @@ -71,7 +71,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, * If 'prediction' is TRUE then also test motion compensation or * nondeterministic approximation. * If 'delta' is TRUE then current range is already predicted. - * + * * Return value: * costs of the best approximation or MAXCOSTS if costs exceed 'max_costs' * @@ -82,7 +82,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, */ { real_t subdivide_costs; /* Costs arising from approx. the current - range with two childs */ + range with two children */ real_t lincomb_costs; /* Costs arising from approx. the current range with a linear combination */ int new_y_state [MAXLABELS]; /* Corresponding state of Y */ @@ -91,7 +91,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, bool_t try_nd; /* YES: try ND prediction */ unsigned states; /* Number of states before the recursive subdivision starts */ - void *domain_model; /* copy of domain pool model */ + void *domain_model; /* copy of domain pool model */ void *d_domain_model; /* copy of delta domain pool model */ void *lc_domain_model; /* copy of domain pool model */ void *lc_d_domain_model; /* copy of delta domain pool model */ @@ -103,17 +103,17 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, tree_t p_tree_model; /* copy of pred. tree model */ range_t lrange; /* range of lin. comb. approx. */ range_t rrange; /* range of recursive approx. */ - range_t child [MAXLABELS]; /* new childs of the current range */ + range_t child [MAXLABELS]; /* new children of the current range */ static unsigned percent = 0; /* status of progress meter */ if (wfa->wfainfo->level == range->level) percent = 0; - + range->into [0] = NO_EDGE; /* default approximation: empty */ range->tree = RANGE; if (range->level < 3) /* Don't process small ranges */ - return MAXCOSTS; + return MAXCOSTS; /* * If image permutation (tiling) is performed and the tiling level @@ -123,7 +123,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, && range->level == wfa->wfainfo->level - c->tiling->exponent) { unsigned width, height; /* size of range (dummies)*/ - + if (c->tiling->vorder [range->global_address] < 0) return 0; /* nothing to do */ else @@ -140,7 +140,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, * Check whether prediction is allowed or not * mc == motion compensation, nd == nondeterminism */ - try_mc = (prediction && c->mt->frame_type != I_FRAME + try_mc = (prediction && c->mt->frame_type != I_FRAME && range->level >= wfa->wfainfo->p_min_level && range->level <= wfa->wfainfo->p_max_level && (range->x + width_of_level (range->level) @@ -155,21 +155,21 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, if (try_mc) clear_norms_table (range->level, wfa->wfainfo, c->mt); - + /* * Check if current range must be initialized. I.e. range pixels must * be copied from entire image to bintree pixel buffer. Moreover, * all inner products tables must be initialized. */ - if (range->level == c->options.lc_max_level) + if (range->level == c->options.lc_max_level) init_range (range, c->mt->original, band, wfa, c); - + price = c->price; - if (band != Y) + if (band != Y) price *= c->options.chroma_decrease; /* less quality for chroma bands */ /* - * Compute childs of corresponding state in Y band + * Compute children of corresponding state in Y band */ if (band != Y) /* Cb and Cr bands only */ { @@ -183,7 +183,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, } else new_y_state [0] = new_y_state [1] = RANGE; - + /* * Store contents of all models that may get modified during recursion */ @@ -193,8 +193,8 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, d_coeff_model = c->d_coeff->model_duplicate (c->d_coeff, c->d_coeff->model); tree_model = c->tree; p_tree_model = c->p_tree; - states = wfa->states; - + states = wfa->states; + /* * First alternative of range approximation: * Compute costs of linear combination. @@ -208,10 +208,10 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, lrange.weights_bits = 0; lrange.mv_tree_bits = try_mc ? 1 : 0; /* mc allowed but not used */ lrange.mv_coord_bits = 0; - lrange.nd_tree_bits = 0; - lrange.nd_weights_bits = 0; + lrange.nd_tree_bits = 0; + lrange.nd_weights_bits = 0; lrange.prediction = NO; - + lincomb_costs = approximate_range (max_costs, price, c->options.max_elements, y_state, &lrange, @@ -219,7 +219,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, (delta ? c->d_coeff : c->coeff), wfa, c); } else - lincomb_costs = MAXCOSTS; + lincomb_costs = MAXCOSTS; /* * Store contents of models that have been modified @@ -237,7 +237,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, c->coeff->model = c->coeff->model_duplicate (c->coeff, coeff_model); c->d_coeff->model = c->d_coeff->model_duplicate (c->d_coeff, d_coeff_model); - + /* * Second alternative of range approximation: * Compute costs of recursive subdivision. @@ -245,8 +245,8 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, if (range->level > c->options.lc_min_level) /* range is large enough */ { unsigned label; - - memset (&child [0], 0, 2 * sizeof (range_t)); /* initialize childs */ + + memset (&child [0], 0, 2 * sizeof (range_t)); /* initialize children */ /* * Initialize a new range for recursive approximation @@ -260,7 +260,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, rrange.mv_coord_bits = 0; rrange.nd_tree_bits = try_nd ? tree_bits (CHILD, lrange.level, &c->p_tree): 0; - rrange.nd_weights_bits = 0; + rrange.nd_weights_bits = 0; rrange.prediction = NO; /* @@ -271,11 +271,11 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, + rrange.matrix_bits + rrange.mv_tree_bits + rrange.mv_coord_bits + rrange.nd_tree_bits + rrange.nd_weights_bits) * price; - - for (label = 0; label < MAXLABELS; label++) + + for (label = 0; label < MAXLABELS; label++) { real_t remaining_costs; /* upper limit for next recursion */ - + child[label].image = rrange.image * MAXLABELS + label + 1; child[label].address = rrange.address * MAXLABELS + label; child[label].global_address = rrange.global_address * MAXLABELS @@ -289,8 +289,8 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, ? (rrange.y + label * height_of_level (rrange.level - 1)) : rrange.y; - - /* + + /* * If necessary compute the inner products of the new states * (generated during the recursive approximation of child [0]) */ @@ -298,7 +298,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, compute_ip_images_state (child[label].image, child[label].address, child[label].level, 1, states, wfa, c); /* - * Call subdivide() for both childs. + * Call subdivide() for both children. * Abort the recursion if 'subdivide_costs' exceed 'lincomb_costs' * or 'max_costs'. */ @@ -315,10 +315,10 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, fill_norms_table (child[label].x, child[label].y, child[label].level, wfa->wfainfo, c->mt); } - + if (try_mc) update_norms_table (rrange.level, wfa->wfainfo, c->mt); - + /* * Update of progress meter */ @@ -327,7 +327,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, if (c->options.progress_meter == FIASCO_PROGRESS_PERCENT) { unsigned new_percent; /* new status of progress meter */ - + new_percent = (child[label].global_address + 1) * 100.0 / (1 << (wfa->wfainfo->level - child[label].level)); if (new_percent > percent) @@ -339,7 +339,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, else if (c->options.progress_meter == FIASCO_PROGRESS_BAR) { unsigned new_percent; /* new status of progress meter */ - + new_percent = (child[label].global_address + 1) * 50.0 / (1 << (wfa->wfainfo->level - child[label].level)); @@ -349,15 +349,15 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, } } } - + /* - * If costs of subdivision exceed costs of linear combination + * If costs of subdivision exceed costs of linear combination * then abort recursion. */ - if (subdivide_costs >= MIN(lincomb_costs, max_costs)) + if (subdivide_costs >= MIN(lincomb_costs, max_costs)) { subdivide_costs = MAXCOSTS; - break; + break; } rrange.err += child [label].err; rrange.tree_bits += child [label].tree_bits; @@ -379,8 +379,8 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, /* * Third alternative of range approximation: - * Predict range via motion compensation or nondeterminism and - * approximate delta image. + * Predict range via motion compensation or nondeterminism and + * approximate delta image. */ if (try_mc || try_nd) /* try prediction */ { @@ -403,7 +403,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, c->d_coeff->model_free (d_coeff_model); c->coeff->model_free (lc_coeff_model); c->d_coeff->model_free (lc_d_coeff_model); - + return prediction_costs; } } @@ -423,25 +423,25 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, c->d_coeff->model_free (c->d_coeff->model); c->coeff->model_free (lc_coeff_model); c->d_coeff->model_free (lc_d_coeff_model); - + c->domain_pool->model = domain_model; c->d_domain_pool->model = d_domain_model; c->coeff->model = coeff_model; c->d_coeff->model = d_coeff_model; c->tree = tree_model; c->p_tree = p_tree_model; - + if (wfa->states != states) remove_states (states, wfa); return MAXCOSTS; } - else if (lincomb_costs < subdivide_costs) + else if (lincomb_costs < subdivide_costs) { /* * Use the linear combination: The factors of the linear combination * are stored already in 'range', so revert the probability models - * only. + * only. */ c->domain_pool->model_free (c->domain_pool->model); c->d_domain_pool->model_free (c->d_domain_pool->model); @@ -452,7 +452,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, c->d_coeff->model_free (c->d_coeff->model); c->coeff->model_free (coeff_model); c->d_coeff->model_free (d_coeff_model); - + c->domain_pool->model = lc_domain_model; c->d_domain_pool->model = lc_d_domain_model; c->coeff->model = lc_coeff_model; @@ -461,7 +461,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, c->p_tree = p_tree_model; *range = lrange; - + if (wfa->states != states) remove_states (states, wfa); @@ -474,8 +474,8 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, * given in child[]. * Don't use state in linear combinations in any of the following cases: * - if color component is Cb or Cr - * - if level of state > tiling level - * - if state is (partially) outside image geometry + * - if level of state > tiling level + * - if state is (partially) outside image geometry */ if (band > Y || (c->tiling->exponent @@ -545,7 +545,7 @@ cut_to_bintree (real_t *dst, const word_t *src, /***************************************************************************** private code - + *****************************************************************************/ static void @@ -558,7 +558,7 @@ init_new_state (bool_t auxiliary_state, bool_t delta, range_t *range, * If flag 'delta' is set then state represents a delta image (prediction via * nondeterminism or motion compensation). * 'range' the current range image, - * 'child []' the left and right childs of 'range'. + * 'child []' the left and right children of 'range'. * * No return value. * @@ -583,11 +583,11 @@ init_new_state (bool_t auxiliary_state, bool_t delta, range_t *range, } else state_is_domain = NO; - + range->into [0] = NO_EDGE; range->tree = wfa->states; - - for (label = 0; label < MAXLABELS; label++) + + for (label = 0; label < MAXLABELS; label++) { wfa->tree [wfa->states][label] = child [label].tree; wfa->y_state [wfa->states][label] = y_state [label]; @@ -605,7 +605,7 @@ init_new_state (bool_t auxiliary_state, bool_t delta, range_t *range, warning ("Negative image norm: %f, %f", child [0].err, child [1].err); /* state_is_domain = YES; */ - + append_state (!state_is_domain, compute_final_distribution (wfa->states, wfa), range->level, wfa, c); @@ -621,13 +621,13 @@ init_range (range_t *range, const image_t *image, unsigned band, * No return value. * * Side effects: - * 'c->pixels' are filled with pixel values of image block - * 'c->ip_images_state' are computed with respect to new image block + * 'c->pixels' are filled with pixel values of image block + * 'c->ip_images_state' are computed with respect to new image block * 'range->address' and 'range->image' are initialized with zero */ { unsigned state; - + /* * Clear already computed products */ @@ -640,7 +640,7 @@ init_range (range_t *range, const image_t *image, unsigned band, image->width, image->height, range->x, range->y, width_of_level (range->level), height_of_level (range->level)); - + range->address = range->image = 0; compute_ip_images_state (0, 0, range->level, 1, 0, wfa, c); } diff --git a/converter/other/fiasco/codec/wfa.h b/converter/other/fiasco/codec/wfa.h index 59020fc1..4e66ccbd 100644 --- a/converter/other/fiasco/codec/wfa.h +++ b/converter/other/fiasco/codec/wfa.h @@ -2,7 +2,7 @@ * wfa.h * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -20,7 +20,7 @@ #define MAXEDGES 5 #define MAXSTATES 6000 #define MAXLABELS 2 /* only bintree possible anymore */ -#define MAXLEVEL 22 +#define MAXLEVEL 22 #define FIASCO_BINFILE_RELEASE 2 #define FIASCO_MAGIC "FIASCO" /* FIASCO magic number */ @@ -85,7 +85,7 @@ typedef struct wfa_info char *basis_name; /* filename of the initial basis */ char *title; /* title of FIASCO stream */ char *comment; /* comment for FIASCO stream */ - + unsigned max_states; /* max. cardinality of domain pool */ unsigned chroma_max_states; /* max. cardinality of domain pool for chroma band coding */ @@ -111,7 +111,7 @@ typedef struct wfa_info typedef struct wfa /* - * Used to store all informations and data structures of a WFA + * Used to store all information and data structures of a WFA */ { wfa_info_t *wfainfo; /* misc. information about the WFA */ diff --git a/converter/other/fiasco/doc/fiasco_c_options_new.3 b/converter/other/fiasco/doc/fiasco_c_options_new.3 index c4a030fe..a7a96409 100644 --- a/converter/other/fiasco/doc/fiasco_c_options_new.3 +++ b/converter/other/fiasco/doc/fiasco_c_options_new.3 @@ -410,8 +410,7 @@ The function \fBfiasco_c_options_new()\fP returns a pointer to the newly allocated coder option object. If an error has been caught, a NULL pointer is returned. -All set functions return 1 on success and 0 if an error has been -catched. +All set functions return 1 on success and 0 if an error has been caught. In case of an error, use the function fiasco_get_error_message(3) to get a string with the last error message of FIASCO. diff --git a/converter/other/fiasco/input/basis.c b/converter/other/fiasco/input/basis.c index aa371ea1..e5ced0d0 100644 --- a/converter/other/fiasco/input/basis.c +++ b/converter/other/fiasco/input/basis.c @@ -1,8 +1,8 @@ /* - * basis.c: WFA initial basis files + * basis.c: WFA initial basis files * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -44,29 +44,29 @@ typedef struct /***************************************************************************** prototypes - + *****************************************************************************/ static void small_init (basis_values_t *bv); -static basis_file_t const basis_files[] = { +static basis_file_t const basis_files[] = { {"small.fco", small_init}, {"small.wfa", small_init}, - {NULL, NULL} + {NULL, NULL} }; /***************************************************************************** public code - + *****************************************************************************/ bool_t get_linked_basis (const char *basis_name, wfa_t *wfa) /* - * Check wether given WFA initial basis 'basis_name' is already linked - * with the excecutable. If the basis is available then fill the 'wfa' struct + * Check whether given WFA initial basis 'basis_name' is already linked + * with the executable. If the basis is available then fill the 'wfa' struct * according to the stored data, otherwise print a warning message. * * Return value: @@ -79,18 +79,18 @@ get_linked_basis (const char *basis_name, wfa_t *wfa) bool_t success = NO; /* indicates if basis is found */ unsigned n; /* counter */ basis_values_t bv; /* basis values */ - + for (n = 0; basis_files [n].filename != NULL; n++) if (streq (basis_files [n].filename, basis_name)) /* basis is stored */ { - unsigned state, edge; - + unsigned state, edge; + (*basis_files [n].function) (&bv); /* initialize local variables */ /* * Generate WFA */ wfa->basis_states = wfa->states = bv.states + 1; - wfa->domain_type[0] = USE_DOMAIN_MASK; + wfa->domain_type[0] = USE_DOMAIN_MASK; wfa->final_distribution[0] = 128; append_edge (0, 0, 1.0, 0, wfa); append_edge (0, 0, 1.0, 1, wfa); @@ -105,13 +105,13 @@ get_linked_basis (const char *basis_name, wfa_t *wfa) append_edge (bv.transitions [edge][0], bv.transitions [edge][1], bv.transitions [edge][2], bv.transitions [edge][3], wfa); - + success = YES; break; } if (!success) - warning ("WFA initial basis '%s' isn't linked with the excecutable yet." + warning ("WFA initial basis '%s' isn't linked with the executable yet." "\nLoading basis from disk instead.", basis_name); return success; @@ -120,7 +120,7 @@ get_linked_basis (const char *basis_name, wfa_t *wfa) /***************************************************************************** private code - + *****************************************************************************/ /***************************************************************************** @@ -141,3 +141,6 @@ small_init (basis_values_t *bv) bv->use_domain = use_domain_small; bv->transitions = transitions_small; } + + + diff --git a/converter/other/fiasco/input/matrices.c b/converter/other/fiasco/input/matrices.c index 388855ea..d20a27eb 100644 --- a/converter/other/fiasco/input/matrices.c +++ b/converter/other/fiasco/input/matrices.c @@ -2,7 +2,7 @@ * matrices.c: Input of transition matrices * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -34,7 +34,7 @@ /***************************************************************************** prototypes - + *****************************************************************************/ static unsigned @@ -49,19 +49,19 @@ compute_y_state (int state, int y_state, wfa_t *wfa); /***************************************************************************** public code - + *****************************************************************************/ unsigned read_matrices (wfa_t *wfa, bitfile_t *input) -/* +/* * Read transitions of WFA given from the stream 'input'. * * Return value: * number of edges * * Side effects: - * 'wfa->into' is filled with decoded values + * 'wfa->into' is filled with decoded values */ { unsigned total; /* total number of edges in the WFA */ @@ -73,14 +73,14 @@ read_matrices (wfa_t *wfa, bitfile_t *input) total += delta_decoding (wfa, root_state, input); if (wfa->wfainfo->color) total += chroma_decoding (wfa, input); - + return total; } /***************************************************************************** private code - + *****************************************************************************/ static unsigned @@ -94,7 +94,7 @@ delta_decoding (wfa_t *wfa, unsigned last_domain, bitfile_t *input) * number of non-zero matrix elements (WFA edges) * * Side effects: - * 'wfa->into' is filled with decoded values + * 'wfa->into' is filled with decoded values */ { range_sort_t rs; /* ranges are sorted as in the coder */ @@ -128,26 +128,26 @@ delta_decoding (wfa_t *wfa, unsigned last_domain, bitfile_t *input) arith_t *decoder; model_t *elements; unsigned max_edges = read_rice_code (3, input); - + /* * Get the probability array of the number of edges distribution * and allocate the corresponding model. */ { unsigned edge; - + for (edge = 0; edge <= max_edges; edge++) count [edge] = read_rice_code ((int) log2 (last_domain) - 2, input); elements = alloc_model (max_edges + 1, 0, 0, count); } - + /* * Get number of elements per matrix row */ { unsigned row; - + n_edges = Calloc (wfa->states, sizeof (unsigned)); decoder = alloc_decoder (input); for (row = range = 0; range < rs.range_no; range++) @@ -155,17 +155,17 @@ delta_decoding (wfa_t *wfa, unsigned last_domain, bitfile_t *input) { state = rs.range_state [range]; label = rs.range_label [range]; - + n_edges [row++] = decode_symbol (decoder, elements) - (isedge (wfa->into [state][label][0]) ? 1 : 0); } - + free_decoder (decoder); free_model (elements); } } - + /* * Get matrix elements */ @@ -177,18 +177,18 @@ delta_decoding (wfa_t *wfa, unsigned last_domain, bitfile_t *input) u_word_t *mapping_coder2 = Calloc (wfa->states, sizeof (word_t)); bool_t use_normal_domains = get_bit (input); bool_t use_delta_domains = get_bit (input); - + /* * Generate array of states which are admitted domains. * When coding intra frames 'mapping1' == 'mapping2' otherwise - * 'mapping1' is a list of 'normal' domains which are admitted for + * 'mapping1' is a list of 'normal' domains which are admitted for * coding intra blocks * 'mapping2' is a list of 'delta' domains which are admitted for - * coding the motion compensated prediction error + * coding the motion compensated prediction error */ { unsigned n1, n2, state; - + for (n1 = n2 = state = 0; state < wfa->states; state++) { mapping1 [n1] = state; @@ -197,7 +197,7 @@ delta_decoding (wfa_t *wfa, unsigned last_domain, bitfile_t *input) && (state < wfa->basis_states || use_delta_domains || !wfa->delta_state [state])) n1++; - + mapping2 [n2] = state; mapping_coder2 [state] = n2; if (usedomain (state, wfa) @@ -206,7 +206,7 @@ delta_decoding (wfa_t *wfa, unsigned last_domain, bitfile_t *input) n2++; } } - + for (row = 0, range = 0; range < rs.range_no; range++) if (!rs.range_subdivided [range]) { @@ -249,7 +249,7 @@ delta_decoding (wfa_t *wfa, unsigned last_domain, bitfile_t *input) Free (mapping2); Free (mapping_coder2); } - + Free (n_edges); Free (rs.range_state); Free (rs.range_label); @@ -265,12 +265,12 @@ column_0_decoding (wfa_t *wfa, unsigned last_row, bitfile_t *input) * Read column 0 of the transition matrices of the 'wfa' which are coded * with quasi arithmetic coding from stream 'input'. * All rows from 'wfa->basis_states' up to 'last_row' are decoded. - * + * * Return value: * number of non-zero matrix elements (WFA edges) * * Side effects: - * 'wfa->into' is filled with decoded values + * 'wfa->into' is filled with decoded values */ { unsigned row; /* current matrix row */ @@ -294,9 +294,9 @@ column_0_decoding (wfa_t *wfa, unsigned last_row, bitfile_t *input) unsigned n; unsigned index; /* probability index */ unsigned exp; /* current exponent */ - + prob = Calloc (1 << (MAX_PROB + 1), sizeof (unsigned)); - + for (index = 0, n = MIN_PROB; n <= MAX_PROB; n++) for (exp = 0; exp < 1U << n; exp++, index++) prob [index] = n; @@ -304,12 +304,12 @@ column_0_decoding (wfa_t *wfa, unsigned last_row, bitfile_t *input) first = prob_ptr = new_prob_ptr = prob; last = first + 1020; - + is_leaf = wfa->tree [wfa->basis_states]; /* use pointer arithmetics ... */ high = HIGH; /* 1.0 */ low = LOW; /* 0.0 */ - code = get_bits (input, 16); + code = get_bits (input, 16); /* * Decode column 0 with a quasi arithmetic coder (QAC). @@ -325,7 +325,7 @@ column_0_decoding (wfa_t *wfa, unsigned last_row, bitfile_t *input) for (row = wfa->basis_states; row <= last_row; row++) { unsigned count; /* value in the current interval */ - + /* * Read label 0 element */ @@ -397,7 +397,7 @@ column_0_decoding (wfa_t *wfa, unsigned last_row, bitfile_t *input) INPUT_BYTE_ALIGN (input); Free (prob); - + return total; } @@ -411,7 +411,7 @@ chroma_decoding (wfa_t *wfa, bitfile_t *input) * number of non-zero matrix elements (WFA edges) * * Side effects: - * 'wfa->into' is filled with decoded values + * 'wfa->into' is filled with decoded values */ { unsigned domain; /* current domain, counter */ @@ -425,7 +425,7 @@ chroma_decoding (wfa_t *wfa, bitfile_t *input) u_word_t low; /* End of the current code range */ u_word_t code; /* The present input code value */ word_t *y_domains; /* domain images corresponding to Y */ - int save_index; /* YES: store current probabilty */ + int save_index; /* YES: store current probability */ /* * Compute the asymmetric probability array @@ -436,9 +436,9 @@ chroma_decoding (wfa_t *wfa, bitfile_t *input) unsigned n; unsigned index; /* probability index */ unsigned exp; /* current exponent */ - + prob = Calloc (1 << (MAX_PROB + 1), sizeof (unsigned)); - + for (index = 0, n = MIN_PROB; n <= MAX_PROB; n++) for (exp = 0; exp < 1U << n; exp++, index++) prob [index] = n; @@ -454,7 +454,7 @@ chroma_decoding (wfa_t *wfa, bitfile_t *input) y_domains = compute_hits (wfa->basis_states, wfa->tree [wfa->tree [wfa->root_state][0]][0], wfa->wfainfo->chroma_max_states, wfa); - + first = prob_ptr = new_prob_ptr = prob; last = first + 1020; @@ -554,7 +554,7 @@ chroma_decoding (wfa_t *wfa, bitfile_t *input) wfa->tree [wfa->tree [wfa->root_state][0]][0], wfa); compute_y_state (wfa->tree [wfa->tree [wfa->root_state][1]][0], wfa->tree [wfa->tree [wfa->root_state][0]][0], wfa); - + first = prob_ptr = new_prob_ptr = prob; /* @@ -566,7 +566,7 @@ chroma_decoding (wfa_t *wfa, bitfile_t *input) */ { unsigned row; - + for (row = wfa->tree [wfa->tree [wfa->root_state][0]][0] + 1; row < wfa->states; row++) { @@ -629,7 +629,7 @@ compute_y_state (int state, int y_state, wfa_t *wfa) */ { unsigned label; - + for (label = 0; label < MAXLABELS; label++) if (isrange (y_state)) wfa->y_state [state][label] = RANGE; @@ -640,5 +640,7 @@ compute_y_state (int state, int y_state, wfa_t *wfa) compute_y_state (wfa->tree [state][label], wfa->y_state [state][label], wfa); } - + } + + diff --git a/converter/other/fiasco/input/mc.c b/converter/other/fiasco/input/mc.c index 2d4a073d..afc0c1c3 100644 --- a/converter/other/fiasco/input/mc.c +++ b/converter/other/fiasco/input/mc.c @@ -1,9 +1,9 @@ /* - * mc.c: Input of motion compensation + * mc.c: Input of motion compensation * * written by: Michael Unger * Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -32,10 +32,10 @@ /***************************************************************************** local variables - + *****************************************************************************/ -typedef struct huff_node +typedef struct huff_node { int code_index; /* leaf if index >= 0 */ struct huff_node *left; /* follow if '0' bit read */ @@ -46,7 +46,7 @@ typedef struct huff_node /***************************************************************************** prototypes - + *****************************************************************************/ static void @@ -64,7 +64,7 @@ create_huff_node (huff_node_t *hn, int bits_processed); /***************************************************************************** public code - + *****************************************************************************/ void @@ -90,7 +90,7 @@ read_mc (frame_type_e frame_type, wfa_t *wfa, bitfile_t *input) /***************************************************************************** private code - + *****************************************************************************/ static void @@ -114,8 +114,8 @@ decode_mc_tree (frame_type_e frame_type, unsigned max_state, /* * Traverse tree in breadth first order (starting at level - * 'wfa->wfainfo->p_max_level'). Use a queue to store the childs - * of each node ('last' is the next free queue element). + * 'wfa->wfainfo->p_max_level'). Use a queue to store the children + * of each node ('last' is the next free queue element). */ queue = Calloc (MAXSTATES, sizeof (unsigned)); for (last = 0, state = wfa->basis_states; state < max_state; state++) @@ -126,7 +126,7 @@ decode_mc_tree (frame_type_e frame_type, unsigned max_state, { unsigned label; /* current label */ unsigned current; /* current node to process */ - + for (current = 0; current < last; current++) for (label = 0; label < MAXLABELS; label++) { @@ -147,7 +147,7 @@ decode_mc_tree (frame_type_e frame_type, unsigned max_state, if (wfa->mv_tree [state][label].type == NONE && !isrange (wfa->tree [state][label]) && wfa->level_of_state [state] - 1 >= - (int) wfa->wfainfo->p_min_level) + (int) wfa->wfainfo->p_min_level) queue [last++] = wfa->tree [state][label]; /* append child */ } } @@ -155,7 +155,7 @@ decode_mc_tree (frame_type_e frame_type, unsigned max_state, { unsigned label; /* current label */ unsigned current; /* current node to process */ - + for (current = 0; current < last; current++) for (label = 0; label < MAXLABELS; label++) { @@ -172,18 +172,18 @@ decode_mc_tree (frame_type_e frame_type, unsigned max_state, wfa->mv_tree[state][label].type = NONE; else if (get_bit (input)) /* 01 */ wfa->mv_tree[state][label].type = INTERPOLATED; - else if (get_bit (input)) /* 001 */ + else if (get_bit (input)) /* 001 */ wfa->mv_tree[state][label].type = BACKWARD; - else /* 000 */ + else /* 000 */ wfa->mv_tree[state][label].type = FORWARD; if (wfa->mv_tree[state][label].type == NONE && !isrange (wfa->tree[state][label]) && wfa->level_of_state[state] - 1 - >= (int) wfa->wfainfo->p_min_level) + >= (int) wfa->wfainfo->p_min_level) queue[last++] = wfa->tree[state][label]; /* append child */ } } - + INPUT_BYTE_ALIGN (input); Free (queue); } @@ -205,10 +205,10 @@ decode_mc_coords (unsigned max_state, wfa_t *wfa, bitfile_t *input) unsigned state; /* current state */ mv_t *mv; /* current motion vector */ static huff_node_t *huff_mv_root = NULL; /* root of huffman tree */ - + if (huff_mv_root == NULL) huff_mv_root = create_huff_tree (); - + for (state = wfa->basis_states; state < max_state; state++) for (label = 0; label < MAXLABELS; label++) { @@ -220,12 +220,12 @@ decode_mc_coords (unsigned max_state, wfa_t *wfa, bitfile_t *input) case FORWARD: mv->fx = get_mv (1, huff_mv_root, input); mv->fy = get_mv (1, huff_mv_root, input); - break; - case BACKWARD: + break; + case BACKWARD: mv->bx = get_mv (1, huff_mv_root, input); mv->by = get_mv (1, huff_mv_root, input); - break; - case INTERPOLATED: + break; + case INTERPOLATED: mv->fx = get_mv (1, huff_mv_root, input); mv->fy = get_mv (1, huff_mv_root, input); mv->bx = get_mv (1, huff_mv_root, input); @@ -236,11 +236,11 @@ decode_mc_coords (unsigned max_state, wfa_t *wfa, bitfile_t *input) INPUT_BYTE_ALIGN (input); } - + static int get_mv (int f_code, huff_node_t *hn, bitfile_t *input) -/* - * Decode next motion vector component in bitstream +/* + * Decode next motion vector component in bitstream * by traversing the huffman tree. */ { @@ -256,7 +256,7 @@ get_mv (int f_code, huff_node_t *hn, bitfile_t *input) hn = hn->left; } vlc_code = hn->code_index - 16; - if (vlc_code == 0 || f_code == 1) + if (vlc_code == 0 || f_code == 1) return vlc_code; vlc_code_magnitude = abs (vlc_code) - 1; @@ -265,7 +265,7 @@ get_mv (int f_code, huff_node_t *hn, bitfile_t *input) else residual = get_bits (input, f_code - 1); diffvec = (vlc_code_magnitude << (f_code - 1)) + residual + 1; - + return vlc_code > 0 ? diffvec : - diffvec; } @@ -277,7 +277,7 @@ create_huff_tree (void) { unsigned i; huff_node_t *huff_root = Calloc (1, sizeof (huff_node_t)); - + /* * The nodes' index set contains indices of all codewords that are * still decodable by traversing further down from the node. @@ -318,7 +318,7 @@ create_huff_node (huff_node_t *hn, int bits_processed) if (code_len == bits_processed) /* generate leaf */ { hn->code_index = ind; - Free (hn->left); + Free (hn->left); Free (hn->right); return; } @@ -332,3 +332,6 @@ create_huff_node (huff_node_t *hn, int bits_processed) create_huff_node (hn->left, bits_processed + 1); create_huff_node (hn->right, bits_processed + 1); } + + + diff --git a/converter/other/fiasco/input/nd.c b/converter/other/fiasco/input/nd.c index 52d48e61..129a150e 100644 --- a/converter/other/fiasco/input/nd.c +++ b/converter/other/fiasco/input/nd.c @@ -1,8 +1,8 @@ /* - * nd.c: Input of prediction tree + * nd.c: Input of prediction tree * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -31,7 +31,7 @@ /***************************************************************************** prototypes - + *****************************************************************************/ static void @@ -42,7 +42,7 @@ decode_nd_tree (wfa_t *wfa, bitfile_t *input); /***************************************************************************** public code - + *****************************************************************************/ void @@ -56,7 +56,7 @@ read_nd (wfa_t *wfa, bitfile_t *input) */ { unsigned total = decode_nd_tree (wfa, input); - + if (total > 0) decode_nd_coefficients (total, wfa, input); } @@ -64,7 +64,7 @@ read_nd (wfa_t *wfa, bitfile_t *input) /***************************************************************************** private code - + *****************************************************************************/ static unsigned @@ -106,7 +106,7 @@ decode_nd_tree (wfa_t *wfa, bitfile_t *input) { unsigned label; - if (wfa->level_of_state [next] > wfa->wfainfo->p_max_level + 1) + if (wfa->level_of_state [next] > wfa->wfainfo->p_max_level + 1) { /* * Nondetermismn is not allowed at levels larger than @@ -114,7 +114,7 @@ decode_nd_tree (wfa_t *wfa, bitfile_t *input) */ for (label = 0; label < MAXLABELS; label++) if (ischild (state = wfa->tree [next][label])) - queue_append (queue, &state); /* continue with childs */ + queue_append (queue, &state); /* continue with children */ } else if (wfa->level_of_state [next] > wfa->wfainfo->p_min_level) { @@ -123,7 +123,7 @@ decode_nd_tree (wfa_t *wfa, bitfile_t *input) { unsigned count; /* Current interval count */ unsigned range; /* Current interval range */ - + count = (((code - low) + 1) * sum1 - 1) / ((high - low) + 1); if (count < sum0) { @@ -192,7 +192,7 @@ decode_nd_tree (wfa_t *wfa, bitfile_t *input) static void decode_nd_coefficients (unsigned total, wfa_t *wfa, bitfile_t *input) /* - * Read #'total' weights of nondeterministic part of 'wfa' + * Read #'total' weights of nondeterministic part of 'wfa' * of given 'input' stream. * 'frame' gives the current frame number. * @@ -204,24 +204,24 @@ decode_nd_coefficients (unsigned total, wfa_t *wfa, bitfile_t *input) { unsigned *coefficients; /* array of factors to encode */ unsigned *ptr; /* pointer to current factor */ - + /* * Decode array of coefficients stored with arithmetic coding */ { const int scaling = 50; /* scaling factor of prob. model */ unsigned c_symbols = 1 << (wfa->wfainfo->dc_rpf->mantissa_bits + 1); - + ptr = coefficients = decode_array (input, NULL, &c_symbols, 1, total, scaling); } - + /* * Fill 'wfa->weights' with decoded coefficients */ { unsigned state, label; - + for (state = wfa->basis_states; state < wfa->states; state++) for (label = 0; label < MAXLABELS; label++) if (ischild (wfa->tree [state][label]) @@ -235,3 +235,6 @@ decode_nd_coefficients (unsigned total, wfa_t *wfa, bitfile_t *input) } Free (coefficients); } + + + diff --git a/converter/other/fiasco/input/read.c b/converter/other/fiasco/input/read.c index 9f4ac993..b4fcefc5 100644 --- a/converter/other/fiasco/input/read.c +++ b/converter/other/fiasco/input/read.c @@ -2,7 +2,7 @@ * read.c: Input of WFA files * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -47,7 +47,7 @@ /***************************************************************************** prototypes - + *****************************************************************************/ static void @@ -57,7 +57,7 @@ read_tiling (tiling_t *tiling, unsigned image_width, unsigned image_height, /***************************************************************************** public code - + *****************************************************************************/ bitfile_t * @@ -69,14 +69,14 @@ open_wfa (const char *filename, wfa_info_t *wi) * Pointer to input stream (fileposition: first WFA frame) * * Side effects: - * The values of the header of 'filename' are copied to 'wfainfo'. + * The values of the header of 'filename' are copied to 'wfainfo'. * */ { bitfile_t *input; /* pointer to WFA bitfile */ - + assert (filename && wi); - + wi->wfa_name = strdup (filename); /* @@ -85,16 +85,16 @@ open_wfa (const char *filename, wfa_info_t *wi) { unsigned n; const char *str; - + if (!(input = open_bitfile (filename, "FIASCO_DATA", READ_ACCESS))) file_error (filename); - + for (str = FIASCO_MAGIC, n = strlen (FIASCO_MAGIC); n; n--) if (get_bits (input, 8) != (unsigned) *str++) error ("Input file %s is not a valid FIASCO file!", filename); get_bits (input, 8); /* fetch newline */ } - + /* * Read WFA header information */ @@ -102,13 +102,13 @@ open_wfa (const char *filename, wfa_info_t *wi) char basis_name [MAXSTRLEN]; /* temp. buffer */ const unsigned rice_k = 8; /* parameter of Rice Code */ char *str = basis_name; - + while ((*str++ = get_bits (input, 8)) != 0 && str < basis_name + MAXSTRLEN) ; if (str == basis_name + MAXSTRLEN) error ("Input file %s is not a valid FIASCO file!", filename); - + { wi->release = read_rice_code (rice_k, input); @@ -121,12 +121,12 @@ open_wfa (const char *filename, wfa_info_t *wi) if (wi->release > 1) { header_type_e type; - + while ((type = read_rice_code (rice_k, input)) != HEADER_END) { char buffer [MAXSTRLEN]; unsigned n = 0; - + switch (type) { case HEADER_TITLE: @@ -157,7 +157,7 @@ open_wfa (const char *filename, wfa_info_t *wi) { unsigned lx = log2 (wi->width - 1) + 1; unsigned ly = log2 (wi->height - 1) + 1; - + wi->level = MAX(lx, ly) * 2 - ((ly == lx + 1) ? 1 : 0); } wi->chroma_max_states = wi->color ? read_rice_code (rice_k, input) : -1; @@ -176,14 +176,14 @@ open_wfa (const char *filename, wfa_info_t *wi) mantissa = get_bits (input, 3) + 2; range = get_bits (input, 2); wi->rpf = alloc_rpf (mantissa, range); - + if (get_bit (input)) /* different DC model */ { mantissa = get_bits (input, 3) + 2; range = get_bits (input, 2); wi->dc_rpf = alloc_rpf (mantissa, range); } - else /* use same model for DC coefficents */ + else /* use same model for DC coefficients */ wi->dc_rpf = alloc_rpf (wi->rpf->mantissa_bits, wi->rpf->range_e); @@ -196,7 +196,7 @@ open_wfa (const char *filename, wfa_info_t *wi) else wi->d_rpf = alloc_rpf (wi->rpf->mantissa_bits, wi->rpf->range_e); - + if (get_bit (input)) /* different DC delta model */ { mantissa = get_bits (input, 3) + 2; @@ -216,7 +216,7 @@ open_wfa (const char *filename, wfa_info_t *wi) wi->B_as_past_ref = get_bit (input) ? YES : NO; } } - + INPUT_BYTE_ALIGN (input); return input; @@ -246,10 +246,10 @@ read_basis (const char *filename, wfa_t *wfa) Free (wfa->wfainfo->basis_name); wfa->wfainfo->basis_name = strdup (filename); } - + if (get_linked_basis (filename, wfa)) - return; /* basis is linked with excecutable */ - + return; /* basis is linked with executable */ + /* * Check whether 'wfa_name' is a regular ASCII WFA initial basis file */ @@ -258,19 +258,19 @@ read_basis (const char *filename, wfa_t *wfa) if (!(input = open_file (filename, "FIASCO_DATA", READ_ACCESS))) file_error(filename); - + if (fscanf (input, MAXSTRLEN_SCANF, magic) != 1) error ("Format error: ASCII FIASCO initial basis file %s", filename); else if (strneq (FIASCO_BASIS_MAGIC, magic)) error ("Input file %s is not an ASCII FIASCO initial basis!", filename); } - + /* * WFA ASCII format: * * Note: State 0 is assumed to be the constant function f(x, y) = 128. - * Don't define any transitions of state 0 in an initial basis. + * Don't define any transitions of state 0 in an initial basis. * * Header: * type |description @@ -307,14 +307,14 @@ read_basis (const char *filename, wfa_t *wfa) /* * State 0 is assumed to be the constant function f(x, y) = 128. */ - wfa->domain_type [0] = USE_DOMAIN_MASK; + wfa->domain_type [0] = USE_DOMAIN_MASK; wfa->final_distribution [0] = 128; wfa->states = wfa->basis_states; wfa->basis_states++; append_edge (0, 0, 1.0, 0, wfa); append_edge (0, 0, 1.0, 1, wfa); - + for (state = 1; state < wfa->basis_states; state++) wfa->domain_type [state] = read_int (input) ? USE_DOMAIN_MASK : AUXILIARY_MASK; @@ -343,7 +343,7 @@ read_basis (const char *filename, wfa_t *wfa) } } } - + fclose (input); } @@ -353,7 +353,7 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) * Read next WFA frame of the WFA stream 'input'. * WFA header information has to be already present in the 'wfainfo' struct. * (i.e. open_wfa must be called first!) - * + * * No return value. * * Side effects: @@ -364,9 +364,9 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) { tiling_t tiling; /* tiling information */ unsigned frame_number; /* current frame number */ - + assert (wfa && input); - + /* * Frame header information */ @@ -382,16 +382,16 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) { INPUT_BYTE_ALIGN (input); } - + /* - * Read image tiling info + * Read image tiling info */ if (get_bit (input)) /* tiling performed ? */ read_tiling (&tiling, wfa->wfainfo->width, wfa->wfainfo->height, wfa->wfainfo->level, input); else tiling.exponent = 0; - + INPUT_BYTE_ALIGN (input); read_tree (wfa, &tiling, input); @@ -402,7 +402,7 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) */ { unsigned state; - + for (state = wfa->basis_states; state < wfa->states; state++) if ((!wfa->wfainfo->color || (int) state <= wfa->tree [wfa->tree [wfa->root_state][0]][0]) @@ -420,7 +420,7 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) else wfa->domain_type [state] = 0; } - + if (tiling.exponent) Free (tiling.vorder); @@ -431,12 +431,12 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) read_mc (wfa->frame_type, wfa, input); locate_delta_images (wfa); - + /* * Read linear combinations (coefficients and indices) */ { - unsigned edges = read_matrices (wfa, input); + unsigned edges = read_matrices (wfa, input); if (edges) read_weights (edges, wfa, input); @@ -447,7 +447,7 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) */ { unsigned state; - + for (state = wfa->basis_states; state <= wfa->states; state++) wfa->final_distribution[state] = compute_final_distribution (state, wfa); @@ -459,7 +459,7 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) /***************************************************************************** private code - + *****************************************************************************/ static void @@ -468,14 +468,14 @@ read_tiling (tiling_t *tiling, unsigned image_width, unsigned image_height, /* * Read image tiling information from the given file 'input' * and store parameters in struct 'tiling'. - * + * * No return value. */ { const unsigned rice_k = 8; /* parameter of Rice Code */ - + tiling->exponent = read_rice_code (rice_k, input); - + if (get_bit (input)) /* variance order */ { unsigned tile; /* current image tile */ @@ -487,7 +487,7 @@ read_tiling (tiling_t *tiling, unsigned image_width, unsigned image_height, { locate_subimage (image_level, image_level - tiling->exponent, tile, &x0, &y0, &width, &height); - if (x0 < image_width && y0 < image_height) + if (x0 < image_width && y0 < image_height) tiling->vorder [tile] = get_bits (input, tiling->exponent); else tiling->vorder [tile] = -1; @@ -500,3 +500,6 @@ read_tiling (tiling_t *tiling, unsigned image_width, unsigned image_height, tiling->exponent, get_bit (input) ? YES : NO); } } + + + diff --git a/converter/other/fiasco/input/tree.c b/converter/other/fiasco/input/tree.c index 0ac2b6ae..74ceeb68 100644 --- a/converter/other/fiasco/input/tree.c +++ b/converter/other/fiasco/input/tree.c @@ -2,7 +2,7 @@ * tree.c: Input of bintree partitioning * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -31,7 +31,7 @@ /***************************************************************************** prototypes - + *****************************************************************************/ static unsigned @@ -39,14 +39,14 @@ restore_depth_first_order (unsigned src_state, unsigned level, unsigned x, unsigned y, unsigned *dst_state, word_t (*bfo_tree)[MAXLABELS], wfa_t *wfa, tiling_t *tiling); -static void +static void decode_tree (bitfile_t *input, byte_t *data, unsigned n_data, unsigned scaling, u_word_t sum0, u_word_t sum1); /***************************************************************************** public code - + *****************************************************************************/ void @@ -64,7 +64,7 @@ read_tree (wfa_t *wfa, tiling_t *tiling, bitfile_t *input) { byte_t *bitstring; /* the encoded data */ word_t (*bfo_tree)[MAXLABELS]; /* node numbers in BFO */ - + /* * Read WFA tree stored in breadth first order */ @@ -75,7 +75,7 @@ read_tree (wfa_t *wfa, tiling_t *tiling, bitfile_t *input) bitstring = Calloc (total, sizeof (byte_t)); decode_tree (input, bitstring, total, scale, 1, 11); } - + /* * Generate tree using a breadth first traversal */ @@ -84,7 +84,7 @@ read_tree (wfa_t *wfa, tiling_t *tiling, bitfile_t *input) unsigned state; unsigned label; byte_t *buffer = bitstring; /* pointer to decoded data */ - + bfo_tree = Calloc (wfa->states * MAXLABELS, sizeof (word_t)); for (state = 0, next = 1; state < next; state++) for (label = 0; label < MAXLABELS; label++) @@ -110,7 +110,7 @@ read_tree (wfa_t *wfa, tiling_t *tiling, bitfile_t *input) /***************************************************************************** private code - + *****************************************************************************/ static unsigned @@ -119,13 +119,13 @@ restore_depth_first_order (unsigned src_state, unsigned level, unsigned x, word_t (*bfo_tree)[MAXLABELS], wfa_t *wfa, tiling_t *tiling) /* - * Map state 'src_state' (breadth first order) + * Map state 'src_state' (breadth first order) * to state '*dst_state' (depth first order) * Add a tree edge 'state' --> 'child' with label and weight 1.0 * if required. * 'x', 'y' give the coordinates of the current state in the 'color' image - * of size 'image_level'. 'tiling' defines the image partitioning. - * + * of size 'image_level'. 'tiling' defines the image partitioning. + * * Return value: * new node number in depth first order * @@ -134,8 +134,8 @@ restore_depth_first_order (unsigned src_state, unsigned level, unsigned x, * are filled with decoded values. */ { - unsigned newx [MAXLABELS]; /* x coordinate of childs */ - unsigned newy [MAXLABELS]; /* y coordinate of childs */ + unsigned newx [MAXLABELS]; /* x coordinate of children */ + unsigned newy [MAXLABELS]; /* y coordinate of children */ unsigned x0, y0; /* NW corner of image tile */ unsigned width, height; /* size of image tile */ @@ -145,7 +145,7 @@ restore_depth_first_order (unsigned src_state, unsigned level, unsigned x, if (tiling->exponent && level == wfa->wfainfo->level - tiling->exponent) { unsigned tile; - + for (tile = 0; tile < 1U << tiling->exponent; tile++) { locate_subimage (wfa->wfainfo->level, level, tile, @@ -159,7 +159,7 @@ restore_depth_first_order (unsigned src_state, unsigned level, unsigned x, } } /* - * Coordinates of childs 0 and 1 + * Coordinates of children 0 and 1 */ if (wfa->wfainfo->color && level == wfa->wfainfo->level + 1) newx[0] = newy[0] = newx[1] = newy[1] = 0; @@ -170,12 +170,12 @@ restore_depth_first_order (unsigned src_state, unsigned level, unsigned x, newx[1] = level & 1 ? x : x + width_of_level (level - 1); newy[1] = level & 1 ? y + height_of_level (level - 1) : y; } - + /* * Remap node numbers */ { - int child [MAXLABELS]; /* childs of current node (state) */ + int child [MAXLABELS]; /* children of current node (state) */ int domain; /* current domain */ unsigned label; @@ -196,17 +196,17 @@ restore_depth_first_order (unsigned src_state, unsigned level, unsigned x, } wfa->level_of_state [*dst_state] = level; } - + return (*dst_state)++; -} +} /**************************************************************************** Binary adaptive arithmetic compression - + ****************************************************************************/ -static void +static void decode_tree (bitfile_t *input, byte_t *data, unsigned n_data, unsigned scaling, u_word_t sum0, u_word_t sum1) /* @@ -235,11 +235,11 @@ decode_tree (bitfile_t *input, byte_t *data, unsigned n_data, unsigned scaling, low = 0; high = 0xffff; - for (n = n_data; n; n--) + for (n = n_data; n; n--) { unsigned count; /* Current interval count */ unsigned range; /* Current interval range */ - + count = (((code - low) + 1) * sum1 - 1) / ((high - low) + 1); if (count < sum0) { diff --git a/converter/other/fiasco/lib/arith.c b/converter/other/fiasco/lib/arith.c index 825d4757..4b92a2f7 100644 --- a/converter/other/fiasco/lib/arith.c +++ b/converter/other/fiasco/lib/arith.c @@ -2,7 +2,7 @@ * arith.c: Adaptive arithmetic coding and decoding * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -27,7 +27,7 @@ /****************************************************************************** public code - + ******************************************************************************/ arith_t * @@ -35,7 +35,7 @@ alloc_encoder (bitfile_t *output) /* * Arithmetic coder constructor: * Initialize the arithmetic coder. - * + * * Return value: * A pointer to the new coder structure */ @@ -43,7 +43,7 @@ alloc_encoder (bitfile_t *output) arith_t *arith = Calloc (1, sizeof (arith_t)); assert (output); - + arith->low = LOW; arith->high = HIGH; arith->underflow = 0; @@ -58,7 +58,7 @@ free_encoder (arith_t *arith) * Arithmetic encoder destructor. * Flush the arithmetic coder. Append all remaining bits to the * output stream. Append zero bits to get the output file byte aligned. - * + * * No return value. */ { @@ -66,14 +66,14 @@ free_encoder (arith_t *arith) u_word_t high; /* end of the current code range */ u_word_t underflow; /* number of underflow bits pending */ bitfile_t *output; - + assert (arith); low = arith->low; high = arith->high; underflow = arith->underflow; output = arith->file; - + low = high; RESCALE_OUTPUT_INTERVAL; @@ -92,7 +92,7 @@ encode_symbol (unsigned symbol, arith_t *arith, model_t *model) * * The model is updated after encoding the symbol (if necessary the * symbol counts are rescaled). - * + * * Return value: * information content of the encoded symbol. * @@ -110,7 +110,7 @@ encode_symbol (unsigned symbol, arith_t *arith, model_t *model) u_word_t high; /* end of the current code range */ u_word_t underflow; /* number of underflow bits pending */ bitfile_t *output; /* output file */ - + assert (model && arith); /* @@ -122,7 +122,7 @@ encode_symbol (unsigned symbol, arith_t *arith, model_t *model) output = arith->file; assert (high > low); - + if (model->order > 0) /* order-'n' model*/ { unsigned power; /* multiplicator */ @@ -134,10 +134,10 @@ encode_symbol (unsigned symbol, arith_t *arith, model_t *model) */ power = 1; /* multiplicator */ index = 0; /* address of prob. model */ - - for (i = 0; i < model->order; i++) /* genarate a M-nary number */ + + for (i = 0; i < model->order; i++) /* generate a M-nary number */ { - index += model->context [i] * power; + index += model->context [i] * power; power *= model->symbols; } @@ -160,9 +160,9 @@ encode_symbol (unsigned symbol, arith_t *arith, model_t *model) range = (high - low) + 1; high = low + (u_word_t) ((range * high_count) / scale - 1); low = low + (u_word_t) ((range * low_count) / scale); - + RESCALE_OUTPUT_INTERVAL; - + if (model->scale > 0) /* adaptive model */ { unsigned i; @@ -189,7 +189,7 @@ encode_symbol (unsigned symbol, arith_t *arith, model_t *model) arith->low = low; arith->high = high; arith->underflow = underflow; - + return - log2 ((high_count - low_count) / (real_t) scale); } @@ -214,21 +214,21 @@ encode_array (bitfile_t *output, const unsigned *data, const unsigned *context, assert (output && c_symbols && data); assert (n_context == 1 || context); - + /* * Allocate probability models, start with uniform distribution */ totals = Calloc (n_context, sizeof (u_word_t *)); { unsigned c; - + for (c = 0; c < n_context; c++) { unsigned i; - + totals [c] = Calloc (c_symbols [c] + 1, sizeof (u_word_t)); totals [c][0] = 0; - + for (i = 0; i < c_symbols [c]; i++) totals [c][i + 1] = totals [c][i] + 1; } @@ -242,7 +242,7 @@ encode_array (bitfile_t *output, const unsigned *data, const unsigned *context, u_word_t high = 0xffff; /* End of the current code range */ u_word_t underflow = 0; /* Number of underflow bits pending */ unsigned n; - + for (n = 0; n < n_data; n++) { u_word_t low_count; /* lower bound of 'symbol' interval */ @@ -253,8 +253,8 @@ encode_array (bitfile_t *output, const unsigned *data, const unsigned *context, int c; /* context of current data symbol */ d = data [n]; - c = n_context > 1 ? context [n] : 0; - + c = n_context > 1 ? context [n] : 0; + scale = totals [c][c_symbols [c]]; low_count = totals [c][d]; high_count = totals [c][d + 1]; @@ -266,7 +266,7 @@ encode_array (bitfile_t *output, const unsigned *data, const unsigned *context, high = low + (u_word_t) ((range * high_count) / scale - 1); low = low + (u_word_t) ((range * low_count) / scale); RESCALE_OUTPUT_INTERVAL; - + /* * Update probability models */ @@ -275,7 +275,7 @@ encode_array (bitfile_t *output, const unsigned *data, const unsigned *context, for (i = d + 1; i < c_symbols [c] + 1; i++) totals [c][i]++; - + if (totals [c][c_symbols [c]] > scaling) /* scaling */ for (i = 1; i < c_symbols [c] + 1; i++) { @@ -292,7 +292,7 @@ encode_array (bitfile_t *output, const unsigned *data, const unsigned *context, RESCALE_OUTPUT_INTERVAL; OUTPUT_BYTE_ALIGN (output); } - + /* * Cleanup ... */ @@ -310,16 +310,16 @@ alloc_decoder (bitfile_t *input) * Arithmetic decoder constructor: * Initialize the arithmetic decoder with the first * 16 input bits from the stream 'input'. - * + * * Return value: * A pointer to the new decoder structure */ { arith_t *arith = Calloc (1, sizeof (arith_t)); - + assert (input); - + arith->low = LOW; arith->high = HIGH; arith->code = get_bits (input, 16); @@ -333,8 +333,8 @@ free_decoder (arith_t *arith) /* * Arithmetic decoder destructor: * Flush the arithmetic decoder, i.e., read bits to get the input - * file byte aligned. - * + * file byte aligned. + * * No return value. * * Side effects: @@ -355,7 +355,7 @@ decode_symbol (arith_t *arith, model_t *model) * is given in 'arith'. Read refinement bits from the stream 'input' * and use the given probability 'model'. Update the probability model after * deconding the symbol (if necessary also rescale the symbol counts). - * + * * Return value: * decoded symbol * @@ -375,7 +375,7 @@ decode_symbol (arith_t *arith, model_t *model) bitfile_t *input; /* input file */ assert (arith && model); - + /* * Get interval values */ @@ -385,22 +385,22 @@ decode_symbol (arith_t *arith, model_t *model) input = arith->file; assert (high > low); - + if (model->order > 0) /* order-'n' model */ { unsigned power; /* multiplicator */ unsigned i; - + /* * Compute index of the probability model to use. * See init_model() for more details. */ power = 1; /* multiplicator */ index = 0; /* address of prob. model */ - + for (i = 0; i < model->order; i++) /* genarate a m-nary number */ { - index += model->context[i] * power; + index += model->context[i] * power; power *= model->symbols; } @@ -420,7 +420,7 @@ decode_symbol (arith_t *arith, model_t *model) if (model->order > 0) /* order-'n' model */ { unsigned i; - + for (i = 0; i < model->order - 1; i++) model->context [i] = model->context [i + 1]; model->context [i] = symbol; @@ -432,15 +432,15 @@ decode_symbol (arith_t *arith, model_t *model) { u_word_t low_count; /* lower bound of 'symbol' interval */ u_word_t high_count; /* upper bound of 'symbol' interval */ - + low_count = model->totals [index + symbol]; high_count = model->totals [index + symbol + 1]; high = low + (u_word_t) ((range * high_count) / scale - 1 ); low = low + (u_word_t) ((range * low_count) / scale ); } - + RESCALE_INPUT_INTERVAL; - + if (model->scale > 0) /* adaptive model */ { unsigned i; @@ -460,7 +460,7 @@ decode_symbol (arith_t *arith, model_t *model) } } } - + /* * Store interval values */ @@ -488,28 +488,28 @@ decode_array (bitfile_t *input, const unsigned *context, { unsigned *data; /* array to store decoded symbols */ u_word_t **totals; /* probability model */ - + if (n_context < 1) n_context = 1; /* always use one context */ assert (input && c_symbols); assert (n_context == 1 || context); data = Calloc (n_data, sizeof (unsigned)); - + /* * Allocate probability models, start with uniform distribution */ totals = Calloc (n_context, sizeof (u_word_t *)); { unsigned c; - + for (c = 0; c < n_context; c++) { unsigned i; - + totals [c] = Calloc (c_symbols [c] + 1, sizeof (u_word_t)); totals [c][0] = 0; - + for (i = 0; i < c_symbols [c]; i++) totals [c][i + 1] = totals [c][i] + 1; } @@ -523,8 +523,8 @@ decode_array (bitfile_t *input, const unsigned *context, u_word_t low = 0; /* Start of the current code range */ u_word_t high = 0xffff; /* End of the current code range */ unsigned n; - - for (n = 0; n < n_data; n++) + + for (n = 0; n < n_data; n++) { u_word_t scale; /* range of all 'm' symbol intervals */ u_word_t low_count; /* lower bound of 'symbol' interval */ @@ -534,13 +534,13 @@ decode_array (bitfile_t *input, const unsigned *context, unsigned d; /* current data symbol */ unsigned c; /* context of current data symbol */ - c = n_context > 1 ? context [n] : 0; + c = n_context > 1 ? context [n] : 0; assert (high > low); scale = totals [c][c_symbols [c]]; range = (high - low) + 1; count = (((code - low) + 1 ) * scale - 1) / range; - + for (d = c_symbols [c]; count < totals [c][d]; d--) /* next symbol */ ; low_count = totals [c][d]; @@ -558,7 +558,7 @@ decode_array (bitfile_t *input, const unsigned *context, for (i = d + 1; i < c_symbols [c] + 1; i++) totals [c][i]++; - + if (totals [c][c_symbols [c]] > scaling) /* scaling */ for (i = 1; i < c_symbols [c] + 1; i++) { @@ -577,12 +577,12 @@ decode_array (bitfile_t *input, const unsigned *context, */ { unsigned c; - + for (c = 0; c < n_context; c++) Free (totals [c]); Free (totals); } - + return data; } @@ -600,10 +600,10 @@ alloc_model (unsigned m, unsigned scale, unsigned n, unsigned *totals) * * Return value: * a pointer to the new probability model structure. - * + * * Note: We recommend a small size of the alphabet because no escape codes * are used to encode/decode previously unseen symbols. - * + * */ { model_t *model; /* new probability model */ @@ -621,7 +621,7 @@ alloc_model (unsigned m, unsigned scale, unsigned n, unsigned *totals) model->order = n; model->context = n > 0 ? Calloc (n, sizeof (unsigned)) : NULL; /* - * Allocate memory for the probabilty model. + * Allocate memory for the probability model. * Each of the m^n different contexts requires its own probability model. */ for (num = 1, i = 0; i < model->order; i++) @@ -644,17 +644,17 @@ alloc_model (unsigned m, unsigned scale, unsigned n, unsigned *totals) */ power = 1; /* multiplicator */ index = 0; /* address of prob. model */ - - for (i = 0; i < model->order; i++) /* genarate a m-nary number */ + + for (i = 0; i < model->order; i++) /* generate a m-nary number */ { - index += model->context[i] * power; + index += model->context[i] * power; power *= model->symbols; } index *= model->symbols + 1; /* size of each model is m + 1 */ model->totals [index + 0] = 0; /* always zero */ - + for (i = 1; i <= model->symbols; i++) /* prob of each symbol is 1/m or as given in totals */ model->totals[index + i] = model->totals [index + i - 1] @@ -667,14 +667,14 @@ alloc_model (unsigned m, unsigned scale, unsigned n, unsigned *totals) { dec = NO; model->context[i]++; - if (model->context[i] >= model->symbols) + if (model->context[i] >= model->symbols) { /* change previous context */ model->context[i] = 0; if (i > 0) /* there's still a context remaining */ dec = YES; else - cont = NO; /* all context models initilized */ + cont = NO; /* all context models initialized */ } } } diff --git a/converter/other/fiasco/lib/bit-io.c b/converter/other/fiasco/lib/bit-io.c index f69343e6..04716f05 100644 --- a/converter/other/fiasco/lib/bit-io.c +++ b/converter/other/fiasco/lib/bit-io.c @@ -1,12 +1,12 @@ /* - * bit-io.c: Buffered and bit oriented file I/O + * bit-io.c: Buffered and bit oriented file I/O * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ - + /* * $Date: 2000/06/14 20:49:37 $ * $Author: hafner $ @@ -35,7 +35,7 @@ /***************************************************************************** local constants - + *****************************************************************************/ static const unsigned BUFFER_SIZE = 16350; @@ -48,7 +48,7 @@ static const unsigned mask[] = {0x0001, 0x0002, 0x0004, 0x0008, /***************************************************************************** public code - + *****************************************************************************/ FILE * @@ -57,7 +57,7 @@ open_file (const char *filename, const char *env_var, openmode_e mode) * Try to open file 'filename' with mode 'mode' (READ_ACCESS, WRITE_ACCESS). * Scan the current directory first and then cycle through the * path given in the environment variable 'env_var', if set. - * + * * Return value: * Pointer to open file on success, else NULL. */ @@ -81,42 +81,42 @@ open_file (const char *filename, const char *env_var, openmode_e mode) { if (mode == READ_ACCESS) return stdin; - else + else return stdout; } - + /* * Try to open 'readonly' file in the current directory */ if (mode == READ_ACCESS && (fp = fopen (filename, read_mode))) - return fp; + return fp; if (mode == WRITE_ACCESS && strchr (filename, '/')) /* contains path */ return fopen (filename, write_mode); - + /* * Get value of environment variable 'env_var', if set * else use DEFAULT_PATH ("./") */ if (env_var != NULL) env_path = getenv (env_var); - if (env_path == NULL) + if (env_path == NULL) env_path = strdup (DEFAULT_PATH); else env_path = strdup (env_path); - + /* * Try to open file in the directory given by the environment - * variable env_var - individual path components are separated by PATH_SEP + * variable env_var - individual path components are separated by PATH_SEP */ path = strtok (env_path, PATH_SEP); - do + do { - if (ext_filename) + if (ext_filename) Free (ext_filename); ext_filename = Calloc (strlen (path) + strlen (filename) + 2, sizeof (char)); - strcpy (ext_filename, path); + strcpy (ext_filename, path); if (*(ext_filename + strlen (ext_filename) - 1) != '/') strcat (ext_filename, "/"); strcat (ext_filename, filename); @@ -125,7 +125,7 @@ open_file (const char *filename, const char *env_var, openmode_e mode) while (fp == NULL && (path = strtok (NULL, PATH_SEP)) != NULL); Free (env_path); - + return fp; } @@ -143,7 +143,7 @@ open_bitfile (const char *filename, const char *env_var, openmode_e mode) */ { bitfile_t *bitfile = Calloc (1, sizeof (bitfile_t)); - + bitfile->file = open_file (filename, env_var, mode); if (bitfile->file == NULL) @@ -164,8 +164,8 @@ open_bitfile (const char *filename, const char *env_var, openmode_e mode) bitfile->filename = filename ? strdup (filename) : strdup ("(stdout)"); } else - error ("Unknow file access mode '%d'.", mode); - + error ("Unknown file access mode '%d'.", mode); + bitfile->bits_processed = 0; bitfile->buffer = Calloc (BUFFER_SIZE, sizeof (byte_t)); bitfile->ptr = bitfile->buffer; @@ -187,7 +187,7 @@ get_bit (bitfile_t *bitfile) */ { assert (bitfile); - + if (!bitfile->bitpos--) /* use next byte ? */ { bitfile->ptr++; @@ -226,7 +226,7 @@ get_bits (bitfile_t *bitfile, unsigned bits) */ { unsigned value = 0; /* input value */ - + while (bits--) value = (unsigned) (value << 1) | get_bit (bitfile); @@ -235,7 +235,7 @@ get_bits (bitfile_t *bitfile, unsigned bits) void put_bit (bitfile_t *bitfile, unsigned value) -/* +/* * Put the bit 'value' to the bitfile buffer. * The buffer is written to the file 'bitfile->file' if the number of * buffer bytes exceeds 'BUFFER_SIZE'. @@ -247,7 +247,7 @@ put_bit (bitfile_t *bitfile, unsigned value) */ { assert (bitfile); - + if (!bitfile->bitpos--) /* use next byte ? */ { bitfile->ptr++; @@ -265,7 +265,7 @@ put_bit (bitfile_t *bitfile, unsigned value) } bitfile->bitpos = 7; } - + if (value) *bitfile->ptr |= mask [bitfile->bitpos]; @@ -274,7 +274,7 @@ put_bit (bitfile_t *bitfile, unsigned value) void put_bits (bitfile_t *bitfile, unsigned value, unsigned bits) -/* +/* * Put #'bits' bits of integer 'value' to the bitfile buffer 'bitfile'. * * No return value. @@ -292,7 +292,7 @@ close_bitfile (bitfile_t *bitfile) /* * Bitfile destructor: * Close 'bitfile', if 'bitfile->mode' == WRITE_ACCESS write bit buffer - * to disk. + * to disk. * * No return value. * @@ -301,7 +301,7 @@ close_bitfile (bitfile_t *bitfile) */ { assert (bitfile); - + if (bitfile->mode == WRITE_ACCESS) { unsigned bytes = fwrite (bitfile->buffer, sizeof (byte_t), diff --git a/converter/other/fiasco/output/mc.c b/converter/other/fiasco/output/mc.c index d048bef5..170a2648 100644 --- a/converter/other/fiasco/output/mc.c +++ b/converter/other/fiasco/output/mc.c @@ -1,9 +1,9 @@ /* - * mc.c: Output of motion compensation + * mc.c: Output of motion compensation * * Written by: Michael Unger * Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -30,7 +30,7 @@ /***************************************************************************** local variables - + *****************************************************************************/ static unsigned p_frame_codes [4][2] = @@ -39,7 +39,7 @@ static unsigned p_frame_codes [4][2] = * NONE, FORWARD */ { - {1, 1}, {0, 1}, {0, 0}, {0, 0} + {1, 1}, {0, 1}, {0, 0}, {0, 0} }; static unsigned b_frame_codes [4][2] = @@ -48,7 +48,7 @@ static unsigned b_frame_codes [4][2] = * NONE, FORWARD, BACKWARD, INTERPOLATED */ { - {1, 1}, {000, 3}, {001, 3}, {01, 2} + {1, 1}, {000, 3}, {001, 3}, {01, 2} }; enum vlc_e {CODE = 0, BITS = 1}; @@ -56,7 +56,7 @@ enum vlc_e {CODE = 0, BITS = 1}; /***************************************************************************** prototypes - + *****************************************************************************/ static void @@ -68,7 +68,7 @@ encode_mc_coords (unsigned max_state, const wfa_t *wfa, bitfile_t *output); /***************************************************************************** public code - + *****************************************************************************/ void @@ -85,7 +85,7 @@ write_mc (frame_type_e frame_type, const wfa_t *wfa, bitfile_t *output) /***************************************************************************** private code - + *****************************************************************************/ static void @@ -108,22 +108,22 @@ encode_mc_tree (unsigned max_state, frame_type_e frame_type, const wfa_t *wfa, mc_type_e type; /* type of motion compensation */ unsigned (*mc_tree_codes)[2]; /* pointer to VLC table */ unsigned bits = bits_processed (output); /* number of bits used */ - + if (frame_type == P_FRAME) mc_tree_codes = p_frame_codes; /* binary code */ - else + else mc_tree_codes = b_frame_codes; /* variable length code */ - + /* * Traverse tree in breadth first order (starting at - * level 'wfa->p_max_level'). Use a queue to store the childs - * of each node ('last' is the next free queue element). + * level 'wfa->p_max_level'). Use a queue to store the children + * of each node ('last' is the next free queue element). */ for (last = 0, state = wfa->basis_states; state < max_state; state++) if (wfa->level_of_state [state] - 1 == (int) wfa->wfainfo->p_max_level) queue [last++] = state; /* init level = 'mc_max_level' */ - + for (current = 0; current < last; current++) for (label = 0; label < MAXLABELS; label++) { @@ -145,7 +145,7 @@ encode_mc_tree (unsigned max_state, frame_type_e frame_type, const wfa_t *wfa, wfa->level_of_state [state] - 1 >= (int) wfa->wfainfo->p_min_level) queue [last++] = wfa->tree [state][label]; /* append child */ - + } OUTPUT_BYTE_ALIGN (output); @@ -174,16 +174,16 @@ encode_mc_coords (unsigned max_state, const wfa_t *wfa, bitfile_t *output) unsigned itotal = 0; /* #interpolated decisions */ unsigned bits = bits_processed (output); /* number of bits used */ unsigned sr = wfa->wfainfo->search_range; /* search range */ - + for (level = wfa->wfainfo->p_max_level; level >= wfa->wfainfo->p_min_level; level--) level_count [level] = 0; - + for (state = wfa->basis_states; state < max_state; state++) for (label = 0; label < MAXLABELS; label++) { mv_t *mv = &wfa->mv_tree[state][label]; /* motion vector info */ - + if (mv->type != NONE) { level_count [wfa->level_of_state [state] - 1]++; @@ -229,14 +229,14 @@ encode_mc_coords (unsigned max_state, const wfa_t *wfa, bitfile_t *output) } OUTPUT_BYTE_ALIGN (output); - + debug_message ("Motion compensation: %d forward, %d backward, " "%d interpolated", ftotal, btotal, itotal); for (level = wfa->wfainfo->p_max_level; level >= wfa->wfainfo->p_min_level; level--) debug_message ("Level %d: %d motion vectors", level, level_count[level]); - + { unsigned total = ftotal * 2 + btotal * 2 + itotal * 4; diff --git a/converter/other/fiasco/output/nd.c b/converter/other/fiasco/output/nd.c index 65a85467..b1dd6746 100644 --- a/converter/other/fiasco/output/nd.c +++ b/converter/other/fiasco/output/nd.c @@ -1,8 +1,8 @@ /* - * nd.c: Output of prediction tree + * nd.c: Output of prediction tree * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -32,7 +32,7 @@ /***************************************************************************** prototypes - + *****************************************************************************/ static unsigned @@ -43,7 +43,7 @@ encode_nd_coefficients (unsigned total, const wfa_t *wfa, bitfile_t *output); /***************************************************************************** public code - + *****************************************************************************/ void @@ -56,7 +56,7 @@ write_nd (const wfa_t *wfa, bitfile_t *output) */ { unsigned total = encode_nd_tree (wfa, output); - + if (total > 0) encode_nd_coefficients (total, wfa, output); } @@ -64,13 +64,13 @@ write_nd (const wfa_t *wfa, bitfile_t *output) /***************************************************************************** private code - + *****************************************************************************/ static unsigned encode_nd_tree (const wfa_t *wfa, bitfile_t *output) /* - * Write prediction tree of 'wfa' to given stream 'output'. + * Write prediction tree of 'wfa' to given stream 'output'. * * No return value. */ @@ -85,7 +85,7 @@ encode_nd_tree (const wfa_t *wfa, bitfile_t *output) unsigned bits = bits_processed (output); used = not_used = 0; - + /* * Initialize arithmetic coder */ @@ -94,18 +94,18 @@ encode_nd_tree (const wfa_t *wfa, bitfile_t *output) underflow = 0; sum0 = 1; sum1 = 11; - + queue = alloc_queue (sizeof (int)); state = wfa->root_state; queue_append (queue, &state); - + /* * Traverse the WFA tree in breadth first order (using a queue). */ while (queue_remove (queue, &next)) { unsigned label; - + if (wfa->level_of_state [next] > wfa->wfainfo->p_max_level + 1) { /* @@ -114,7 +114,7 @@ encode_nd_tree (const wfa_t *wfa, bitfile_t *output) */ for (label = 0; label < MAXLABELS; label++) if (ischild (state = wfa->tree [next][label])) - queue_append (queue, &state); /* continue with childs */ + queue_append (queue, &state); /* continue with children */ } else if (wfa->level_of_state [next] > wfa->wfainfo->p_min_level) { @@ -126,7 +126,7 @@ encode_nd_tree (const wfa_t *wfa, bitfile_t *output) if (isedge (wfa->into [next][label][0])) /* prediction used */ { used++; - + /* * Encode a '1' symbol */ @@ -134,12 +134,12 @@ encode_nd_tree (const wfa_t *wfa, bitfile_t *output) low = low + (u_word_t) ((range * sum0) / sum1); RESCALE_OUTPUT_INTERVAL; } - else /* no predict., continue with childs */ + else /* no predict., continue with children */ { not_used++; if (wfa->level_of_state [state] > wfa->wfainfo->p_min_level) queue_append (queue, &state); - + /* * Encode a '0' symbol */ @@ -162,7 +162,7 @@ encode_nd_tree (const wfa_t *wfa, bitfile_t *output) sum1 = sum0 + 1; } } - + } } free_queue (queue); @@ -178,7 +178,7 @@ encode_nd_tree (const wfa_t *wfa, bitfile_t *output) used, not_used); { unsigned total = used + not_used; - + debug_message ("nd-tree: %5d bits. (%5d symbols => %5.2f bps)", bits_processed (output) - bits, total, total > 0 ? ((bits_processed (output) - bits) / @@ -205,7 +205,7 @@ encode_nd_coefficients (unsigned total, const wfa_t *wfa, bitfile_t *output) unsigned *ptr; /* pointer to current factor */ unsigned state, label, edge; word_t domain; - + ptr = coefficients = Calloc (total, sizeof (unsigned)); for (state = wfa->basis_states; state < wfa->states; state++) @@ -232,7 +232,7 @@ encode_nd_coefficients (unsigned total, const wfa_t *wfa, bitfile_t *output) encode_array (output, coefficients, NULL, &c_symbols, 1, total, scaling); } - + debug_message ("nd-factors: %5d bits. (%5d symbols => %5.2f bps)", bits_processed (output) - bits, total, total ? ((bits_processed (output) - bits) diff --git a/converter/other/fiasco/output/tree.c b/converter/other/fiasco/output/tree.c index 2eae2df9..55080a51 100644 --- a/converter/other/fiasco/output/tree.c +++ b/converter/other/fiasco/output/tree.c @@ -2,7 +2,7 @@ * tree.c: Output of bintree partitioning * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -30,7 +30,7 @@ /***************************************************************************** prototypes - + *****************************************************************************/ static void @@ -40,7 +40,7 @@ encode_tree (bitfile_t *output, const byte_t *data, unsigned n_data, /***************************************************************************** public code - + *****************************************************************************/ void @@ -64,9 +64,9 @@ write_tree (const wfa_t *wfa, bitfile_t *output) /* * Traverse tree in breadth first order. Use a queue to store - * the childs of each node ('last' is the next free queue element). + * the children of each node ('last' is the next free queue element). * The first element ('current') of this queue will get the new parent - * node. + * node. */ tree_string = Calloc (MAXSTATES * MAXLABELS, sizeof (byte_t)); queue [0] = wfa->root_state; @@ -83,7 +83,7 @@ write_tree (const wfa_t *wfa, bitfile_t *output) if (total != (wfa->states - wfa->basis_states) * MAXLABELS) error ("total [%d] != (states - basis_states) * 2 [%d]", total, (wfa->states - wfa->basis_states) * MAXLABELS); - + { unsigned scale = total / 20 ; @@ -91,7 +91,7 @@ write_tree (const wfa_t *wfa, bitfile_t *output) } Free (tree_string); - + debug_message ("tree: %5d bits. (%5d symbols => %5.2f bps)", bits_processed (output) - bits, total, total > 0 ? ((bits_processed (output) - bits) @@ -101,7 +101,7 @@ write_tree (const wfa_t *wfa, bitfile_t *output) /***************************************************************************** private code - + *****************************************************************************/ static void @@ -128,7 +128,7 @@ encode_tree (bitfile_t *output, const byte_t *data, unsigned n_data, for (n = n_data; n; n--) { unsigned range; /* Current interval range */ - + if (!*data++) { /* diff --git a/converter/other/fiasco/params.c b/converter/other/fiasco/params.c index 7d0b84ab..d834414a 100644 --- a/converter/other/fiasco/params.c +++ b/converter/other/fiasco/params.c @@ -3,7 +3,7 @@ * * Written by: Stefan Frank * Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -28,7 +28,7 @@ #include <stdlib.h> #include <string.h> - + #include <getopt.h> /* system or ../lib */ #include "pm_c_util.h" @@ -47,7 +47,7 @@ /***************************************************************************** prototypes - + *****************************************************************************/ static void @@ -56,7 +56,7 @@ static int get_parameter_index (const param_t *params, const char *search_string); static void set_parameter (param_t *parameter, const char *value); -static void +static void usage (const param_t *params, const char *progname, const char *synopsis, const char *comment, const char *non_opt_string, bool_t show_all_options, const char *sys_file_name, @@ -65,17 +65,17 @@ usage (const param_t *params, const char *progname, const char *synopsis, /***************************************************************************** public code - + *****************************************************************************/ int -parseargs (param_t *usr_params, - int argc, char **argv, +parseargs (param_t *usr_params, + int argc, char **argv, const char *synopsis, - const char *comment, - const char *non_opt_string, + const char *comment, + const char *non_opt_string, const char *path, - const char *sys_file_name, + const char *sys_file_name, const char *usr_file_name) /* * Perform the command line parsing. @@ -95,7 +95,7 @@ parseargs (param_t *usr_params, * * Side effects: * the elements of ARGV are permuted - * usr_params [].value is modified + * usr_params [].value is modified */ { extern int optind; /* index in ARGV of the 1st element @@ -146,7 +146,7 @@ parseargs (param_t *usr_params, */ { param_t *p; - + for (p = usr_params; p->name != NULL; p++) { set_parameter (p, p->default_value); @@ -155,7 +155,7 @@ parseargs (param_t *usr_params, } sys_params = detailed_help ? detailed_sys_params : short_sys_params; - + for (p = sys_params; p->name != NULL; p++) set_parameter (p, p->default_value); } @@ -210,12 +210,12 @@ parseargs (param_t *usr_params, int optchar; /* found option character */ /* - * Build short option string for getopt_long (). + * Build short option string for getopt_long (). */ { param_t *p; /* counter */ char *ptr_optstr; /* pointer to position in string */ - + ptr_optstr = optstr; for (p = params; p->name != NULL; p++) if (p->optchar != '\0') @@ -231,13 +231,13 @@ parseargs (param_t *usr_params, } *ptr_optstr = '\0'; } - + /* - * Build long option string for getopt_long (). + * Build long option string for getopt_long (). */ { int i; - + long_options = calloc (n1 + n2 + 1, sizeof (struct option)); if (!long_options) error ("Out of memory."); @@ -264,15 +264,15 @@ parseargs (param_t *usr_params, long_options [i].val = 0; } } - + /* - * Parse comand line + * Parse command line */ while ((optchar = getopt_long (argc, argv, optstr, long_options, &option_index)) != EOF) { int param_index = -1; - + switch (optchar) { case 0: @@ -303,7 +303,7 @@ parseargs (param_t *usr_params, default: { int i; - + for (i = 0; params [i].name != NULL; i++) if (params [i].optchar == optchar) { @@ -350,7 +350,7 @@ parseargs (param_t *usr_params, free (long_options); } - + /* * Read config-file if specified by option -f */ @@ -361,7 +361,7 @@ parseargs (param_t *usr_params, if ((filename = (char *) parameter_value (params, "config")) != NULL) { FILE *parameter_file; /* input file */ - + warning ("Options set in file `%s' will override" " command line options.", filename); parameter_file = open_file (filename, NULL, READ_ACCESS); @@ -379,10 +379,10 @@ parseargs (param_t *usr_params, memcpy (usr_params, params, n1 * sizeof (param_t)); /* fill user struct */ free (sys_path); - + return optind; } - + void * parameter_value (const param_t *params, const char *name) /* @@ -399,7 +399,7 @@ parameter_value (const param_t *params, const char *name) if (params [pind].type == PSTR || params [pind].type == POSTR) return (void *) params [pind].value.s; - + return (void *) &(params [pind].value); } @@ -414,7 +414,7 @@ ask_and_set (param_t *params, const char *name, const char *msg) * Side effects: * 'params ['name'].value' is changed */ -{ +{ char answer [MAXSTRLEN]; int index = get_parameter_index (params, name); @@ -423,7 +423,7 @@ ask_and_set (param_t *params, const char *name, const char *msg) if (msg) fprintf (stderr, "%s\n", msg); - + switch (params [index].type) { case PFLAG: /* Unusual, at least. */ @@ -439,7 +439,7 @@ ask_and_set (param_t *params, const char *name, const char *msg) default: error ("Invalid parameter type for %s", name); } -} +} void write_parameters (const param_t *params, FILE *output) @@ -483,7 +483,7 @@ write_parameters (const param_t *params, FILE *output) /***************************************************************************** private code - + *****************************************************************************/ static void @@ -498,7 +498,7 @@ set_parameter (param_t *parameter, const char *value) */ { assert (parameter); - + switch (parameter->type) { case PFLAG: @@ -516,7 +516,7 @@ set_parameter (param_t *parameter, const char *value) { long int data; char *endptr; - + data = strtol (value, &endptr, 0); if (*endptr != '\0' || endptr == value) warning ("Invalid value `%s' converted to %d", @@ -531,7 +531,7 @@ set_parameter (param_t *parameter, const char *value) { long int data; char *endptr; - + data = strtol (value, &endptr, 0); if (*endptr != '\0' || endptr == value) warning ("Invalid value `%s' converted to %d", @@ -543,7 +543,7 @@ set_parameter (param_t *parameter, const char *value) { double data; char *endptr; - + data = strtod (value, &endptr); if (*endptr != '\0' || endptr == value) warning ("Invalid value `%s' converted to %f", @@ -555,7 +555,7 @@ set_parameter (param_t *parameter, const char *value) case POSTR: parameter->value.s = value ? strdup (value) : NULL; break; - default: + default: error ("Invalid parameter type for %s", parameter->name); } } @@ -606,7 +606,7 @@ read_parameter_file (param_t *params, FILE *file) char *name; /* parameter name */ char *value; /* parameter value */ int pind; /* current argument number */ - + b = strchr (buffer, '#'); if (b != NULL) /* Strip comments. */ *b = '\0'; @@ -619,7 +619,7 @@ read_parameter_file (param_t *params, FILE *file) /* * Extract value of parameter */ - for (value = b + 1; ISSPACE (*value); value++) + for (value = b + 1; ISSPACE (*value); value++) ; /* Delete leading spaces */ for (b = value + strlen (value) - 1; b >= value && ISSPACE (*b); b--) @@ -628,7 +628,7 @@ read_parameter_file (param_t *params, FILE *file) /* * Extract parameter name */ - for (name = buffer; ISSPACE (*name); name++) + for (name = buffer; ISSPACE (*name); name++) ; /* Delete leading spaces */ for (b = name + strlen (name) - 1; b >= name && ISSPACE (*b); b--) @@ -637,14 +637,14 @@ read_parameter_file (param_t *params, FILE *file) pind = get_parameter_index (params, name); if (pind >= 0) set_parameter (¶ms [pind], value); - + n++; } -} +} -static void +static void usage (const param_t *params, const char *progname, const char *synopsis, const char *comment, const char *non_opt_string, bool_t show_all_options, const char *sys_file_name, @@ -662,7 +662,7 @@ usage (const param_t *params, const char *progname, const char *synopsis, { int i; size_t width = 0; - + fprintf (stderr, "Usage: %s [OPTION]...%s\n", progname, non_opt_string ? non_opt_string : " "); if (synopsis != NULL) @@ -683,7 +683,7 @@ usage (const param_t *params, const char *progname, const char *synopsis, else width = MAX(width, (strlen (params [i].name)) - 1); } - + for (i = 0; params [i].name != NULL; i++) if (params [i].optchar != '\0' || show_all_options) { @@ -691,7 +691,7 @@ usage (const param_t *params, const char *progname, const char *synopsis, fprintf (stderr, " -%c, --", params [i].optchar); else fprintf (stderr, " --"); - + if (params [i].type == POSTR) fprintf (stderr, "%s=[%s]%-*s ", params [i].name, params [i].argument_name, @@ -707,7 +707,7 @@ usage (const param_t *params, const char *progname, const char *synopsis, (unsigned)(width + 1), params [i].name); fprintf (stderr, params [i].use, params [i].argument_name); - + switch (params [i].type) { case PFLAG: diff --git a/converter/other/fiasco/pnmtofiasco.c b/converter/other/fiasco/pnmtofiasco.c index e2656c71..9f63e7a1 100644 --- a/converter/other/fiasco/pnmtofiasco.c +++ b/converter/other/fiasco/pnmtofiasco.c @@ -2,11 +2,11 @@ * cwfa.c: FIASCO coder * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ - + /* * $Date: 2000/10/28 17:39:29 $ * $Author: hafner $ @@ -33,7 +33,7 @@ /***************************************************************************** local variables - + *****************************************************************************/ static param_t params [] = @@ -107,7 +107,7 @@ static param_t params [] = "Set domain pool of r-lc to `%s'."}, {"coeff", "NAME", '\0', PSTR, {0}, "adaptive", "Set coefficients model to `%s'."}, - /* DELTA APPROXIATION */ + /* DELTA APPROXIMATION */ {"d-domain-pool", "NAME", '\0', PSTR, {0}, "rle", "Set domain pool of d-lc to `%s'."}, {"d-coeff", "NAME", '\0', PSTR, {0}, "adaptive", @@ -132,36 +132,36 @@ static param_t params [] = "Smooth frames by factor `%s' (0.5 - 1.0)"}, {"reference-frame", "FILE", '\0', PSTR, {0}, NULL, "Use PPM/PGM image `%s' as reference frame."}, -#endif +#endif {NULL, NULL, 0, PSTR, {0}, NULL, NULL } }; /***************************************************************************** prototypes - + *****************************************************************************/ -static void +static void checkargs (int argc, char **argv, char const ***image_template, char **wfa_name, float *quality, fiasco_c_options_t **options); /***************************************************************************** public code - + *****************************************************************************/ - -int + +int main (int argc, char **argv) { char const **image_template; /* template for input image files */ char *wfa_name; /* filename of output WFA */ float quality; /* approximation quality */ fiasco_c_options_t *options; /* additional coder options */ - + pnm_init(&argc, argv); - + init_error_handling (argv [0]); checkargs (argc, argv, &image_template, &wfa_name, &quality, &options); @@ -179,10 +179,10 @@ main (int argc, char **argv) /***************************************************************************** private code - + *****************************************************************************/ -static void +static void checkargs (int argc, char **argv, char const ***image_template, char **wfa_name, float *quality, fiasco_c_options_t **options) /* @@ -191,7 +191,7 @@ checkargs (int argc, char **argv, char const ***image_template, * Return value: * 1 on success * 0 otherwise - * + * * * Side effects: * 'image_template', 'wfa_name', 'quality' and 'options' are set. @@ -200,7 +200,7 @@ checkargs (int argc, char **argv, char const ***image_template, 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 -, " @@ -220,7 +220,7 @@ checkargs (int argc, char **argv, char const ***image_template, /* * Default options ... */ - image_name = (char *) parameter_value (params, "image-name"); + image_name = (char *) parameter_value (params, "image-name"); *wfa_name = (char *) parameter_value (params, "output-name"); for (;;) { @@ -233,7 +233,7 @@ checkargs (int argc, char **argv, char const ***image_template, ask_and_set (params, "quality", "Please enter coding quality 'q' ('q' > 0): "); } - + if (optind < argc) /* Additional command line param */ { if (image_name) @@ -260,7 +260,7 @@ checkargs (int argc, char **argv, char const ***image_template, */ { *options = fiasco_c_options_new (); - + { char *pattern = (char *) parameter_value (params, "pattern"); @@ -270,7 +270,7 @@ checkargs (int argc, char **argv, char const ***image_template, { char *basis = (char *) parameter_value (params, "basis-name"); - + if (!fiasco_c_options_set_basisfile (*options, basis)) error (fiasco_get_error_message ()); } @@ -278,41 +278,41 @@ checkargs (int argc, char **argv, char const ***image_template, { int n = * (int *) parameter_value (params, "chroma-dictionary"); float q = * (float *) parameter_value (params, "chroma-qfactor"); - + if (!fiasco_c_options_set_chroma_quality (*options, q, MAX(0, n))) error (fiasco_get_error_message ()); } - + { int n = *((int *) parameter_value (params, "smooth")); - + if (!fiasco_c_options_set_smoothing (*options, MAX(0, n))) error (fiasco_get_error_message ()); } - + { int n = * (int *) parameter_value (params, "progress-meter"); - fiasco_progress_e type = (n < 0) ? + fiasco_progress_e type = (n < 0) ? FIASCO_PROGRESS_NONE : (fiasco_progress_e) n; - + if (!fiasco_c_options_set_progress_meter (*options, type)) error (fiasco_get_error_message ()); } - + { char *t = (char *) parameter_value (params, "title"); - + if (strlen (t) > 0 && !fiasco_c_options_set_title (*options, t)) error (fiasco_get_error_message ()); } - + { char *c = (char *) parameter_value (params, "comment"); if (strlen (c) > 0 && !fiasco_c_options_set_comment (*options, c)) error (fiasco_get_error_message ()); } - + { fiasco_tiling_e method = FIASCO_TILING_VARIANCE_DSC; int e = * (int *) parameter_value (params, "tiling-exponent"); @@ -332,7 +332,7 @@ checkargs (int argc, char **argv, char const ***image_template, 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") */; @@ -354,7 +354,7 @@ checkargs (int argc, char **argv, char const ***image_template, m = 4; N = 5; } - + if (!fiasco_c_options_set_optimizations (*options, m, M, N, MAX(0, D), o)) error (fiasco_get_error_message ()); @@ -363,7 +363,7 @@ checkargs (int argc, char **argv, char const ***image_template, 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 ()); @@ -374,7 +374,7 @@ checkargs (int argc, char **argv, char const ***image_template, 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) @@ -383,7 +383,7 @@ checkargs (int argc, char **argv, char const ***image_template, 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) @@ -392,7 +392,7 @@ checkargs (int argc, char **argv, char const ***image_template, 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)) @@ -402,4 +402,7 @@ checkargs (int argc, char **argv, char const ***image_template, if (fiasco_get_verbosity () == FIASCO_ULTIMATE_VERBOSITY) write_parameters (params, stderr); } -} +} + + + diff --git a/converter/other/giftopnm.c b/converter/other/giftopnm.c index e2d5923d..470c85b7 100644 --- a/converter/other/giftopnm.c +++ b/converter/other/giftopnm.c @@ -867,7 +867,7 @@ termStack(struct Stack * const stackP) { What we call 'dataWidth', others call the "minimum code size," which is a misnomer, because the minimum code size in a stream must be at least one - more than 'dataWidth', to accomodate the clear and end codes. + more than 'dataWidth', to accommmodate the clear and end codes. -----------------------------------------------------------------------------*/ static int const maxLzwCodeCt = (1<<MAX_LZW_BITS); @@ -1722,7 +1722,7 @@ readImageData(FILE * const ifP, pm_error("Invalid data width (bits for a true data item) " "in image data: %u. " "Maximum allowable code size in GIF is %u, " - "and a code has to be wide enough to accomodate both " + "and a code has to be wide enough to accommodate both " "all possible data values and two control codes", lzwDataWidth, MAX_LZW_BITS); diff --git a/converter/other/pamtotiff.c b/converter/other/pamtotiff.c index 115b8b4a..1718c933 100644 --- a/converter/other/pamtotiff.c +++ b/converter/other/pamtotiff.c @@ -838,7 +838,7 @@ computeRasterParm(struct pam * const pamP, 2. Direct mode (specified with -output) We have the Tiff library write output to the specified file. As the Tiff - library requires taht it be be seekable and readable, we fail the program + library requires that it be be seekable and readable, we fail the program rather than ask the Tiff library to use the file if it does not meet these requirements. diff --git a/converter/other/pnmtopalm/pnmtopalm.c b/converter/other/pnmtopalm/pnmtopalm.c index 4f535d1a..9fc92790 100644 --- a/converter/other/pnmtopalm/pnmtopalm.c +++ b/converter/other/pnmtopalm/pnmtopalm.c @@ -787,7 +787,7 @@ computeRawRowNonDirect(const xel * const xelrow, sizeof(ColormapEntry), palmcolor_compare_colors); if (!foundEntryP) { - pm_error("INERNAL ERROR: " + pm_error("INTERNAL ERROR: " "Color (%u,%u,%u) not found in colormap, " "though it was supposedly there before", PPM_GETR(xelrow[col]), diff --git a/converter/other/pnmtops.c b/converter/other/pnmtops.c index abb80cd7..45d856d0 100644 --- a/converter/other/pnmtops.c +++ b/converter/other/pnmtops.c @@ -2121,7 +2121,7 @@ main(int argc, const char * argv[]) { ** wrzl@gup.uni-linz.ac.at. ** ** July 2011 afu -** row converters rewritten, fast PBM-only row convertor added, +** row converters rewritten, fast PBM-only row converter added, ** rle compression slightly modified, flate compression added ** ascii85 output end added. ** diff --git a/converter/pbm/pbmtoibm23xx.c b/converter/pbm/pbmtoibm23xx.c index 0af20b5e..3f1f9679 100644 --- a/converter/pbm/pbmtoibm23xx.c +++ b/converter/pbm/pbmtoibm23xx.c @@ -131,7 +131,7 @@ process_handle(FILE * const fh, int cols, rows, format; /* iteration variables */ unsigned int x, y; - unsigned int bitline; /* pixel line within a sigle printing line */ + unsigned int bitline; /* pixel line within a single printing line */ unsigned int pass; /* here we build the to-be-printed data */ unsigned char *output; /* for reading one row from the file */ diff --git a/converter/pbm/pbmtoptx.c b/converter/pbm/pbmtoptx.c index c0fb0f80..69f1707a 100644 --- a/converter/pbm/pbmtoptx.c +++ b/converter/pbm/pbmtoptx.c @@ -12,10 +12,10 @@ #include "pbm.h" -/* Follwing is obtained by reversing bit order (MFS-LFS) and adding 64. */ +/* Following is obtained by reversing bit order (MFS-LFS) and adding 64. */ /* Note the two escape sequences: \\ and \x7f . */ -static unsigned char const ptxchar[64] = +static unsigned char const ptxchar[64] = "@`PpHhXxDdTtLl\\|BbRrJjZzFfVvNn^~AaQqIiYyEeUuMm]}CcSsKk[{GgWwOo_\x7f"; @@ -32,7 +32,7 @@ putBitrow(const bit * const bitrow, unsigned int const byteCnt = (itemCnt * 6) / 8; bit const byteCur = bitrow[byteCnt]; bit const byteNext = bitrow[byteCnt + 1]; - + unsigned int item; switch (itemCnt % 4) { @@ -62,7 +62,7 @@ main(int argc, const char ** argv) { ifP = stdin; else { ifP = pm_openr(argv[1]); - + if (argc-1 > 1) pm_error("Too many arguments. The only possible argument is " "the input fil name"); @@ -82,9 +82,8 @@ main(int argc, const char ** argv) { pbm_freerow_packed(bitrow); pm_close(ifP); - + return 0; } - diff --git a/converter/ppm/ppmtompeg/docs/template.param b/converter/ppm/ppmtompeg/docs/template.param index 78ad5300..fb837428 100644 --- a/converter/ppm/ppmtompeg/docs/template.param +++ b/converter/ppm/ppmtompeg/docs/template.param @@ -138,7 +138,7 @@ BQSCALE 25 # this must be ORIGINAL or DECODED REFERENCE_FRAME ORIGINAL -# for parallel parameters see parallel.param in the exmaples subdirectory +# for parallel parameters see parallel.param in the examples subdirectory # if you want constant bit-rate mode, specify it as follows (number is bits/sec): BIT_RATE 1000000 diff --git a/converter/ppm/xim.h b/converter/ppm/xim.h index 2e6a6dc1..ff21203f 100644 --- a/converter/ppm/xim.h +++ b/converter/ppm/xim.h @@ -6,7 +6,7 @@ ** Taken from the X.V11R4 version of XimHeader.h: ** ** Author: Philip R. Thompson -** Address: phils@athena.mit.edu, 9-526 +** Address: phils@athena.mit.edu, 9-526 ** Note: size of header should be 1024 (1K) bytes. ** $Header: /mit/phils/X/RCS/XimHeader.h,v 1.7 89/11/09 17:26:54 phils Exp Locker: phils $ ** $Date: 89/11/09 17:26:54 $ @@ -81,7 +81,7 @@ typedef struct XimImage { typedef struct XimAsciiHeader { char file_version[4]; /* header version */ char header_size[8]; /* Size of file header (fixed part only) */ - char image_height[8]; /* Height of the raster imgage in pixels */ + char image_height[8]; /* Height of the raster image in pixels */ char image_width[8]; /* Width of the raster image in pixels */ char bytes_line[8]; /* Actual # of bytes separating scanlines */ char bits_channel[4]; /* Bits per channel (usually 1 or 8) */ diff --git a/doc/INSTALL b/doc/INSTALL index 3c3bfcbd..c20d372e 100644 --- a/doc/INSTALL +++ b/doc/INSTALL @@ -210,7 +210,7 @@ to in _mingw.h. This is the trick other C libraries use. (A user proposed that this change be distributed in _mingw.h, in April 2017 on -the mingw-users mailing list, but the maintainer was opposed to accomodating +the mingw-users mailing list, but the maintainer was opposed to accommodating programs written for the older standards). If you cannot change _mingw.h, you can alternatively change Netpbm. Find all diff --git a/editor/pamaltsat.c b/editor/pamaltsat.c index 6d9b91e0..3bff55bd 100644 --- a/editor/pamaltsat.c +++ b/editor/pamaltsat.c @@ -160,7 +160,7 @@ typedef double (binsearchFunc)(double const x, /* The binary-search function. Returns such <x> from [<min>, <max>] that monotonically increasing function func(x, data) equals <value> within - precision <prec>. <dataP> is an arbitary parameter to <func>. */ + precision <prec>. <dataP> is an arbitrary parameter to <func>. */ static double binsearch(binsearchFunc func, const void * const dataP, @@ -299,7 +299,7 @@ typedef struct { TupleD * tupsatP; /* saturated color */ double * intRatioP; - /* ratio of orignal and saturated intensities */ + /* ratio of original and saturated intensities */ } MaxLogSatInfo; @@ -346,7 +346,7 @@ getMaxLogSat(LinSampleInfo * const siP, /* Discarding return value (maximum saturation) because upon completion of binsearch() info.tupsatP will contain the saturated color. The target value of maximum channel intensity is decreased by PREC in order to avoid - overlow. */ + overflow. */ binsearch(binsearchMaxLogSat, &info, PREC, 1.0, upperLimit, 1.0 - PREC); } @@ -399,11 +399,11 @@ saturateSpectrum(LinSampleInfo * const siP, else { double const km1 = (1.0 - siP->intensity)/(siP->maxval - siP->intensity); - /* Maximum saturation factor that keeps maximum layer intesity + /* Maximum saturation factor that keeps maximum layer intensity within range */ double const km2 = siP->intensity/(siP->intensity - sample[siP->minl]); - /* Maximum saturation factor that keeps minimum layer intesity + /* Maximum saturation factor that keeps minimum layer intensity within range */ diff --git a/editor/pamcut.c b/editor/pamcut.c index db5b5b3d..6da4fc0c 100644 --- a/editor/pamcut.c +++ b/editor/pamcut.c @@ -35,10 +35,10 @@ typedef struct { If LOCTYPE_NONE: Meaningless - If LOCTYPE_FROMFAR: Number of colums from the far edge of the image + If LOCTYPE_FROMFAR: Number of columns from the far edge of the image (right or bottom). Last column/row is 1. - If LOCTYPE_FROMNEAR: Number of colums from the near edge of the + If LOCTYPE_FROMNEAR: Number of columns from the near edge of the image (left or top). First column/row is 0. */ } Location; diff --git a/editor/pamlevels.c b/editor/pamlevels.c index fbbb2c0b..a282751a 100644 --- a/editor/pamlevels.c +++ b/editor/pamlevels.c @@ -482,7 +482,7 @@ pamlevels(CmdlineInfo const cmdline) { static void freeCmdLineInfo(CmdlineInfo cmdline) { /*---------------------------------------------------------------------------- - Free any memory that has been dynamically allcoated in <cmdline>. + Free any memory that has been dynamically allocated in <cmdline>. -----------------------------------------------------------------------------*/ TransSet * const xxP = &cmdline.xlats; diff --git a/editor/pnmcrop.c b/editor/pnmcrop.c index 6ef1c280..5e74190f 100644 --- a/editor/pnmcrop.c +++ b/editor/pnmcrop.c @@ -1136,7 +1136,7 @@ extremeCrops(struct CmdlineInfo const cmdline, pm_message("Input image has no distinction between " "border and content"); - /* We can't just pick a representive pixel, say top-left corner. + /* We can't just pick a representative pixel, say top-left corner. If -top and/or -bottom was specified but not -left and -right, the output should be one row, not a single pixel. diff --git a/editor/ppmshadow b/editor/ppmshadow index ae6b1b0f..c07c03b0 100755 --- a/editor/ppmshadow +++ b/editor/ppmshadow @@ -89,7 +89,7 @@ sub imageDimensions($) { sub backgroundColor($) { my ($fileName) = @_; #----------------------------------------------------------------------------- -# Return the color of the backround of the image in the file named $fileName. +# Return the color of the background of the image in the file named $fileName. #----------------------------------------------------------------------------- # We call the color of the top left pixel the background color. diff --git a/generator/pamtris/boundaries.c b/generator/pamtris/boundaries.c index 7045cbc7..cfcc4c1d 100644 --- a/generator/pamtris/boundaries.c +++ b/generator/pamtris/boundaries.c @@ -120,7 +120,7 @@ gen_triangle_boundaries(Xy const xy, } if (xy._[0][1] == xy._[1][1] && xy._[1][1] == xy._[2][1]) { - /* Triangle is degenarate: its visual representation consists only of + /* Triangle is degenerate: its visual representation consists only of a horizontal straight line. */ diff --git a/generator/pamtris/framebuffer.c b/generator/pamtris/framebuffer.c index 93263c91..5665e9a4 100644 --- a/generator/pamtris/framebuffer.c +++ b/generator/pamtris/framebuffer.c @@ -164,7 +164,7 @@ realloc_image_buffer(int32_t const new_maxval, function "process_next_command", which is the only function that calls this one. - If the function suceeds, the image buffer is left in cleared state. The + If the function succeeds, the image buffer is left in cleared state. The Z-Buffer, however, is not touched at all. If the new depth is equal to the previous one, no actual reallocation is @@ -313,7 +313,7 @@ draw_span(uint32_t const base, unsigned int l; /* The following statements will only have any effect if the depth - test, performed above, has suceeded. I. e. if the depth test fails, + test, performed above, has succeeded. I. e. if the depth test fails, no changes will be made on the frame buffer; otherwise, the frame buffer will be updated with the new values. */ diff --git a/generator/pbmtext.c b/generator/pbmtext.c index 6304c7d4..ef00be27 100644 --- a/generator/pbmtext.c +++ b/generator/pbmtext.c @@ -610,7 +610,7 @@ getCharsWithinWidth(PM_WCHAR const line[], if (currentWidth > targetWidth) { if (cursor == 1) pm_error("-width value too small " - "to accomodate single character"); + "to accommodate single character"); else *charCountP = cursor - 1; } else diff --git a/lib/libpamcolor.c b/lib/libpamcolor.c index e1a24c66..718df89f 100644 --- a/lib/libpamcolor.c +++ b/lib/libpamcolor.c @@ -177,15 +177,15 @@ parseInteger(const char * const colorname, if (r > maxval) pm_error("Red value in color specification '%s' is %u, " - "whcih is invalid because the specified maxval is %u", + "which is invalid because the specified maxval is %u", colorname, r, maxval); if (g > maxval) pm_error("Green value in color specification '%s' is %u, " - "whcih is invalid because the specified maxval is %u", + "which is invalid because the specified maxval is %u", colorname, g, maxval); if (b > maxval) pm_error("Blue value in color specification '%s' is %u, " - "whcih is invalid because the specified maxval is %u", + "which is invalid because the specified maxval is %u", colorname, b, maxval); color[PAM_RED_PLANE] = (float)r/maxval; diff --git a/lib/libpamwrite.c b/lib/libpamwrite.c index 1ff334aa..7edc90dc 100644 --- a/lib/libpamwrite.c +++ b/lib/libpamwrite.c @@ -384,7 +384,7 @@ pnm_writepamrowmult(const struct pam * const pamP, const tuple * const tuplerow, unsigned int const count) { /*---------------------------------------------------------------------------- - Write mutiple ('count') copies of the same row ('tuplerow') to the file. + Write multiple ('count') copies of the same row ('tuplerow') to the file. -----------------------------------------------------------------------------*/ if (pm_plain_output || pamP->plainformat) { unsigned int i; diff --git a/lib/libpbmfont1.c b/lib/libpbmfont1.c index 2d269da7..4189f150 100644 --- a/lib/libpbmfont1.c +++ b/lib/libpbmfont1.c @@ -189,8 +189,8 @@ pbm_dissectfont(const bit ** const fontsheet, unsigned int const frows, unsigned int const fcols) { /*---------------------------------------------------------------------------- - Dissect PBM sheet font data, create a font structre, - load bitmap data into it. + Dissect PBM sheet font data, create a font structure, load bitmap data into + it. Return value is a pointer to the newly created font structure @@ -205,7 +205,7 @@ pbm_dissectfont(const bit ** const fontsheet, just a matter of filling in all the coordinates. Struct font has fields 'oldfont', 'fcols', 'frows' for backward - compability. If there is any need to load data stored in this format + compatibility. If there is any need to load data stored in this format feed the above three, in order, as arguments to this function: pbm_dissectfont(oldfont, fcols, frows); diff --git a/test/pbmtext.test b/test/pbmtext.test index fdecf453..515711e4 100755 --- a/test/pbmtext.test +++ b/test/pbmtext.test @@ -53,7 +53,7 @@ done # Test 4: Should print 1647614653 2027 three times -# Note: backslashes inserted in 3 locations in the rectange to make +# Note: backslashes inserted in 3 locations in the rectangle to make # possible input as a here document. fontRectangle_txt=${tmpdir}/fontRectangle.txt diff --git a/test/ps-flate-roundtrip.test b/test/ps-flate-roundtrip.test index de1105f0..08d1500c 100755 --- a/test/ps-flate-roundtrip.test +++ b/test/ps-flate-roundtrip.test @@ -5,7 +5,7 @@ # This script tests the optional flate (zlib) compression feature of # pstopnm. # Flate compression allows you to make smaller output (.ps) files: -# it is useful, but not essential. Flate compression is not neccessary for +# it is useful, but not essential. Flate compression is not necessary for # printing pages with postscript printers - which is why many people need # pnmtops on their systems. |