diff options
Diffstat (limited to 'converter/other/fiasco')
37 files changed, 1679 insertions, 1809 deletions
diff --git a/converter/other/fiasco/Makefile b/converter/other/fiasco/Makefile index 16221d77..392e843c 100644 --- a/converter/other/fiasco/Makefile +++ b/converter/other/fiasco/Makefile @@ -11,8 +11,9 @@ COMP_INCLUDES = \ -I$(SRCDIR)/$(SUBDIR)/codec -I$(SRCDIR)/$(SUBDIR)/input \ -I$(SRCDIR)/$(SUBDIR)/output -I$(SRCDIR)/$(SUBDIR)/lib \ -BINARIES = pnmtofiasco fiascotopnm +PORTBINARIES = pnmtofiasco fiascotopnm +BINARIES = $(PORTBINARIES) MERGEBINARIES = $(BINARIES) SCRIPTS = @@ -24,21 +25,18 @@ FIASCOLIBS = codec/libfiasco_codec.a \ output/libfiasco_output.a \ lib/libfiasco_lib.a -COMMON_OBJECTS = binerror.o getopt.o getopt1.o params.o +ADDL_OBJECTS = binerror.o getopt.o getopt1.o params.o -OBJECTS = $(BINARIES:%=%.o) $(COMMON_OBJECTS) +OBJECTS = $(BINARIES:%=%.o) $(ADDL_OBJECTS) -MERGE_OBJECTS = $(BINARIES:%=%.o2) $(COMMON_OBJECTS) $(FIASCOLIBS) +MERGE_OBJECTS = $(BINARIES:%=%.o2) $(ADDL_OBJECTS) $(FIASCOLIBS) SUBDIRS = codec input output lib include $(SRCDIR)/common.mk -$(BINARIES):%:%.o $(COMMON_OBJECTS) $(FIASCOLIBS) $(NETPBMLIB) \ - $(LIBOPT) - $(LD) -o $@ $< $(COMMON_OBJECTS) \ - $(shell $(LIBOPT) $(FIASCOLIBS) $(NETPBMLIB)) $(MATHLIB) \ - $(LDFLAGS) $(LDLIBS) $(RPATH) $(LADD) +$(BINARIES):%:%.o $(ADDL_OBJECTS) $(FIASCOLIBS) +$(BINARIES): LDFLAGS_TARGET = $(shell $(LIBOPT) $(FIASCOLIBS)) codec/libfiasco_codec.a: $(BUILDDIR)/$(SUBDIR)/codec FORCE $(MAKE) -C codec -f $(SRCDIR)/$(SUBDIR)/codec/Makefile \ diff --git a/converter/other/fiasco/binerror.c b/converter/other/fiasco/binerror.c index 8a41a214..77243c64 100644 --- a/converter/other/fiasco/binerror.c +++ b/converter/other/fiasco/binerror.c @@ -92,11 +92,7 @@ _error (const char *format, ...) fprintf (stderr, "%s: %s: line %d:\nError: ", executable, error_file, error_line); -#if HAVE_VPRINTF vfprintf (stderr, format, args); -#elif HAVE_DOPRNT - _doprnt (format, args, stderr); -#endif /* HAVE_DOPRNT */ fputc ('\n', stderr); va_end(args); @@ -132,11 +128,7 @@ _warning (const char *format, ...) fprintf (stderr, "%s: %s: line %d:\nWarning: ", executable, error_file, error_line); -#if HAVE_VPRINTF vfprintf (stderr, format, args); -#elif HAVE_DOPRNT - _doprnt (format, args, stderr); -#endif /* HAVE_DOPRNT */ fputc ('\n', stderr); va_end (args); diff --git a/converter/other/fiasco/codec/approx.c b/converter/other/fiasco/codec/approx.c index 72e38cbf..5072fae3 100644 --- a/converter/other/fiasco/codec/approx.c +++ b/converter/other/fiasco/codec/approx.c @@ -294,7 +294,7 @@ static real_t ip_domain_ortho_vector [MAXSTATES][MAXEDGES]; static real_t rem_denominator [MAXSTATES]; static real_t rem_numerator [MAXSTATES]; /* - * At step n of the orthogonalization the comparitive value + * At step n of the orthogonalization the comparative value * (numerator_i / denominator_i):= <b, o_n>^2 / ||o_n|| , * is computed for every domain i, * where o_n := s_i - \sum(k = 0, ... , n-1) {(<s_i, o_k> / ||o_k||^2) o_k} @@ -670,7 +670,7 @@ orthogonalize (unsigned index, unsigned n, unsigned level, real_t min_norm, * for (i = 0, ... , wfa->states) * <s_i, o_n> := <s_i, v_n> - * \sum (k = 0, ... , n - 1){ <v_n, o_k> <s_i, o_k> / ||o_k||^2} - * Moreover the denominator and numerator parts of the comparitive + * Moreover the denominator and numerator parts of the comparative * value are updated. */ for (domain = 0; domain_blocks [domain] >= 0; domain++) diff --git a/converter/other/fiasco/codec/coder.c b/converter/other/fiasco/codec/coder.c index 927ebbda..94e367dd 100644 --- a/converter/other/fiasco/codec/coder.c +++ b/converter/other/fiasco/codec/coder.c @@ -252,14 +252,14 @@ alloc_coder (char const * const * const inputname, lx = (unsigned) (log2 (wi->width - 1) + 1); ly = (unsigned) (log2 (wi->height - 1) + 1); - wi->level = max (lx, ly) * 2 - ((ly == lx + 1) ? 1 : 0); + wi->level = MAX(lx, ly) * 2 - ((ly == lx + 1) ? 1 : 0); } c = Calloc (1, sizeof (coding_t)); c->options = *options; - c->options.lc_min_level = max (options->lc_min_level, 3); - c->options.lc_max_level = min (options->lc_max_level, wi->level - 1); + c->options.lc_min_level = MAX(options->lc_min_level, 3); + c->options.lc_max_level = MIN(options->lc_max_level, wi->level - 1); c->tiling = alloc_tiling (options->tiling_method, options->tiling_exponent, wi->level); @@ -273,7 +273,7 @@ alloc_coder (char const * const * const inputname, if (c->options.lc_max_level >= wi->level - c->tiling->exponent) { message ("'max_level' changed from %d to %d " - "due to image tiling level.", + "because of image tiling level.", c->options.lc_max_level, wi->level - c->tiling->exponent - 1); c->options.lc_max_level = wi->level - c->tiling->exponent - 1; } @@ -285,16 +285,16 @@ alloc_coder (char const * const * const inputname, * p_min_level, p_max_level min and max level for ND/MC prediction * [p_min_level, p_max_level] must be a subset of [min_level, max_level] ! */ - wi->p_min_level = max (options->p_min_level, c->options.lc_min_level); - wi->p_max_level = min (options->p_max_level, c->options.lc_max_level); + wi->p_min_level = MAX(options->p_min_level, c->options.lc_min_level); + wi->p_max_level = MIN(options->p_max_level, c->options.lc_max_level); if (wi->p_min_level > wi->p_max_level) wi->p_min_level = wi->p_max_level; - c->options.images_level = min (c->options.images_level, - c->options.lc_max_level - 1); + c->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->products_level = MAX(0, ((signed int) c->options.lc_max_level + - (signed int) c->options.images_level - 1)); c->pixels = Calloc (size_of_level (c->options.lc_max_level), sizeof (real_t)); c->images_of_state = Calloc (MAXSTATES, sizeof (real_t *)); @@ -324,8 +324,8 @@ alloc_coder (char const * const * const inputname, /* * Max. number of states and edges */ - wi->max_states = max (min (options->max_states, MAXSTATES), 1); - c->options.max_elements = max (min (options->max_elements, MAXEDGES), 1); + wi->max_states = MAX(MIN(options->max_states, MAXSTATES), 1); + c->options.max_elements = MAX(MIN(options->max_elements, MAXEDGES), 1); /* * Title and comment strings @@ -348,7 +348,7 @@ alloc_coder (char const * const * const inputname, /* * Color image options ... */ - wi->chroma_max_states = max (1, options->chroma_max_states); + wi->chroma_max_states = MAX(1, options->chroma_max_states); /* * Set up motion compensation struct. @@ -432,9 +432,9 @@ print_statistics (char c, real_t costs, const wfa_t *wfa, const image_t *image, if (lincomb) { - max_level = max (max_level, + max_level = MAX(max_level, (unsigned) (wfa->level_of_state [state] - 1)); - min_level = min (min_level, + min_level = MIN(min_level, (unsigned) (wfa->level_of_state [state] - 1)); } } @@ -548,77 +548,78 @@ frame_coder (wfa_t *wfa, coding_t *c, bitfile_t *output) } else { - int YCb_node = -1; - int tree [3]; /* 3 root states of each color comp. */ - color_e band; + 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) - * are copied into a large image: - * [ Y Cr ] - * [ Cb 0 ] - * I.e. the color components of an image are processed in a row. - * After all components are compressed, virtual states are generated - * to describe the large image. - */ - for (band = first_band (YES); band <= last_band (YES) ; band++) - { - debug_message ("Encoding color component %d", band); - tree [band] = RANGE; - if (band == Cb) - { - unsigned min_level; - - c->domain_pool->chroma (wfa->wfainfo->chroma_max_states, wfa, - c->domain_pool->model); - /* - * Don't use a finer partioning for the chrominancy bands than for - * the luminancy band. - */ - for (min_level = MAXLEVEL, state = wfa->basis_states; - state < wfa->states; state++) - { - unsigned lincomb, label; + /* + * When compressing color images, the three color components (YCbCr) + * are copied into a large image: + * [ Y Cr ] + * [ Cb 0 ] + * I.e. the color components of an image are processed in a row. + * After all components are compressed, virtual states are generated + * to describe the large image. + */ + for (band = first_band (YES); band <= last_band (YES) ; band++) + { + debug_message ("Encoding color component %d", band); + tree [band] = RANGE; + if (band == Cb) + { + unsigned min_level; + + c->domain_pool->chroma (wfa->wfainfo->chroma_max_states, wfa, + c->domain_pool->model); + /* + * Don't use a finer partioning for the chrominancy bands than + * for the luminancy band. + */ + for (min_level = MAXLEVEL, state = wfa->basis_states; + state < wfa->states; state++) + { + unsigned lincomb, label; - for (lincomb = 0, label = 0; label < MAXLABELS; label++) - lincomb += isrange (wfa->tree [state][label]) ? 1 : 0; - if (lincomb) - min_level = min (min_level, - (unsigned) (wfa->level_of_state [state] - - 1)); - } - c->options.lc_min_level = min_level; - if (c->mt->frame_type != I_FRAME) /* subtract mc of luminance */ - subtract_mc (c->mt->original, c->mt->past, c->mt->future, wfa); - } - - memset (&range, 0, sizeof (range_t)); - range.level = wfa->wfainfo->level; + for (lincomb = 0, label = 0; label < MAXLABELS; label++) + lincomb += isrange (wfa->tree [state][label]) ? 1 : 0; + if (lincomb) + min_level = MIN(min_level, + (unsigned) (wfa->level_of_state [state] + - 1)); + } + c->options.lc_min_level = min_level; + if (c->mt->frame_type != I_FRAME) /* subtract mc of luminance */ + subtract_mc (c->mt->original, c->mt->past, c->mt->future, + wfa); + } + + memset (&range, 0, sizeof (range_t)); + range.level = wfa->wfainfo->level; - costs = subdivide (MAXCOSTS, band, tree [Y], &range, wfa, c, - c->mt->frame_type != I_FRAME && band == Y, NO); - if (c->options.progress_meter != FIASCO_PROGRESS_NONE) - message (""); - { - char colors [] = {'Y', 'B', 'R'}; + 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); - } + 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 (isrange (range.tree)) /* whole image is approx. by a l.c. */ + error ("No root state generated for color component %d!", band); + else + tree[band] = range.tree; - if (band == Cb) - { - wfa->tree [wfa->states][0] = tree[Y]; - wfa->tree [wfa->states][1] = tree[Cb]; - YCb_node = wfa->states; - append_state (YES, compute_final_distribution (wfa->states, wfa), - wfa->wfainfo->level + 1, wfa, c); - } + if (band == Cb) + { + wfa->tree [wfa->states][0] = tree[Y]; + wfa->tree [wfa->states][1] = tree[Cb]; + YCb_node = wfa->states; + append_state (YES, compute_final_distribution(wfa->states, wfa), + wfa->wfainfo->level + 1, wfa, c); + } } /* * generate two virtual states (*) diff --git a/converter/other/fiasco/codec/control.c b/converter/other/fiasco/codec/control.c index 9af9928b..94c23c83 100644 --- a/converter/other/fiasco/codec/control.c +++ b/converter/other/fiasco/codec/control.c @@ -16,11 +16,7 @@ #include "config.h" -#if HAVE_STRING_H -# include <string.h> -#else /* not HAVE_STRING_H */ -# include <strings.h> -#endif /* not HAVE_STRING_H */ +#include <string.h> #include "types.h" #include "macros.h" diff --git a/converter/other/fiasco/codec/decoder.c b/converter/other/fiasco/codec/decoder.c index 77d5340f..26284596 100644 --- a/converter/other/fiasco/codec/decoder.c +++ b/converter/other/fiasco/codec/decoder.c @@ -1,9 +1,9 @@ /* - * decode.c: Decoding of an image represented by a WFA + * decode.c: Decoding of an image represented by a WFA * - * Written by: Ullrich Hafner - * Michael Unger - * + * Written by: Ullrich Hafner + * Michael Unger + * * This file is part of FIASCO («F»ractal «I»mage «A»nd «S»equence «CO»dec) * Copyright (C) 1994-2000 Ullrich Hafner <hafner@bigfoot.de> */ @@ -15,13 +15,12 @@ * $State: Exp $ */ +#include "pm_config.h" #include "config.h" -#if HAVE_STRING_H -# include <string.h> -#else /* not HAVE_STRING_H */ -# include <strings.h> -#endif /* not HAVE_STRING_H */ +#include <string.h> + +#include "pm_c_util.h" #include "types.h" #include "macros.h" @@ -37,33 +36,33 @@ /***************************************************************************** - prototypes + prototypes *****************************************************************************/ static void compute_state_images (unsigned frame_level, word_t **simg, - const u_word_t *offset, const wfa_t *wfa); + const u_word_t *offset, const wfa_t *wfa); static void free_state_images (unsigned max_level, bool_t color, word_t **state_image, - u_word_t *offset, const unsigned *root_state, - unsigned range_state, format_e format, const wfa_t *wfa); + u_word_t *offset, const unsigned *root_state, + unsigned range_state, format_e format, const wfa_t *wfa); static void alloc_state_images (word_t ***images, u_word_t **offsets, const image_t *frame, - const unsigned *root_state, unsigned range_state, - unsigned max_level, format_e format, const wfa_t *wfa); + const unsigned *root_state, unsigned range_state, + unsigned max_level, format_e format, const wfa_t *wfa); static void compute_actual_size (unsigned luminance_root, - unsigned *width, unsigned *height, const wfa_t *wfa); + unsigned *width, unsigned *height, const wfa_t *wfa); static void enlarge_image (int enlarge_factor, format_e format, unsigned y_root, - wfa_t *wfa); + wfa_t *wfa); static word_t * duplicate_state_image (const word_t *domain, unsigned offset, unsigned level); /***************************************************************************** - public code + public code *****************************************************************************/ @@ -75,7 +74,7 @@ alloc_video (bool_t store_wfa) * and future WFA if flag 'store_wfa' is TRUE. * * Return value: - * pointer to the new video structure + * pointer to the new video structure */ { video_t *video = Calloc (1, sizeof (video_t)); @@ -84,7 +83,7 @@ alloc_video (bool_t store_wfa) video->display = 0; video->future = video->sfuture = video->past - = video->frame = video->sframe = NULL; + = video->frame = video->sframe = NULL; if (store_wfa) { @@ -107,7 +106,7 @@ free_video (video_t *video) * No return value. * * Side effects: - * 'video' struct is discarded. + * 'video' struct is discarded. */ { if (video->past) @@ -132,9 +131,9 @@ free_video (video_t *video) image_t * get_next_frame (bool_t store_wfa, int enlarge_factor, - int smoothing, const char *reference_frame, - format_e format, video_t *video, dectimer_t *timer, - wfa_t *orig_wfa, bitfile_t *input) + int smoothing, const char *reference_frame, + format_e format, video_t *video, dectimer_t *timer, + wfa_t *orig_wfa, bitfile_t *input) /* * Get next frame of the WFA 'video' from stream 'input'. * 'orig_wfa' is the constant part of the WFA used by all frames. @@ -148,265 +147,265 @@ get_next_frame (bool_t store_wfa, int enlarge_factor, * If 'timer' is not NULL, then accumulate running time statistics. * * Return value: - * pointer to decoded frame + * pointer to decoded frame * * Side effects: - * 'video' and 'timer' struct are modified. + * 'video' and 'timer' struct are modified. */ { - image_t *frame = NULL; /* current frame */ - image_t *sframe = NULL; /* current smoothed frame */ + image_t *frame = NULL; /* current frame */ + image_t *sframe = NULL; /* current smoothed frame */ bool_t current_frame_is_future_frame = NO; - if (video->future_display == video->display) + if (video->future_display == video->display) { /* * Future frame is already computed since it has been used * as reference frame. So just return the stored frame. */ if (video->frame) /* discard current frame */ - free_image (video->frame); + free_image (video->frame); video->frame = video->future; video->future = NULL; if (video->sframe) /* discard current (smoothed) frame */ - free_image (video->sframe); + free_image (video->sframe); video->sframe = video->sfuture; video->sfuture = NULL; if (store_wfa) - copy_wfa (video->wfa, video->wfa_future); + copy_wfa (video->wfa, video->wfa_future); video->display++; if (!store_wfa) - video->wfa = NULL; + video->wfa = NULL; } else { - do /* compute next frame(s) */ + do /* compute next frame(s) */ { - unsigned frame_number; /* current frame number */ - clock_t ptimer; - unsigned int stop_timer [3]; - wfa_t *tmp_wfa = NULL; - - if (!store_wfa) - video->wfa = orig_wfa; - else - { - tmp_wfa = alloc_wfa (NO); - copy_wfa (tmp_wfa, video->wfa); - copy_wfa (video->wfa, orig_wfa); - } + unsigned frame_number; /* current frame number */ + clock_t ptimer; + unsigned int stop_timer [3]; + wfa_t *tmp_wfa = NULL; + + if (!store_wfa) + video->wfa = orig_wfa; + else + { + tmp_wfa = alloc_wfa (NO); + copy_wfa (tmp_wfa, video->wfa); + copy_wfa (video->wfa, orig_wfa); + } - /* - * First step: read WFA from disk - */ - prg_timer (&ptimer, START); - frame_number = read_next_wfa (video->wfa, input); - stop_timer [0] = prg_timer (&ptimer, STOP); - if (timer) - { - timer->input [video->wfa->frame_type] += stop_timer [0]; - timer->frames [video->wfa->frame_type]++; - } + /* + * First step: read WFA from disk + */ + prg_timer (&ptimer, START); + frame_number = read_next_wfa (video->wfa, input); + stop_timer [0] = prg_timer (&ptimer, STOP); + if (timer) + { + timer->input [video->wfa->frame_type] += stop_timer [0]; + timer->frames [video->wfa->frame_type]++; + } - /* - * Read reference frame from disk if required - * (i.e., 1st frame is of type B or P) - */ - if (video->display == 0 && video->wfa->frame_type != I_FRAME) - { - if (!reference_frame) - error ("First frame is %c-frame but no " - "reference frame is given.", - video->wfa->frame_type == B_FRAME ? 'B' : 'P'); - - video->frame = read_image_file (reference_frame); - video->sframe = NULL; - } + /* + * Read reference frame from disk if required + * (i.e., 1st frame is of type B or P) + */ + if (video->display == 0 && video->wfa->frame_type != I_FRAME) + { + if (!reference_frame) + error ("First frame is %c-frame but no " + "reference frame is given.", + video->wfa->frame_type == B_FRAME ? 'B' : 'P'); + + video->frame = read_image_file (reference_frame); + video->sframe = NULL; + } - /* - * Depending on current frame type update past and future frames - */ - if (video->wfa->frame_type == I_FRAME) - { - if (video->past) /* discard past frame */ - free_image (video->past); - video->past = NULL; - if (video->future) /* discard future frame */ - free_image (video->future); - video->future = NULL; - if (video->sfuture) /* discard (smoothed) future frame */ - free_image (video->sfuture); - video->sfuture = NULL; - if (video->frame) /* discard current frame */ - free_image (video->frame); - video->frame = NULL; - if (video->sframe) /* discard current (smoothed) frame */ - free_image (video->sframe); - video->sframe = NULL; - } - else if (video->wfa->frame_type == P_FRAME) - { - if (video->past) /* discard past frame */ - free_image (video->past); - video->past = video->frame; /* past <- current frame */ - video->frame = NULL; - if (video->sframe) /* discard current (smoothed) frame */ - free_image (video->sframe); - video->sframe = NULL; - if (store_wfa) - copy_wfa (video->wfa_past, tmp_wfa); - if (video->future) /* discard future frame */ - free_image (video->future); - video->future = NULL; - if (video->sfuture) /* discard (smoothed) future frame */ - free_image (video->sfuture); - video->sfuture = NULL; - } - else /* B_FRAME */ - { - if (current_frame_is_future_frame) - { - if (video->future) /* discard future frame */ - free_image (video->future); - video->future = frame; /* future <- current frame */ - if (video->sfuture) /* discard (smoothed) future frame */ - free_image (video->sfuture); - video->sfuture = sframe; /* future <- current (smoothed) */ - if (store_wfa) - copy_wfa (video->wfa_future, tmp_wfa); - if (video->frame) /* discard current frame */ - free_image (video->frame); - video->frame = NULL; - if (video->sframe) /* discard current (smoothed) frame */ - free_image (video->sframe); - video->sframe = NULL; - frame = NULL; - sframe = NULL; - } - else - { - if (video->wfa->wfainfo->B_as_past_ref == YES) - { - if (video->past) /* discard past frame */ - free_image (video->past); - video->past = video->frame; /* past <- current frame */ - video->frame = NULL; - if (video->sframe) /* discard current (smoothed) frame */ - free_image (video->sframe); - video->sframe = NULL; - if (store_wfa) - copy_wfa (video->wfa_past, tmp_wfa); - } - else - { - if (video->frame) /* discard current */ - free_image (video->frame); - video->frame = NULL; - if (video->sframe) /* discard current (smoothed) frame */ - free_image (video->sframe); - video->sframe = NULL; - } - } - } - if (tmp_wfa) - free_wfa (tmp_wfa); - - current_frame_is_future_frame = NO; - /* - * Second step: decode image - * Optionally enlarge image if specified by option 'enlarge_factor'. - */ - { - unsigned orig_width, orig_height; - - stop_timer [0] = stop_timer [1] = stop_timer [2] = 0; - - enlarge_image (enlarge_factor, format, - (video->wfa->wfainfo->color - && format == FORMAT_4_2_0) - ? video->wfa->tree [video->wfa->tree [video->wfa->root_state][0]][0] : -1, video->wfa); - - if (enlarge_factor > 0) - { - orig_width = video->wfa->wfainfo->width << enlarge_factor; - orig_height = video->wfa->wfainfo->height << enlarge_factor; - } - else - { - orig_width = video->wfa->wfainfo->width >> - enlarge_factor; - orig_height = video->wfa->wfainfo->height >> - enlarge_factor; - if (orig_width & 1) - orig_width++; - if (orig_height & 1) - orig_height++; - } - - frame = decode_image (orig_width, orig_height, format, - timer != NULL ? stop_timer : NULL, - video->wfa); - if (timer) - { - timer->preprocessing [video->wfa->frame_type] += stop_timer [0]; - timer->decoder [video->wfa->frame_type] += stop_timer [1]; - timer->cleanup [video->wfa->frame_type] += stop_timer [2]; - } - } - - /* - * Third step: restore motion compensation - */ - if (video->wfa->frame_type != I_FRAME) - { - prg_timer (&ptimer, START); - restore_mc (enlarge_factor, frame, video->past, video->future, - video->wfa); - stop_timer [0] = prg_timer (&ptimer, STOP); - if (timer) - timer->motion [video->wfa->frame_type] += stop_timer [0]; - } - - /* - * Fourth step: smooth image along partitioning borders - */ - prg_timer (&ptimer, START); - if (smoothing < 0) /* smoothing not changed by user */ - smoothing = video->wfa->wfainfo->smoothing; - if (smoothing > 0 && smoothing <= 100) - { - sframe = clone_image (frame); - smooth_image (smoothing, video->wfa, sframe); - } - else - sframe = NULL; - - stop_timer [0] = prg_timer (&ptimer, STOP); - if (timer) - timer->smooth [video->wfa->frame_type] += stop_timer [0]; - - if (frame_number == video->display) - { - video->display++; - video->frame = frame; - video->sframe = sframe; - frame = NULL; - sframe = NULL; - } - else if (frame_number > video->display) - { - video->future_display = frame_number; - current_frame_is_future_frame = YES; - } + /* + * Depending on current frame type update past and future frames + */ + if (video->wfa->frame_type == I_FRAME) + { + if (video->past) /* discard past frame */ + free_image (video->past); + video->past = NULL; + if (video->future) /* discard future frame */ + free_image (video->future); + video->future = NULL; + if (video->sfuture) /* discard (smoothed) future frame */ + free_image (video->sfuture); + video->sfuture = NULL; + if (video->frame) /* discard current frame */ + free_image (video->frame); + video->frame = NULL; + if (video->sframe) /* discard current (smoothed) frame */ + free_image (video->sframe); + video->sframe = NULL; + } + else if (video->wfa->frame_type == P_FRAME) + { + if (video->past) /* discard past frame */ + free_image (video->past); + video->past = video->frame; /* past <- current frame */ + video->frame = NULL; + if (video->sframe) /* discard current (smoothed) frame */ + free_image (video->sframe); + video->sframe = NULL; + if (store_wfa) + copy_wfa (video->wfa_past, tmp_wfa); + if (video->future) /* discard future frame */ + free_image (video->future); + video->future = NULL; + if (video->sfuture) /* discard (smoothed) future frame */ + free_image (video->sfuture); + video->sfuture = NULL; + } + else /* B_FRAME */ + { + if (current_frame_is_future_frame) + { + if (video->future) /* discard future frame */ + free_image (video->future); + video->future = frame; /* future <- current frame */ + if (video->sfuture) /* discard (smoothed) future frame */ + free_image (video->sfuture); + video->sfuture = sframe; /* future <- current (smoothed) */ + if (store_wfa) + copy_wfa (video->wfa_future, tmp_wfa); + if (video->frame) /* discard current frame */ + free_image (video->frame); + video->frame = NULL; + if (video->sframe) /* discard current (smoothed) frame */ + free_image (video->sframe); + video->sframe = NULL; + frame = NULL; + sframe = NULL; + } + else + { + if (video->wfa->wfainfo->B_as_past_ref == YES) + { + if (video->past) /* discard past frame */ + free_image (video->past); + video->past = video->frame; /* past <- current frame */ + video->frame = NULL; + if (video->sframe) /* discard current (smoothed) frame */ + free_image (video->sframe); + video->sframe = NULL; + if (store_wfa) + copy_wfa (video->wfa_past, tmp_wfa); + } + else + { + if (video->frame) /* discard current */ + free_image (video->frame); + video->frame = NULL; + if (video->sframe) /* discard current (smoothed) frame */ + free_image (video->sframe); + video->sframe = NULL; + } + } + } + if (tmp_wfa) + free_wfa (tmp_wfa); + + current_frame_is_future_frame = NO; + /* + * Second step: decode image + * Optionally enlarge image if specified by option 'enlarge_factor'. + */ + { + unsigned orig_width, orig_height; + + stop_timer [0] = stop_timer [1] = stop_timer [2] = 0; + + enlarge_image (enlarge_factor, format, + (video->wfa->wfainfo->color + && format == FORMAT_4_2_0) + ? video->wfa->tree [video->wfa->tree [video->wfa->root_state][0]][0] : -1, video->wfa); + + if (enlarge_factor > 0) + { + orig_width = video->wfa->wfainfo->width << enlarge_factor; + orig_height = video->wfa->wfainfo->height << enlarge_factor; + } + else + { + orig_width = video->wfa->wfainfo->width >> - enlarge_factor; + orig_height = video->wfa->wfainfo->height >> - enlarge_factor; + if (orig_width & 1) + orig_width++; + if (orig_height & 1) + orig_height++; + } + + frame = decode_image (orig_width, orig_height, format, + timer != NULL ? stop_timer : NULL, + video->wfa); + if (timer) + { + timer->preprocessing [video->wfa->frame_type] += stop_timer [0]; + timer->decoder [video->wfa->frame_type] += stop_timer [1]; + timer->cleanup [video->wfa->frame_type] += stop_timer [2]; + } + } + + /* + * Third step: restore motion compensation + */ + if (video->wfa->frame_type != I_FRAME) + { + prg_timer (&ptimer, START); + restore_mc (enlarge_factor, frame, video->past, video->future, + video->wfa); + stop_timer [0] = prg_timer (&ptimer, STOP); + if (timer) + timer->motion [video->wfa->frame_type] += stop_timer [0]; + } + + /* + * Fourth step: smooth image along partitioning borders + */ + prg_timer (&ptimer, START); + if (smoothing < 0) /* smoothing not changed by user */ + smoothing = video->wfa->wfainfo->smoothing; + if (smoothing > 0 && smoothing <= 100) + { + sframe = clone_image (frame); + smooth_image (smoothing, video->wfa, sframe); + } + else + sframe = NULL; + + stop_timer [0] = prg_timer (&ptimer, STOP); + if (timer) + timer->smooth [video->wfa->frame_type] += stop_timer [0]; + + if (frame_number == video->display) + { + video->display++; + video->frame = frame; + video->sframe = sframe; + frame = NULL; + sframe = NULL; + } + else if (frame_number > video->display) + { + video->future_display = frame_number; + current_frame_is_future_frame = YES; + } - if (!store_wfa) - remove_states (video->wfa->basis_states, video->wfa); + if (!store_wfa) + remove_states (video->wfa->basis_states, video->wfa); } while (!video->frame); if (!store_wfa) - video->wfa = NULL; + video->wfa = NULL; } return video->sframe ? video->sframe : video->frame; @@ -414,7 +413,7 @@ get_next_frame (bool_t store_wfa, int enlarge_factor, image_t * decode_image (unsigned orig_width, unsigned orig_height, format_e format, - unsigned *dec_timer, const wfa_t *wfa) + unsigned *dec_timer, const wfa_t *wfa) /* * Compute image which is represented by the given 'wfa'. * 'orig_width'x'orig_height' gives the resolution of the image at @@ -422,20 +421,20 @@ decode_image (unsigned orig_width, unsigned orig_height, format_e format, * If 'dec_timer' is given, accumulate running time statistics. * * Return value: - * pointer to decoded image + * pointer to decoded image * * Side effects: - * '*dectimer' is changed if 'dectimer' != NULL. + * '*dectimer' is changed if 'dectimer' != NULL. */ { - unsigned root_state [3]; /* root of bintree for each band */ - unsigned width, height; /* computed image size */ - image_t *frame; /* regenerated frame */ - word_t **images; /* pointer to array of pointers - to state images */ - u_word_t *offsets; /* pointer to array of state image - offsets */ - unsigned max_level; /* max. level of state with approx. */ + unsigned root_state [3]; /* root of bintree for each band */ + unsigned width, height; /* computed image size */ + image_t *frame; /* regenerated frame */ + word_t **images; /* pointer to array of pointers + to state images */ + u_word_t *offsets; /* pointer to array of state image + offsets */ + unsigned max_level; /* max. level of state with approx. */ unsigned state; clock_t ptimer; @@ -458,16 +457,16 @@ decode_image (unsigned orig_width, unsigned orig_height, format_e format, */ for (max_level = 0, state = wfa->basis_states; state < wfa->states; state++) if (isedge (wfa->into [state][0][0]) || isedge (wfa->into [state][1][0])) - max_level = max (max_level, wfa->level_of_state [state]); + max_level = MAX(max_level, wfa->level_of_state [state]); /* * Allocate frame buffer for decoded image */ compute_actual_size (format == FORMAT_4_2_0 ? root_state [Y] : MAXSTATES, - &width, &height, wfa); - width = max (width, orig_width); - height = max (height, orig_height); + &width, &height, wfa); + width = MAX(width, orig_width); + height = MAX(height, orig_height); frame = alloc_image (width, height, wfa->wfainfo->color, format); /* @@ -480,7 +479,7 @@ decode_image (unsigned orig_width, unsigned orig_height, format_e format, wfa->level_of_state [wfa->tree[wfa->root_state][1]] = 128; } alloc_state_images (&images, &offsets, frame, root_state, 0, max_level, - format, wfa); + format, wfa); if (dec_timer) dec_timer [0] += prg_timer (&ptimer, STOP); @@ -498,38 +497,38 @@ decode_image (unsigned orig_width, unsigned orig_height, format_e format, */ prg_timer (&ptimer, START); free_state_images (max_level, frame->color, images, offsets, root_state, 0, - format, wfa); + format, wfa); /* * Crop decoded image if the image size differs. */ if (orig_width != width || orig_height != height) { - frame->height = orig_height; - frame->width = orig_width; - if (orig_width != width) + frame->height = orig_height; + frame->width = orig_width; + if (orig_width != width) { - color_e band; /* current color band */ - word_t *src, *dst; /* source and destination pointers */ - unsigned y; /* current row */ - - for (band = first_band (frame->color); - band <= last_band (frame->color); band++) - { - src = dst = frame->pixels [band]; - for (y = orig_height; y; y--) - { - memmove (dst, src, orig_width * sizeof (word_t)); - dst += orig_width; - src += width; - } - if (format == FORMAT_4_2_0 && band == Y) - { - orig_width >>= 1; - orig_height >>= 1; - width >>= 1; - } - } + color_e band; /* current color band */ + word_t *src, *dst; /* source and destination pointers */ + unsigned y; /* current row */ + + for (band = first_band (frame->color); + band <= last_band (frame->color); band++) + { + src = dst = frame->pixels [band]; + for (y = orig_height; y; y--) + { + memmove (dst, src, orig_width * sizeof (word_t)); + dst += orig_width; + src += width; + } + if (format == FORMAT_4_2_0 && band == Y) + { + orig_width >>= 1; + orig_height >>= 1; + width >>= 1; + } + } } } if (dec_timer) @@ -544,10 +543,10 @@ decode_state (unsigned state, unsigned level, wfa_t *wfa) * Decode 'state' image of 'wfa' at given 'level'. * * Return value. - * pointer to decoded state image + * pointer to decoded state image * * Side effects: - * 'wfa' states > 'state' are removed. + * 'wfa' states > 'state' are removed. */ { word_t *domains [2]; @@ -571,15 +570,15 @@ decode_state (unsigned state, unsigned level, wfa_t *wfa) */ { word_t *src, *dst; - unsigned y; - + unsigned y; + src = domains [0]; dst = img->pixels [GRAY]; for (y = img->height; y; y--) { - memcpy (dst, src, width_of_level (level) * sizeof (word_t)); - src += width_of_level (level); - dst += img->width; + memcpy (dst, src, width_of_level (level) * sizeof (word_t)); + src += width_of_level (level); + dst += img->width; } Free (domains [0]); } @@ -589,87 +588,87 @@ decode_state (unsigned state, unsigned level, wfa_t *wfa) word_t * decode_range (unsigned range_state, unsigned range_label, unsigned range_level, - word_t **domain, wfa_t *wfa) + word_t **domain, wfa_t *wfa) /* * Compute 'wfa' image of range (identified by 'state' and 'label') * at 'range_level (works as function decode_image()). * * Return value: - * pointer to the pixels in SHORT format + * pointer to the pixels in SHORT format * * Side effects: - * if 'domain' != NULL then also the domain blocks - * of the corresponding range blocks are generated + * if 'domain' != NULL then also the domain blocks + * of the corresponding range blocks are generated * and returned in domain[] - * 'wfa->level_of_state []' is changed + * 'wfa->level_of_state []' is changed */ { - unsigned root_state [3]; /* dummy (for alloc_state_images) */ - image_t *state_image; /* regenerated state image */ - word_t **images; /* pointer to array of pointers - to state images */ - u_word_t *offsets; /* pointer to array of state image - offsets */ + unsigned root_state [3]; /* dummy (for alloc_state_images) */ + image_t *state_image; /* regenerated state image */ + word_t **images; /* pointer to array of pointers + to state images */ + u_word_t *offsets; /* pointer to array of state image + offsets */ word_t *range; enlarge_image (range_level - (wfa->level_of_state [range_state] - 1), - FORMAT_4_4_4, -1, wfa); + FORMAT_4_4_4, -1, wfa); root_state [0] = range_state; state_image = alloc_image (width_of_level (range_level + 1), - height_of_level (range_level + 1), - NO, FORMAT_4_4_4); + height_of_level (range_level + 1), + NO, FORMAT_4_4_4); alloc_state_images (&images, &offsets, state_image, NULL, range_state, - range_level + 1, NO, wfa); + range_level + 1, NO, wfa); compute_state_images (range_level + 1, images, offsets, wfa); range = Calloc (size_of_level (range_level), sizeof (word_t)); - if ((range_level & 1) == 0) /* square image */ + if ((range_level & 1) == 0) /* square image */ { memcpy (range, - images [range_state + (range_level + 1) * wfa->states] - + range_label * size_of_level (range_level), - size_of_level (range_level) * sizeof (word_t)); + images [range_state + (range_level + 1) * wfa->states] + + range_label * size_of_level (range_level), + size_of_level (range_level) * sizeof (word_t)); } - else /* rectangle */ + else /* rectangle */ { word_t *src, *dst; unsigned y; src = images [range_state + (range_level + 1) * wfa->states] - + range_label * width_of_level (range_level); + + range_label * width_of_level (range_level); dst = range; for (y = height_of_level (range_level); y; y--) { - memcpy (dst, src, width_of_level (range_level) * sizeof (word_t)); - dst += width_of_level (range_level); - src += width_of_level (range_level + 1); + memcpy (dst, src, width_of_level (range_level) * sizeof (word_t)); + dst += width_of_level (range_level); + src += width_of_level (range_level + 1); } } - if (domain != NULL) /* copy domain images */ + if (domain != NULL) /* copy domain images */ { - int s; /* domain state */ - unsigned edge; /* counter */ - + int s; /* domain state */ + unsigned edge; /* counter */ + if (ischild (s = wfa->tree [range_state][range_label])) - *domain++ = duplicate_state_image (images [s + (range_level) - * wfa->states], - offsets [s + (range_level) - * wfa->states], - range_level); + *domain++ = duplicate_state_image (images [s + (range_level) + * wfa->states], + offsets [s + (range_level) + * wfa->states], + range_level); for (edge = 0; isedge (s = wfa->into[range_state][range_label][edge]); - edge++) - *domain++ = duplicate_state_image (images [s + (range_level) - * wfa->states], - offsets [s + (range_level) - * wfa->states], - range_level); + edge++) + *domain++ = duplicate_state_image (images [s + (range_level) + * wfa->states], + offsets [s + (range_level) + * wfa->states], + range_level); *domain = NULL; } free_state_images (range_level + 1, NO, images, offsets, NULL, range_state, - NO, wfa); + NO, wfa); free_image (state_image); return range; @@ -684,102 +683,102 @@ smooth_image (unsigned sf, const wfa_t *wfa, image_t *image) * No return value. * * Side effects: - * pixel values of the 'image' are modified with respect to 's' + * pixel values of the 'image' are modified with respect to 's' */ { - int is, inegs; /* integer factors of s and 1 - s*/ - unsigned state; + int is, inegs; /* integer factors of s and 1 - s*/ + unsigned state; unsigned img_width = image->width; unsigned img_height = image->height; - real_t s = 1.0 - sf / 200.0; + real_t s = 1.0 - sf / 200.0; - if (s < 0.5 || s >= 1) /* value out of range */ + if (s < 0.5 || s >= 1) /* value out of range */ return; - is = s * 512 + .5; /* integer representation of s */ - inegs = (1 - s) * 512 + .5; /* integer representation of 1 - s */ + is = s * 512 + .5; /* integer representation of s */ + inegs = (1 - s) * 512 + .5; /* integer representation of 1 - s */ for (state = wfa->basis_states; - state < (wfa->wfainfo->color - ? wfa->tree [wfa->root_state][0] - : wfa->states); state++) + state < (wfa->wfainfo->color + ? wfa->tree [wfa->root_state][0] + : wfa->states); state++) { word_t *bptr = image->pixels [Y]; /* pointer to right or - lower line */ + lower line */ unsigned level = wfa->level_of_state[state]; /* level of state image */ unsigned width = width_of_level (level); /* size of state image */ unsigned height = height_of_level (level); /* size of state image */ if (wfa->y [state][1] >= img_height || wfa->x [state][1] >= img_width) - continue; /* outside visible area */ - - if (level % 2) /* horizontal smoothing */ + continue; /* outside visible area */ + + if (level % 2) /* horizontal smoothing */ { - unsigned i; /* line counter */ - word_t *img1; /* pointer to left or upper line */ - word_t *img2; /* pointer to right or lower line */ - - img1 = bptr + (wfa->y [state][1] - 1) * img_width - + wfa->x [state][1]; - img2 = bptr + wfa->y [state][1] * img_width + wfa->x [state][1]; - - for (i = min (width, img_width - wfa->x [state][1]); i; - i--, img1++, img2++) - { - int tmp = *img1; - + unsigned i; /* line counter */ + word_t *img1; /* pointer to left or upper line */ + word_t *img2; /* pointer to right or lower line */ + + img1 = bptr + (wfa->y [state][1] - 1) * img_width + + wfa->x [state][1]; + img2 = bptr + wfa->y [state][1] * img_width + wfa->x [state][1]; + + for (i = MIN(width, img_width - wfa->x [state][1]); i; + i--, img1++, img2++) + { + int tmp = *img1; + #ifdef HAVE_SIGNED_SHIFT - *img1 = (((is * tmp) >> 10) << 1) - + (((inegs * (int) *img2) >> 10) << 1); - *img2 = (((is * (int) *img2) >> 10) << 1) - + (((inegs * tmp) >> 10) << 1); + *img1 = (((is * tmp) >> 10) << 1) + + (((inegs * (int) *img2) >> 10) << 1); + *img2 = (((is * (int) *img2) >> 10) << 1) + + (((inegs * tmp) >> 10) << 1); #else /* not HAVE_SIGNED_SHIFT */ - *img1 = (((is * tmp) / 1024) * 2) - + (((inegs * (int) *img2) / 1024) * 2); - *img2 = (((is * (int) *img2) / 1024) * 2) - + (((inegs * tmp) / 1024) *2); + *img1 = (((is * tmp) / 1024) * 2) + + (((inegs * (int) *img2) / 1024) * 2); + *img2 = (((is * (int) *img2) / 1024) * 2) + + (((inegs * tmp) / 1024) *2); #endif /* not HAVE_SIGNED_SHIFT */ - } + } } - else /* vertical smoothing */ + else /* vertical smoothing */ { - unsigned i; /* line counter */ - word_t *img1; /* pointer to left or upper line */ - word_t *img2; /* pointer to right or lower line */ - - img1 = bptr + wfa->y [state][1] * img_width + wfa->x [state][1] - 1; - img2 = bptr + wfa->y [state][1] * img_width + wfa->x [state][1]; - - for (i = min (height, img_height - wfa->y [state][1]); i; - i--, img1 += img_width, img2 += img_width) - { - int tmp = *img1; - + unsigned i; /* line counter */ + word_t *img1; /* pointer to left or upper line */ + word_t *img2; /* pointer to right or lower line */ + + img1 = bptr + wfa->y [state][1] * img_width + wfa->x [state][1] - 1; + img2 = bptr + wfa->y [state][1] * img_width + wfa->x [state][1]; + + for (i = MIN(height, img_height - wfa->y [state][1]); i; + i--, img1 += img_width, img2 += img_width) + { + int tmp = *img1; + #ifdef HAVE_SIGNED_SHIFT - *img1 = (((is * tmp) >> 10) << 1) - + (((inegs * (int) *img2) >> 10) << 1); - *img2 = (((is * (int) *img2) >> 10) << 1) - + (((inegs * tmp) >> 10) << 1); + *img1 = (((is * tmp) >> 10) << 1) + + (((inegs * (int) *img2) >> 10) << 1); + *img2 = (((is * (int) *img2) >> 10) << 1) + + (((inegs * tmp) >> 10) << 1); #else /* not HAVE_SIGNED_SHIFT */ - *img1 = (((is * tmp) / 1024) * 2) - + (((inegs * (int) *img2) / 1024) * 2); - *img2 = (((is * (int) *img2) / 1024) * 2) - + (((inegs * tmp) / 1024) *2); + *img1 = (((is * tmp) / 1024) * 2) + + (((inegs * (int) *img2) / 1024) * 2); + *img2 = (((is * (int) *img2) / 1024) * 2) + + (((inegs * tmp) / 1024) *2); #endif /* not HAVE_SIGNED_SHIFT */ - } + } } } } /***************************************************************************** - private code + private code *****************************************************************************/ static void enlarge_image (int enlarge_factor, format_e format, unsigned y_root, - wfa_t *wfa) + wfa_t *wfa) /* * Enlarge or reduce size of state images by factor 2^'enlarge_factor'. * Use 4:2:0 subsampling if specified by 'format', else use 4:4:4 format. @@ -788,8 +787,8 @@ enlarge_image (int enlarge_factor, format_e format, unsigned y_root, * No return value. * * Side effects: - * coordinates of ranges and motion blocks in the WFA structure 'wfa' - * are modified. + * coordinates of ranges and motion blocks in the WFA structure 'wfa' + * are modified. */ { @@ -799,53 +798,53 @@ enlarge_image (int enlarge_factor, format_e format, unsigned y_root, if (enlarge_factor == 0) { - state = y_root + 1; - enlarge_factor = -1; + state = y_root + 1; + enlarge_factor = -1; } else - state = wfa->basis_states; + state = wfa->basis_states; for (; state < wfa->states; state++) { - unsigned label, n; - - wfa->level_of_state [state] - = max (wfa->level_of_state [state] + enlarge_factor * 2, 0); - - for (label = 0; label < MAXLABELS; label++) - if (enlarge_factor > 0) - { - wfa->x [state][label] <<= enlarge_factor; - wfa->y [state][label] <<= enlarge_factor; - for (n = enlarge_factor; n; n--) - { - wfa->mv_tree [state][label].fx *= 2; - wfa->mv_tree [state][label].fy *= 2; - wfa->mv_tree [state][label].bx *= 2; - wfa->mv_tree [state][label].by *= 2; - } - } - else /* enlarge_factor < 0 */ - { - wfa->x [state][label] >>= - enlarge_factor; - wfa->y [state][label] >>= - enlarge_factor; - for (n = - enlarge_factor; n; n--) - { - wfa->mv_tree [state][label].fx /= 2; - wfa->mv_tree [state][label].fy /= 2; - wfa->mv_tree [state][label].bx /= 2; - wfa->mv_tree [state][label].by /= 2; - } - } - if (format == FORMAT_4_2_0 && state == y_root) - enlarge_factor--; + unsigned label, n; + + wfa->level_of_state [state] + = MAX(wfa->level_of_state [state] + enlarge_factor * 2, 0); + + for (label = 0; label < MAXLABELS; label++) + if (enlarge_factor > 0) + { + wfa->x [state][label] <<= enlarge_factor; + wfa->y [state][label] <<= enlarge_factor; + for (n = enlarge_factor; n; n--) + { + wfa->mv_tree [state][label].fx *= 2; + wfa->mv_tree [state][label].fy *= 2; + wfa->mv_tree [state][label].bx *= 2; + wfa->mv_tree [state][label].by *= 2; + } + } + else /* enlarge_factor < 0 */ + { + wfa->x [state][label] >>= - enlarge_factor; + wfa->y [state][label] >>= - enlarge_factor; + for (n = - enlarge_factor; n; n--) + { + wfa->mv_tree [state][label].fx /= 2; + wfa->mv_tree [state][label].fy /= 2; + wfa->mv_tree [state][label].bx /= 2; + wfa->mv_tree [state][label].by /= 2; + } + } + if (format == FORMAT_4_2_0 && state == y_root) + enlarge_factor--; } } } static void compute_actual_size (unsigned luminance_root, - unsigned *width, unsigned *height, const wfa_t *wfa) + unsigned *width, unsigned *height, const wfa_t *wfa) /* * Compute actual size of the frame represented by the given 'wfa'. * (The reconstructed frame may get larger than the original due @@ -853,24 +852,24 @@ compute_actual_size (unsigned luminance_root, * If 'luminance_root' < MAXSTATES then the size of chroma ranges (4:2:0). * * Return values: - * actual 'width' and 'height' of the decoded frame. + * actual 'width' and 'height' of the decoded frame. */ { - unsigned x = 0, y = 0; /* maximum coordinates */ - unsigned state; /* counter */ + unsigned x = 0, y = 0; /* maximum coordinates */ + unsigned state; /* counter */ for (state = wfa->basis_states; state < wfa->states; state++) if (isedge (wfa->into [state][0][0]) || isedge (wfa->into [state][1][0])) { - unsigned mult = state > luminance_root ? 2 : 1; - - x = max ((wfa->x [state][0] - + width_of_level (wfa->level_of_state [state])) * mult, x); - y = max ((wfa->y [state][0] - + height_of_level (wfa->level_of_state [state])) * mult, y); + unsigned mult = state > luminance_root ? 2 : 1; + + x = MAX((wfa->x [state][0] + + width_of_level (wfa->level_of_state [state])) * mult, x); + y = MAX((wfa->y [state][0] + + height_of_level (wfa->level_of_state [state])) * mult, y); } - if (x & 1) /* ensure that image size is even */ + if (x & 1) /* ensure that image size is even */ x++; if (y & 1) y++; @@ -880,8 +879,8 @@ compute_actual_size (unsigned luminance_root, static void alloc_state_images (word_t ***images, u_word_t **offsets, const image_t *frame, - const unsigned *root_state, unsigned range_state, - unsigned max_level, format_e format, const wfa_t *wfa) + const unsigned *root_state, unsigned range_state, + unsigned max_level, format_e format, const wfa_t *wfa) /* * Generate list of 'wfa' state images which have to be computed for * each level to obtain the decoded 'frame'. 'root_state[]' denotes the @@ -893,24 +892,24 @@ alloc_state_images (word_t ***images, u_word_t **offsets, const image_t *frame, * image of 'wfa->root_state'. * * Return values: - * '*images' Pointer to array of state image pointers - * '*offsets' Pointer to array of state image offsets. + * '*images' Pointer to array of state image pointers + * '*offsets' Pointer to array of state image offsets. * * Side effects: - * The arrays given above are filled with useful values. + * The arrays given above are filled with useful values. */ { - word_t **simg; /* ptr to list of state image ptr's */ - u_word_t *offs; /* ptr to list of offsets */ - unsigned level; /* counter */ + word_t **simg; /* ptr to list of state image ptr's */ + u_word_t *offs; /* ptr to list of offsets */ + unsigned level; /* counter */ - simg = Calloc (wfa->states * (max_level + 1), sizeof (word_t *)); - offs = Calloc (wfa->states * (max_level + 1), sizeof (u_word_t)); + simg = Calloc (wfa->states * (max_level + 1), sizeof (word_t *)); + offs = Calloc (wfa->states * (max_level + 1), sizeof (u_word_t)); /* * Initialize buffers for those state images which are at 'max_level'. */ - if (range_state > 0) /* a range is given */ + if (range_state > 0) /* a range is given */ { simg [range_state + max_level * wfa->states] = frame->pixels [GRAY]; offs [range_state + max_level * wfa->states] = frame->width; @@ -920,25 +919,25 @@ alloc_state_images (word_t ***images, u_word_t **offsets, const image_t *frame, unsigned state; for (state = wfa->basis_states; state <= root_state [Y]; state++) - if (wfa->level_of_state [state] == max_level) - { - simg [state + max_level * wfa->states] - = (frame->pixels [Y] + wfa->y [state][0] * frame->width - + wfa->x [state][0]); - offs [state + max_level * wfa->states] = frame->width; - } + if (wfa->level_of_state [state] == max_level) + { + simg [state + max_level * wfa->states] + = (frame->pixels [Y] + wfa->y [state][0] * frame->width + + wfa->x [state][0]); + offs [state + max_level * wfa->states] = frame->width; + } if (frame->color) { - unsigned width = format == FORMAT_4_2_0 ? - (frame->width >> 1) : frame->width; - for (; state < wfa->states; state++) - if (wfa->level_of_state [state] == max_level) - { - simg [state + max_level * wfa->states] - = (frame->pixels [state > root_state [Cb] ? Cr : Cb] - + wfa->y [state][0] * width + wfa->x [state][0]); - offs [state + max_level * wfa->states] = width; - } + unsigned width = format == FORMAT_4_2_0 ? + (frame->width >> 1) : frame->width; + for (; state < wfa->states; state++) + if (wfa->level_of_state [state] == max_level) + { + simg [state + max_level * wfa->states] + = (frame->pixels [state > root_state [Cb] ? Cr : Cb] + + wfa->y [state][0] * width + wfa->x [state][0]); + offs [state + max_level * wfa->states] = width; + } } } @@ -954,63 +953,63 @@ alloc_state_images (word_t ***images, u_word_t **offsets, const image_t *frame, * Range approximation with child. */ for (state = 1; state < (range_state > 0 ? - range_state + 1 : wfa->states); state++) - if (simg [state + level * wfa->states]) - for (label = 0; label < MAXLABELS; label++) - if (ischild (child = wfa->tree[state][label])) - { - if (isedge (wfa->into[state][label][0])) - { - /* - * Allocate new image block. - */ - simg [child + (level - 1) * wfa->states] - = Calloc (size_of_level (level - 1), sizeof (word_t)); - offs [child + (level - 1) * wfa->states] - = width_of_level (level - 1); - } - else - { - /* - * Use image block and offset of parent. - */ - if (level & 1) /* split vertically */ - { - simg [child + (level - 1) * wfa->states] - = (simg [state + level * wfa->states] - + label * (height_of_level (level - 1) - * offs [state - + level * wfa->states])); - } - else /* split horizontally */ - { - simg [child + (level - 1) * wfa->states] - = (simg [state + level * wfa->states] - + label * width_of_level (level - 1)); - } - offs [child + (level - 1) * wfa->states] - = offs [state + level * wfa->states]; - } - } + range_state + 1 : wfa->states); state++) + if (simg [state + level * wfa->states]) + for (label = 0; label < MAXLABELS; label++) + if (ischild (child = wfa->tree[state][label])) + { + if (isedge (wfa->into[state][label][0])) + { + /* + * Allocate new image block. + */ + simg [child + (level - 1) * wfa->states] + = Calloc (size_of_level (level - 1), sizeof (word_t)); + offs [child + (level - 1) * wfa->states] + = width_of_level (level - 1); + } + else + { + /* + * Use image block and offset of parent. + */ + if (level & 1) /* split vertically */ + { + simg [child + (level - 1) * wfa->states] + = (simg [state + level * wfa->states] + + label * (height_of_level (level - 1) + * offs [state + + level * wfa->states])); + } + else /* split horizontally */ + { + simg [child + (level - 1) * wfa->states] + = (simg [state + level * wfa->states] + + label * width_of_level (level - 1)); + } + offs [child + (level - 1) * wfa->states] + = offs [state + level * wfa->states]; + } + } /* * Range approximation with linear combination */ for (state = 1; state < (range_state > 0 ? - range_state + 1 : wfa->states); state++) - if (simg [state + level * wfa->states]) - for (label = 0; label < MAXLABELS; label++) - for (edge = 0; isedge (domain = wfa->into[state][label][edge]); - edge++) - { - if (domain > 0 /* don't allocate memory for state 0 */ - && !simg [domain + (level - 1) * wfa->states]) - { - simg [domain + (level - 1) * wfa->states] - = Calloc (size_of_level (level - 1), sizeof (word_t)); - offs [domain + (level - 1) * wfa->states] - = width_of_level (level - 1); - } - } + range_state + 1 : wfa->states); state++) + if (simg [state + level * wfa->states]) + for (label = 0; label < MAXLABELS; label++) + for (edge = 0; isedge (domain = wfa->into[state][label][edge]); + edge++) + { + if (domain > 0 /* don't allocate memory for state 0 */ + && !simg [domain + (level - 1) * wfa->states]) + { + simg [domain + (level - 1) * wfa->states] + = Calloc (size_of_level (level - 1), sizeof (word_t)); + offs [domain + (level - 1) * wfa->states] + = width_of_level (level - 1); + } + } } @@ -1020,8 +1019,8 @@ alloc_state_images (word_t ***images, u_word_t **offsets, const image_t *frame, static void free_state_images (unsigned max_level, bool_t color, word_t **state_image, - u_word_t *offset, const unsigned *root_state, - unsigned range_state, format_e format, const wfa_t *wfa) + u_word_t *offset, const unsigned *root_state, + unsigned range_state, format_e format, const wfa_t *wfa) /* * Free memory of state images. * For more details refer to the inverse function 'alloc_state_images()'. @@ -1029,10 +1028,10 @@ free_state_images (unsigned max_level, bool_t color, word_t **state_image, * No return value. * * Side effects: - * arrays 'state_image' and 'offset' are discarded. + * arrays 'state_image' and 'offset' are discarded. */ { - word_t marker; /* ptr is required as a marker */ + word_t marker; /* ptr is required as a marker */ unsigned level; if (range_state > 0) @@ -1047,19 +1046,19 @@ free_state_images (unsigned max_level, bool_t color, word_t **state_image, * Initialize state image array with states at 'max_level' */ for (state = wfa->basis_states; state <= root_state [Y]; state++) - if (wfa->level_of_state [state] == max_level) - state_image [state + max_level * wfa->states] = ▮ + if (wfa->level_of_state [state] == max_level) + state_image [state + max_level * wfa->states] = ▮ if (color) { - if (format == FORMAT_4_2_0) - level = max_level - 2; - else - level = max_level; + if (format == FORMAT_4_2_0) + level = max_level - 2; + else + level = max_level; - for (; state < wfa->states; state++) - if (wfa->level_of_state [state] == level) - state_image [state + level * wfa->states] = ▮ + for (; state < wfa->states; state++) + if (wfa->level_of_state [state] == level) + state_image [state + level * wfa->states] = ▮ } } @@ -1071,37 +1070,37 @@ free_state_images (unsigned max_level, bool_t color, word_t **state_image, * Range approximation with child. */ for (state = 1; state < (range_state > 0 ? - range_state + 1 : wfa->states); state++) - if (state_image [state + level * wfa->states]) - for (label = 0; label < MAXLABELS; label++) - if (ischild (child = wfa->tree[state][label])) - { - if (isedge (wfa->into[state][label][0]) - && (state_image [child + (level - 1) * wfa->states] - != &marker)) - Free (state_image [child + (level - 1) * wfa->states]); - state_image [child + (level - 1) * wfa->states] = ▮ - } + range_state + 1 : wfa->states); state++) + if (state_image [state + level * wfa->states]) + for (label = 0; label < MAXLABELS; label++) + if (ischild (child = wfa->tree[state][label])) + { + if (isedge (wfa->into[state][label][0]) + && (state_image [child + (level - 1) * wfa->states] + != &marker)) + Free (state_image [child + (level - 1) * wfa->states]); + state_image [child + (level - 1) * wfa->states] = ▮ + } /* * Range approximation with linear combination */ for (state = 1; state < (range_state > 0 ? - range_state + 1 : wfa->states); - state++) - if (state_image [state + level * wfa->states]) - for (label = 0; label < MAXLABELS; label++) - for (edge = 0; isedge (domain = wfa->into[state][label][edge]); - edge++) - if (domain > 0 - && (state_image [domain + (level - 1) * wfa->states] - != NULL) - && (state_image [domain + (level - 1) * wfa->states] - != &marker)) - { - Free (state_image [domain + (level - 1) * wfa->states]); - state_image [domain + (level - 1) * wfa->states] - = ▮ - } + range_state + 1 : wfa->states); + state++) + if (state_image [state + level * wfa->states]) + for (label = 0; label < MAXLABELS; label++) + for (edge = 0; isedge (domain = wfa->into[state][label][edge]); + edge++) + if (domain > 0 + && (state_image [domain + (level - 1) * wfa->states] + != NULL) + && (state_image [domain + (level - 1) * wfa->states] + != &marker)) + { + Free (state_image [domain + (level - 1) * wfa->states]); + state_image [domain + (level - 1) * wfa->states] + = ▮ + } } Free (state_image); Free (offset); @@ -1109,7 +1108,7 @@ free_state_images (unsigned max_level, bool_t color, word_t **state_image, static void compute_state_images (unsigned max_level, word_t **simg, - const u_word_t *offset, const wfa_t *wfa) + const u_word_t *offset, const wfa_t *wfa) /* * Compute all state images of the 'wfa' at level {1, ... , 'max_level'} * which are marked in the array 'simg' (offsets of state images @@ -1121,8 +1120,8 @@ compute_state_images (unsigned max_level, word_t **simg, * No return value. * * Side effects: - * state images (given by pointers in the array 'state_image') - * are computed. + * state images (given by pointers in the array 'state_image') + * are computed. */ { unsigned level, state; @@ -1132,8 +1131,8 @@ compute_state_images (unsigned max_level, word_t **simg, */ for (state = 1; state < wfa->states; state++) - if (simg [state] != NULL) /* compute image at level 0 */ - *simg [state] = (int) (wfa->final_distribution[state] * 8 + .5) * 2; + if (simg [state] != NULL) /* compute image at level 0 */ + *simg [state] = (int) (wfa->final_distribution[state] * 8 + .5) * 2; /* * Compute images of states @@ -1153,351 +1152,351 @@ compute_state_images (unsigned max_level, word_t **simg, unsigned height = height_of_level (level - 1); for (state = 1; state < wfa->states; state++) - if (simg [state + level * wfa->states] != NULL) - for (label = 0; label < MAXLABELS; label++) - if (isedge (wfa->into [state][label][0])) - { - unsigned edge; - int domain; - word_t *range; /* address of current range */ - bool_t prediction_used; /* ND prediction found ? */ - - /* - * Compute address of range image - */ - if (level & 1) /* split vertically */ - { - range = simg [state + level * wfa->states] - + label * (height_of_level (level - 1) - * offset [state - + level * wfa->states]); - } - else /* split horizontally */ - { - range = simg [state + level * wfa->states] - + label * width_of_level (level - 1); - } - - /* - * Generate the state images by adding the corresponding - * weighted state images: - * subimage [label] = - * weight_1 * image_1 + ... + weight_n * image_n - */ - if (!ischild (domain = wfa->tree[state][label])) - prediction_used = NO; - else - { - unsigned y; - word_t *src; - word_t *dst; - unsigned src_offset; - unsigned dst_offset; - - prediction_used = YES; - /* - * Copy child image - */ - src = simg [domain + (level - 1) * wfa->states]; - src_offset = offset [domain + (level - 1) * wfa->states] ; - dst = range; - dst_offset = offset [state + level * wfa->states]; - for (y = height; y; y--) - { - memcpy (dst, src, width * sizeof (word_t)); - src += src_offset; - dst += dst_offset; - } - } - - if (!prediction_used - && isedge (domain = wfa->into[state][label][0])) - { - /* - * If prediction is not used then the range is - * filled with the first domain. No addition is needed. - */ - edge = 0; - if (domain != 0) - { - int weight; - word_t *src; - unsigned src_offset; - - src = simg [domain + ((level - 1) - * wfa->states)]; - src_offset = offset [domain + ((level - 1) - * wfa->states)] - width; - weight = wfa->int_weight [state][label][edge]; - - if (width == 1) /* can't add two-pixels in a row */ - { - word_t *dst; - unsigned dst_offset; - - dst = range; - dst_offset = offset [state + level * wfa->states] - - width; + if (simg [state + level * wfa->states] != NULL) + for (label = 0; label < MAXLABELS; label++) + if (isedge (wfa->into [state][label][0])) + { + unsigned edge; + int domain; + word_t *range; /* address of current range */ + bool_t prediction_used; /* ND prediction found ? */ + + /* + * Compute address of range image + */ + if (level & 1) /* split vertically */ + { + range = simg [state + level * wfa->states] + + label * (height_of_level (level - 1) + * offset [state + + level * wfa->states]); + } + else /* split horizontally */ + { + range = simg [state + level * wfa->states] + + label * width_of_level (level - 1); + } + + /* + * Generate the state images by adding the corresponding + * weighted state images: + * subimage [label] = + * weight_1 * image_1 + ... + weight_n * image_n + */ + if (!ischild (domain = wfa->tree[state][label])) + prediction_used = NO; + else + { + unsigned y; + word_t *src; + word_t *dst; + unsigned src_offset; + unsigned dst_offset; + + prediction_used = YES; + /* + * Copy child image + */ + src = simg [domain + (level - 1) * wfa->states]; + src_offset = offset [domain + (level - 1) * wfa->states] ; + dst = range; + dst_offset = offset [state + level * wfa->states]; + for (y = height; y; y--) + { + memcpy (dst, src, width * sizeof (word_t)); + src += src_offset; + dst += dst_offset; + } + } + + if (!prediction_used + && isedge (domain = wfa->into[state][label][0])) + { + /* + * If prediction is not used then the range is + * filled with the first domain. No addition is needed. + */ + edge = 0; + if (domain != 0) + { + int weight; + word_t *src; + unsigned src_offset; + + src = simg [domain + ((level - 1) + * wfa->states)]; + src_offset = offset [domain + ((level - 1) + * wfa->states)] - width; + weight = wfa->int_weight [state][label][edge]; + + if (width == 1) /* can't add two-pixels in a row */ + { + word_t *dst; + unsigned dst_offset; + + dst = range; + dst_offset = offset [state + level * wfa->states] + - width; #ifdef HAVE_SIGNED_SHIFT - *dst++ = ((weight * (int) *src++) >> 10) << 1; -#else /* not HAVE_SIGNED_SHIFT */ - *dst++ = ((weight * (int) *src++) / 1024) * 2; + *dst++ = ((weight * (int) *src++) >> 10) << 1; +#else /* not HAVE_SIGNED_SHIFT */ + *dst++ = ((weight * (int) *src++) / 1024) * 2; #endif /* not HAVE_SIGNED_SHIFT */ - if (height == 2) - { - src += src_offset; - dst += dst_offset; + if (height == 2) + { + src += src_offset; + dst += dst_offset; #ifdef HAVE_SIGNED_SHIFT - *dst++ = ((weight * (int) *src++) >> 10) << 1; + *dst++ = ((weight * (int) *src++) >> 10) << 1; #else /* not HAVE_SIGNED_SHIFT */ - *dst++ = ((weight * (int) *src++) / 1024) * 2; + *dst++ = ((weight * (int) *src++) / 1024) * 2; #endif /* not HAVE_SIGNED_SHIFT */ - } - } - else - { - unsigned y; - int *idst; - unsigned idst_offset; - - idst = (int *) range; - idst_offset = (offset [state + level * wfa->states] - - width) / 2; - for (y = height; y; y--) - { - int *comp_dst = idst + (width >> 1); - - for (; idst != comp_dst; ) - { - int tmp; /* temp. value of adjacent pixels */ + } + } + else + { + unsigned y; + int *idst; + unsigned idst_offset; + + idst = (int *) range; + idst_offset = (offset [state + level * wfa->states] + - width) / 2; + for (y = height; y; y--) + { + int *comp_dst = idst + (width >> 1); + + for (; idst != comp_dst; ) + { + int tmp; /* temp. value of adjacent pixels */ #ifdef HAVE_SIGNED_SHIFT -# if BYTE_ORDER == LITTLE_ENDIAN - tmp = (((weight * (int) src [1]) >> 10) << 17) - | (((weight * (int) src [0]) >> 9) - & 0xfffe); -# else - tmp = (((weight * (int) src [0]) >> 10) << 17) - | (((weight * (int) src [1]) >> 9) - & 0xfffe); -# endif +# if BYTE_ORDER == LITTLE_ENDIAN + tmp = (((weight * (int) src [1]) >> 10) << 17) + | (((weight * (int) src [0]) >> 9) + & 0xfffe); +# else + tmp = (((weight * (int) src [0]) >> 10) << 17) + | (((weight * (int) src [1]) >> 9) + & 0xfffe); +# endif #else /* not HAVE_SIGNED_SHIFT */ -# if BYTE_ORDER == LITTLE_ENDIAN - tmp = (((weight * (int) src [1]) / 1024) - * 131072) - | (((weight * (int) src [0])/ 512) - & 0xfffe); -# else - tmp = (((weight * (int) src [0]) / 1024) - * 131072) - | (((weight * (int) src [1]) / 512) - & 0xfffe); -# endif /* not WORDS_BIGENDIAN */ -#endif - src += 2; - *idst++ = tmp & 0xfffefffe; - } - src += src_offset; - idst += idst_offset; - } - } - } - else - { - int weight = (int) (wfa->weight[state][label][edge] - * wfa->final_distribution[0] - * 8 + .5) * 2; - /* - * Range needs domain 0 - * (the constant function f(x, y) = 1), - * hence a faster algorithm is used. - */ - if (width == 1) /* can't add two-pixels in a row */ - { - word_t *dst; - unsigned dst_offset; - - dst = range; - dst_offset = offset [state + level * wfa->states] - - width; - - *dst++ = weight; - if (height == 2) - { - dst += dst_offset; - *dst++ = weight; - } - } - else - { - unsigned x, y; - int *idst; - unsigned idst_offset; - - weight = (weight * 65536) | (weight & 0xffff); - idst = (int *) range; - idst_offset = offset [state + level * wfa->states] - / 2; - for (x = width >> 1; x; x--) - *idst++ = weight & 0xfffefffe; - idst += (offset [state + level * wfa->states] - - width) / 2; - - for (y = height - 1; y; y--) - { - memcpy (idst, idst - idst_offset, - width * sizeof (word_t)); - idst += idst_offset; - } - } - } - edge = 1; - } - else - edge = 0; - - /* - * Add remaining weighted domain images to current range - */ - for (; isedge (domain = wfa->into[state][label][edge]); - edge++) - { - if (domain != 0) - { - word_t *src; - unsigned src_offset; - int weight; - - src = simg [domain + (level - 1) * wfa->states]; - src_offset = offset [domain + ((level - 1) - * wfa->states)] - width; - weight = wfa->int_weight [state][label][edge]; - - if (width == 1) /* can't add two-pixels in a row */ - { - word_t *dst; - unsigned dst_offset; - - dst = range; - dst_offset = offset [state + level * wfa->states] - - width; +# if BYTE_ORDER == LITTLE_ENDIAN + tmp = (((weight * (int) src [1]) / 1024) + * 131072) + | (((weight * (int) src [0])/ 512) + & 0xfffe); +# else + tmp = (((weight * (int) src [0]) / 1024) + * 131072) + | (((weight * (int) src [1]) / 512) + & 0xfffe); +# endif +#endif /* not HAVE_SIGNED_SHIFT */ + src += 2; + *idst++ = tmp & 0xfffefffe; + } + src += src_offset; + idst += idst_offset; + } + } + } + else + { + int weight = (int) (wfa->weight[state][label][edge] + * wfa->final_distribution[0] + * 8 + .5) * 2; + /* + * Range needs domain 0 + * (the constant function f(x, y) = 1), + * hence a faster algorithm is used. + */ + if (width == 1) /* can't add two-pixels in a row */ + { + word_t *dst; + unsigned dst_offset; + + dst = range; + dst_offset = offset [state + level * wfa->states] + - width; + + *dst++ = weight; + if (height == 2) + { + dst += dst_offset; + *dst++ = weight; + } + } + else + { + unsigned x, y; + int *idst; + unsigned idst_offset; + + weight = (weight * 65536) | (weight & 0xffff); + idst = (int *) range; + idst_offset = offset [state + level * wfa->states] + / 2; + for (x = width >> 1; x; x--) + *idst++ = weight & 0xfffefffe; + idst += (offset [state + level * wfa->states] + - width) / 2; + + for (y = height - 1; y; y--) + { + memcpy (idst, idst - idst_offset, + width * sizeof (word_t)); + idst += idst_offset; + } + } + } + edge = 1; + } + else + edge = 0; + + /* + * Add remaining weighted domain images to current range + */ + for (; isedge (domain = wfa->into[state][label][edge]); + edge++) + { + if (domain != 0) + { + word_t *src; + unsigned src_offset; + int weight; + + src = simg [domain + (level - 1) * wfa->states]; + src_offset = offset [domain + ((level - 1) + * wfa->states)] - width; + weight = wfa->int_weight [state][label][edge]; + + if (width == 1) /* can't add two-pixels in a row */ + { + word_t *dst; + unsigned dst_offset; + + dst = range; + dst_offset = offset [state + level * wfa->states] + - width; #ifdef HAVE_SIGNED_SHIFT - *dst++ += ((weight * (int) *src++) >> 10) << 1; + *dst++ += ((weight * (int) *src++) >> 10) << 1; #else /* not HAVE_SIGNED_SHIFT */ - *dst++ += ((weight * (int) *src++) / 1024) * 2; + *dst++ += ((weight * (int) *src++) / 1024) * 2; #endif /* not HAVE_SIGNED_SHIFT */ - if (height == 2) - { - src += src_offset; - dst += dst_offset; + if (height == 2) + { + src += src_offset; + dst += dst_offset; #ifdef HAVE_SIGNED_SHIFT - *dst++ += ((weight * (int) *src++) >> 10) << 1; + *dst++ += ((weight * (int) *src++) >> 10) << 1; #else /* not HAVE_SIGNED_SHIFT */ - *dst++ += ((weight * (int) *src++) / 1024) * 2; + *dst++ += ((weight * (int) *src++) / 1024) * 2; #endif /* not HAVE_SIGNED_SHIFT */ - } - } - else - { - int *idst; - unsigned idst_offset; - unsigned y; - - idst = (int *) range; - idst_offset = (offset [state + level * wfa->states] - - width) / 2; - - for (y = height; y; y--) - { - int *comp_dst = idst + (width >> 1); - - for (; idst != comp_dst;) - { - int tmp; /* temp. value of adjacent pixels */ + } + } + else + { + int *idst; + unsigned idst_offset; + unsigned y; + + idst = (int *) range; + idst_offset = (offset [state + level * wfa->states] + - width) / 2; + + for (y = height; y; y--) + { + int *comp_dst = idst + (width >> 1); + + for (; idst != comp_dst;) + { + int tmp; /* temp. value of adjacent pixels */ #ifdef HAVE_SIGNED_SHIFT -# if BYTE_ORDER == LITTLE_ENDIAN - tmp = (((weight * (int) src [1]) >> 10) << 17) - | (((weight * (int) src [0]) >> 9) - & 0xfffe); -# else - tmp = (((weight * (int)src [0]) >> 10) << 17) - | (((weight * (int)src [1]) >> 9) - & 0xfffe); -# endif +# if BYTE_ORDER == LITTLE_ENDIAN + tmp = (((weight * (int) src [1]) >> 10) << 17) + | (((weight * (int) src [0]) >> 9) + & 0xfffe); +# else + tmp = (((weight * (int)src [0]) >> 10) << 17) + | (((weight * (int)src [1]) >> 9) + & 0xfffe); +# endif #else /* not HAVE_SIGNED_SHIFT */ -# if BYTE_ORDER == LITTLE_ENDIAN - tmp = (((weight * (int) src [1]) / 1024) - * 131072) - | (((weight * (int) src [0])/ 512) - & 0xfffe); -# else - tmp = (((weight * (int) src [0]) / 1024) - * 131072) - | (((weight * (int) src [1])/ 512) - & 0xfffe); -# endif /* not WORDS_BIGENDIAN */ -#endif - src += 2; - *idst = (*idst + tmp) & 0xfffefffe; - idst++; - } - src += src_offset; - idst += idst_offset; - } - } - } - else - { - int weight = (int) (wfa->weight[state][label][edge] - * wfa->final_distribution[0] - * 8 + .5) * 2; - /* - * Range needs domain 0 - * (the constant function f(x, y) = 1), - * hence a faster algorithm is used. - */ - if (width == 1) /* can't add two-pixels in a row */ - { - word_t *dst; - unsigned dst_offset; - - dst = range; - dst_offset = offset [state + level * wfa->states] - - width; - - *dst++ += weight; - if (height == 2) - { - dst += dst_offset; - *dst++ += weight; - } - } - else - { - int *idst; - unsigned idst_offset; - unsigned y; - - weight = (weight * 65536) | (weight & 0xffff); - idst = (int *) range; - idst_offset = (offset [state + level * wfa->states] - - width) /2; - - for (y = height; y; y--) - { - int *comp_dst = idst + (width >> 1); - - for (; idst != comp_dst; ) - { - *idst = (*idst + weight) & 0xfffefffe; +# if BYTE_ORDER == LITTLE_ENDIAN + tmp = (((weight * (int) src [1]) / 1024) + * 131072) + | (((weight * (int) src [0])/ 512) + & 0xfffe); +# else + tmp = (((weight * (int) src [0]) / 1024) + * 131072) + | (((weight * (int) src [1])/ 512) + & 0xfffe); +# endif +#endif /* not HAVE_SIGNED_SHIFT */ + src += 2; + *idst = (*idst + tmp) & 0xfffefffe; + idst++; + } + src += src_offset; + idst += idst_offset; + } + } + } + else + { + int weight = (int) (wfa->weight[state][label][edge] + * wfa->final_distribution[0] + * 8 + .5) * 2; + /* + * Range needs domain 0 + * (the constant function f(x, y) = 1), + * hence a faster algorithm is used. + */ + if (width == 1) /* can't add two-pixels in a row */ + { + word_t *dst; + unsigned dst_offset; + + dst = range; + dst_offset = offset [state + level * wfa->states] + - width; + + *dst++ += weight; + if (height == 2) + { + dst += dst_offset; + *dst++ += weight; + } + } + else + { + int *idst; + unsigned idst_offset; + unsigned y; + + weight = (weight * 65536) | (weight & 0xffff); + idst = (int *) range; + idst_offset = (offset [state + level * wfa->states] + - width) /2; + + for (y = height; y; y--) + { + int *comp_dst = idst + (width >> 1); + + for (; idst != comp_dst; ) + { + *idst = (*idst + weight) & 0xfffefffe; idst++; - } - idst += idst_offset; - } - } - } - } - } + } + idst += idst_offset; + } + } + } + } + } } } @@ -1509,24 +1508,24 @@ duplicate_state_image (const word_t *domain, unsigned offset, unsigned level) * to the lock 'pixels'. * * Return value: - * pointer to the new domain block + * pointer to the new domain block */ { word_t *dst, *pixels; - int y, n; + int y, n; dst = pixels = Calloc (size_of_level (level), sizeof (word_t)); if (domain) for (y = height_of_level (level); y; y--) { - memcpy (dst, domain, width_of_level (level) * sizeof (word_t)); - dst += width_of_level (level); - domain += offset; + memcpy (dst, domain, width_of_level (level) * sizeof (word_t)); + dst += width_of_level (level); + domain += offset; } - else /* state 0 */ + else /* state 0 */ for (n = size_of_level (level); n; n--) - *dst++ = (int) (128 * 8 + .5) * 2; + *dst++ = (int) (128 * 8 + .5) * 2; return pixels; } diff --git a/converter/other/fiasco/codec/dfiasco.c b/converter/other/fiasco/codec/dfiasco.c index 1cdfc672..2fdec573 100644 --- a/converter/other/fiasco/codec/dfiasco.c +++ b/converter/other/fiasco/codec/dfiasco.c @@ -14,8 +14,12 @@ * $State: Exp $ */ +#include <stdlib.h> #include <string.h> +#include "pm_c_util.h" +#include "nstring.h" + #include "config.h" #include "types.h" @@ -112,7 +116,7 @@ fiasco_decoder_new (const char *filename, const fiasco_d_options_t *options) { set_error (_("Magnifaction factor `%d' is too large. " "Maximium value is %d."), - dfiasco->enlarge_factor, max (0, n - 1)); + dfiasco->enlarge_factor, MAX(0, n - 1)); fiasco_decoder_delete (decoder); return NULL; } @@ -129,7 +133,7 @@ fiasco_decoder_new (const char *filename, const fiasco_d_options_t *options) { set_error (_("Magnifaction factor `%d' is too small. " "Minimum value is %d."), - dfiasco->enlarge_factor, - max (0, n - 1)); + dfiasco->enlarge_factor, - MAX(0, n - 1)); fiasco_decoder_delete (decoder); return NULL; } diff --git a/converter/other/fiasco/codec/domain-pool.c b/converter/other/fiasco/codec/domain-pool.c index 09f854a6..7cc3900e 100644 --- a/converter/other/fiasco/codec/domain-pool.c +++ b/converter/other/fiasco/codec/domain-pool.c @@ -17,16 +17,10 @@ #include "config.h" #include <math.h> +#include <stdlib.h> +#include <string.h> -#if STDC_HEADERS -# include <stdlib.h> -#endif /* not STDC_HEADERS */ - -#if HAVE_STRING_H -# include <string.h> -#else /* not HAVE_STRING_H */ -# include <strings.h> -#endif /* not HAVE_STRING_H */ +#include "pm_c_util.h" #include "types.h" #include "macros.h" @@ -466,7 +460,7 @@ qac_chroma (unsigned max_domains, const wfa_t *wfa, void *model) max_domains, wfa); for (n = 0; n < max_domains && domains [n] >= 0; n++) states [n] = domains [n]; - max_domains = min (max_domains, n); + max_domains = MIN(max_domains, n); Free (domains); for (old = 0, new = 0; new < max_domains && old < qac_model->n; old++) @@ -854,7 +848,7 @@ rle_chroma (unsigned max_domains, const wfa_t *wfa, void *model) states [n] = domains [n]; assert (states [0] == 0); - max_domains = min (max_domains, n); + max_domains = MIN(max_domains, n); Free (domains); Free (rle_model->states); diff --git a/converter/other/fiasco/codec/ip.c b/converter/other/fiasco/codec/ip.c index caa97baf..ade0d916 100644 --- a/converter/other/fiasco/codec/ip.c +++ b/converter/other/fiasco/codec/ip.c @@ -282,7 +282,7 @@ standard_ip_image_state (unsigned address, unsigned level, unsigned domain, real_t ip = 0, *imageptr, *stateptr; if (level > c->options.images_level) - error ("Level %d not supported.", level); + error ("We cannot interpret a Level %d image.", level); imageptr = &c->pixels [address * size_of_level (level)]; @@ -311,7 +311,7 @@ standard_ip_state_state (unsigned domain1, unsigned domain2, unsigned level, real_t ip = 0, *state1ptr, *state2ptr; if (level > c->options.images_level) - error ("Level %d not supported.", level); + error ("We cannot interpret and image with Level %d.", level); state1ptr = c->images_of_state [domain1] + address_of_level (level); state2ptr = c->images_of_state [domain2] + address_of_level (level); diff --git a/converter/other/fiasco/codec/motion.c b/converter/other/fiasco/codec/motion.c index 92951281..876a2998 100644 --- a/converter/other/fiasco/codec/motion.c +++ b/converter/other/fiasco/codec/motion.c @@ -17,11 +17,9 @@ #include "config.h" -#if HAVE_STRING_H -# include <string.h> -#else /* not HAVE_STRING_H */ -# include <strings.h> -#endif /* not HAVE_STRING_H */ +#include <string.h> + +#include "pm_c_util.h" #include "types.h" #include "macros.h" @@ -54,10 +52,10 @@ restore_mc (int enlarge_factor, image_t *image, const image_t *past, #define FX(v) ((image->format == FORMAT_4_2_0) && band != Y ? ((v) / 2) : v) - mcblock1 = Calloc (size_of_level (max ((int) wfa->wfainfo->p_max_level + mcblock1 = Calloc (size_of_level (MAX((int) wfa->wfainfo->p_max_level + 2 * enlarge_factor, 0)), sizeof (word_t)); - mcblock2 = Calloc (size_of_level (max ((int) wfa->wfainfo->p_max_level + mcblock2 = Calloc (size_of_level (MAX((int) wfa->wfainfo->p_max_level + 2 * enlarge_factor, 0)), sizeof (word_t)); diff --git a/converter/other/fiasco/codec/mwfa.c b/converter/other/fiasco/codec/mwfa.c index 6f0af8be..43a7dae2 100644 --- a/converter/other/fiasco/codec/mwfa.c +++ b/converter/other/fiasco/codec/mwfa.c @@ -18,12 +18,9 @@ #include "config.h" #include <ctype.h> +#include <string.h> -#if HAVE_STRING_H -# include <string.h> -#else /* not HAVE_STRING_H */ -# include <strings.h> -#endif /* not HAVE_STRING_H */ +#include "pm_c_util.h" #include "types.h" #include "macros.h" @@ -441,7 +438,7 @@ find_B_frame_mc (word_t *mcpe, real_t price, range_t *range, else /* local exhaustive search */ { /* - * Keep forward and backward mv due to time constraints + * Keep forward and backward mv because of time constraints */ ifx = fx; @@ -813,10 +810,10 @@ find_second_mv (real_t price, const image_t *original, sr = wi->search_range; - y0 = max ((int) -sr, *my - (int) local_range); - y1 = min ((int) sr, *my + (int) local_range); - x0 = max ((int) -sr, *mx - (int) local_range); - x1 = min ((int) sr, *mx + (int) local_range); + y0 = MAX((int) -sr, *my - (int) local_range); + y1 = MIN((int) sr, *my + (int) local_range); + x0 = MAX((int) -sr, *mx - (int) local_range); + x1 = MIN((int) sr, *mx + (int) local_range); *mx = *my = 0; diff --git a/converter/other/fiasco/codec/options.c b/converter/other/fiasco/codec/options.c index 77dbaf00..c8e4d2e2 100644 --- a/converter/other/fiasco/codec/options.c +++ b/converter/other/fiasco/codec/options.c @@ -20,12 +20,11 @@ #include "config.h" #include <string.h> -#if STDC_HEADERS -# include <stdlib.h> -#endif /* not STDC_HEADERS */ - +#include <stdlib.h> #include <stdio.h> +#include "nstring.h" + #include "types.h" #include "macros.h" #include "error.h" diff --git a/converter/other/fiasco/codec/prediction.c b/converter/other/fiasco/codec/prediction.c index 351ba9df..e056d10f 100644 --- a/converter/other/fiasco/codec/prediction.c +++ b/converter/other/fiasco/codec/prediction.c @@ -17,11 +17,7 @@ #include "config.h" -#if HAVE_STRING_H -# include <string.h> -#else /* not HAVE_STRING_H */ -# include <strings.h> -#endif /* not HAVE_STRING_H */ +#include <string.h> #include "types.h" #include "macros.h" diff --git a/converter/other/fiasco/codec/subdivide.c b/converter/other/fiasco/codec/subdivide.c index b7982716..2ace18e4 100644 --- a/converter/other/fiasco/codec/subdivide.c +++ b/converter/other/fiasco/codec/subdivide.c @@ -16,11 +16,9 @@ #include "config.h" -#if HAVE_STRING_H -# include <string.h> -#else /* not HAVE_STRING_H */ -# include <strings.h> -#endif /* not HAVE_STRING_H */ +#include <string.h> + +#include "pm_c_util.h" #include "types.h" #include "macros.h" @@ -293,7 +291,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, : rrange.y; /* - * If neccessary compute the inner products of the new states + * If necessary compute the inner products of the new states * (generated during the recursive approximation of child [0]) */ if (label && rrange.level <= c->options.lc_max_level) @@ -304,7 +302,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, * Abort the recursion if 'subdivide_costs' exceed 'lincomb_costs' * or 'max_costs'. */ - remaining_costs = min (lincomb_costs, max_costs) - subdivide_costs; + remaining_costs = MIN(lincomb_costs, max_costs) - subdivide_costs; if (remaining_costs > 0) /* still a way for improvement */ { @@ -356,7 +354,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, * 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; @@ -386,28 +384,28 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, */ if (try_mc || try_nd) /* try prediction */ { - real_t prediction_costs; /* Costs arising from approx. the current - range with prediction */ - - prediction_costs - = predict_range (min (min (lincomb_costs, subdivide_costs), - max_costs), - price, range, wfa, c, band, y_state, states, - &tree_model, &p_tree_model, domain_model, - d_domain_model, coeff_model, d_coeff_model); - if (prediction_costs < MAXCOSTS) /* prediction has smallest costs */ - { - c->domain_pool->model_free (domain_model); - c->d_domain_pool->model_free (d_domain_model); - c->domain_pool->model_free (lc_domain_model); - c->d_domain_pool->model_free (lc_d_domain_model); - c->coeff->model_free (coeff_model); - c->d_coeff->model_free (d_coeff_model); - c->coeff->model_free (lc_coeff_model); - c->d_coeff->model_free (lc_d_coeff_model); + real_t prediction_costs; /* Costs arising from approx. the current + range with prediction */ + + prediction_costs + = predict_range (MIN(MIN(lincomb_costs, subdivide_costs), + max_costs), + price, range, wfa, c, band, y_state, states, + &tree_model, &p_tree_model, domain_model, + d_domain_model, coeff_model, d_coeff_model); + if (prediction_costs < MAXCOSTS) /* prediction has smallest costs */ + { + c->domain_pool->model_free (domain_model); + c->d_domain_pool->model_free (d_domain_model); + c->domain_pool->model_free (lc_domain_model); + c->d_domain_pool->model_free (lc_d_domain_model); + c->coeff->model_free (coeff_model); + 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; - } + return prediction_costs; + } } if (lincomb_costs >= MAXCOSTS && subdivide_costs >= MAXCOSTS) diff --git a/converter/other/fiasco/codec/tiling.c b/converter/other/fiasco/codec/tiling.c index e820f7fb..21e4428a 100644 --- a/converter/other/fiasco/codec/tiling.c +++ b/converter/other/fiasco/codec/tiling.c @@ -16,9 +16,9 @@ #include "config.h" -#if STDC_HEADERS -# include <stdlib.h> -#endif /* not STDC_HEADERS */ +#include <stdlib.h> + +#include "pm_c_util.h" #include "types.h" #include "macros.h" @@ -29,22 +29,7 @@ #include "wfalib.h" #include "tiling.h" -/***************************************************************************** - - prototypes - -*****************************************************************************/ - -static int -cmpdecvar (const void *value1, const void *value2); -static int -cmpincvar (const void *value1, const void *value2); - -/***************************************************************************** - public code - -*****************************************************************************/ typedef struct var_list { @@ -52,6 +37,38 @@ typedef struct var_list real_t variance; /* variance of tile */ } var_list_t; +#ifndef LITERAL_FN_DEF_MATCH +static qsort_comparison_fn cmpincvar; +#endif + +static int +cmpincvar(const void * const value1, + const void * const value2) { +/*---------------------------------------------------------------------------- + Sorts by increasing variances (quicksort sorting function) +-----------------------------------------------------------------------------*/ + return + ((var_list_t *) value1)->variance - ((var_list_t *) value2)->variance; +} + + + +#ifndef LITERAL_FN_DEF_MATCH +static qsort_comparison_fn cmpdecvar; +#endif + +static int +cmpdecvar(const void * const value1, + const void * const value2) { +/*---------------------------------------------------------------------------- + Sorts by decreasing variances (quicksort sorting function). +-----------------------------------------------------------------------------*/ + return + ((var_list_t *) value2)->variance - ((var_list_t *) value1)->variance; +} + + + tiling_t * alloc_tiling (fiasco_tiling_e method, unsigned tiling_exponent, unsigned image_level) @@ -146,7 +163,7 @@ perform_tiling (const image_t *image, tiling_t *tiling) unsigned number; /* number of image tiles */ unsigned lx = log2 (image->width - 1) + 1; /* x level */ unsigned ly = log2 (image->height - 1) + 1; /* y level */ - unsigned level = max (lx, ly) * 2 - ((ly == lx + 1) ? 1 : 0); + unsigned level = MAX(lx, ly) * 2 - ((ly == lx + 1) ? 1 : 0); var_list_t *var_list = Calloc (tiles, sizeof (var_list_t)); /* @@ -207,33 +224,10 @@ perform_tiling (const image_t *image, tiling_t *tiling) } else { - warning ("Unsupported image tiling method.\n" + warning ("We do not know the tiling method.\n" "Skipping image tiling step."); tiling->exponent = 0; } } } -/***************************************************************************** - - private code - -*****************************************************************************/ - -static int -cmpincvar (const void *value1, const void *value2) -/* - * Sorts by increasing variances (quicksort sorting function). - */ -{ - return ((var_list_t *) value1)->variance - ((var_list_t *) value2)->variance; -} - -static int -cmpdecvar (const void *value1, const void *value2) -/* - * Sorts by decreasing variances (quicksort sorting function). - */ -{ - return ((var_list_t *) value2)->variance - ((var_list_t *) value1)->variance; -} diff --git a/converter/other/fiasco/codec/wfa.h b/converter/other/fiasco/codec/wfa.h index 8b9793f2..9253affd 100644 --- a/converter/other/fiasco/codec/wfa.h +++ b/converter/other/fiasco/codec/wfa.h @@ -19,7 +19,7 @@ #define MAXEDGES 5 #define MAXSTATES 6000 -#define MAXLABELS 2 /* only bintree supported anymore */ +#define MAXLABELS 2 /* only bintree possible anymore */ #define MAXLEVEL 22 #define FIASCO_BINFILE_RELEASE 2 @@ -122,7 +122,7 @@ typedef struct wfa real_t *final_distribution; /* one pixel images */ byte_t *level_of_state; /* level of the image part which is represented by the current state */ - byte_t *domain_type; /* Bit_0==1: auxilliary state + byte_t *domain_type; /* Bit_0==1: auxiliary state Bit_1==1: used for Y compr */ mv_t (*mv_tree)[MAXLABELS]; /* motion vectors */ word_t (*tree)[MAXLABELS]; /* bintree partitioning */ diff --git a/converter/other/fiasco/codec/wfalib.c b/converter/other/fiasco/codec/wfalib.c index a3acb975..61d64d2f 100644 --- a/converter/other/fiasco/codec/wfalib.c +++ b/converter/other/fiasco/codec/wfalib.c @@ -19,12 +19,11 @@ #include "config.h" -#if STDC_HEADERS -# include <stdlib.h> -#endif /* not STDC_HEADERS */ - +#include <stdlib.h> #include <string.h> +#include "pm_c_util.h" + #include "types.h" #include "macros.h" #include "error.h" @@ -218,7 +217,7 @@ compute_hits (unsigned from, unsigned to, unsigned n, const wfa_t *wfa) qsort (hits + 1, to - 1, sizeof (pair_t), sort_desc_pair); - n = min (to, n); + n = MIN(to, n); domains = Calloc (n + 1, sizeof (word_t)); for (domain = 0; domain < (int) n && (!domain || hits [domain].key); @@ -486,7 +485,7 @@ compute_spiral (int *vorder, unsigned image_width, unsigned image_height, lx = log2 (image_width - 1) + 1; ly = log2 (image_height - 1) + 1; - level = max (lx, ly) * 2 - ((ly == lx + 1) ? 1 : 0); + level = MAX(lx, ly) * 2 - ((ly == lx + 1) ? 1 : 0); tiles = 1 << tiling_exp; /* Number of image tiles */ width = width_of_level (level - tiling_exp); height = height_of_level (level - tiling_exp); diff --git a/converter/other/fiasco/config.h b/converter/other/fiasco/config.h index 64b905f8..57b3518d 100644 --- a/converter/other/fiasco/config.h +++ b/converter/other/fiasco/config.h @@ -56,9 +56,6 @@ /* Define if you have the strcasecmp function. */ #define HAVE_STRCASECMP 1 -/* Define if you have the strdup function. */ -#define HAVE_STRDUP 1 - /* Define if you have the <X11/extensions/XShm.h> header file. */ /* #undef HAVE_X11_EXTENSIONS_XSHM_H */ diff --git a/converter/other/fiasco/display.c b/converter/other/fiasco/display.c index 9e531149..cf160329 100644 --- a/converter/other/fiasco/display.c +++ b/converter/other/fiasco/display.c @@ -27,16 +27,8 @@ #include <X11/Xutil.h> #include <X11/keysym.h> -#if STDC_HEADERS -# include <stdlib.h> -# include <string.h> -#else /* not STDC_HEADERS */ -# if HAVE_STRING_H -# include <string.h> -# else /* not HAVE_STRING_H */ -# include <strings.h> -# endif /* not HAVE_STRING_H */ -#endif /* not STDC_HEADERS */ +#include <stdlib.h> +#include <string.h> #include "types.h" #include "macros.h" @@ -315,7 +307,8 @@ alloc_ximage (x11_info_t *xinfo, unsigned width, unsigned height) shmem_flag = 0; if (fiasco_get_verbosity ()) fprintf (stderr, - "Shared memory not supported\nReverting to normal Xlib.\n"); + "Shared memory does not work on this system\n" + "Reverting to normal Xlib.\n"); } if (shmem_flag) diff --git a/converter/other/fiasco/fiascotopnm.c b/converter/other/fiasco/fiascotopnm.c index 6d8b6f7f..dfba2256 100644 --- a/converter/other/fiasco/fiascotopnm.c +++ b/converter/other/fiasco/fiascotopnm.c @@ -25,6 +25,8 @@ #include <string.h> #include <math.h> +#include "nstring.h" + #include "types.h" #include "macros.h" @@ -176,21 +178,21 @@ checkargs (int argc, char **argv, bool_t *double_resolution, bool_t *panel, *options = fiasco_d_options_new (); { - int n = *((int *) parameter_value (params, "smoothing")); + int const n = *((int *) parameter_value (params, "smoothing")); - if (!fiasco_d_options_set_smoothing (*options, max (-1, n))) + if (!fiasco_d_options_set_smoothing (*options, MAX(-1, n))) error (fiasco_get_error_message ()); } { - int n = *((int *) parameter_value (params, "magnify")); + int const n = *((int *) parameter_value (params, "magnify")); if (!fiasco_d_options_set_magnification (*options, n)) error (fiasco_get_error_message ()); } { - bool_t n = *((bool_t *) parameter_value (params, "fast")); + bool_t const n = *((bool_t *) parameter_value (params, "fast")); if (!fiasco_d_options_set_4_2_0_format (*options, n > 0 ? YES : NO)) error (fiasco_get_error_message ()); diff --git a/converter/other/fiasco/getopt.c b/converter/other/fiasco/getopt.c index 0b2d1b75..2f45c7cc 100644 --- a/converter/other/fiasco/getopt.c +++ b/converter/other/fiasco/getopt.c @@ -73,15 +73,7 @@ #include <unistd.h> #endif /* GNU C library. */ -#ifdef VMS -#include <unixlib.h> -#if HAVE_STRING_H - 0 -#include <string.h> -#endif -#endif - -#if defined (WIN32) && !defined (__CYGWIN32__) -/* It's not Unix, really. See? Capital letters. */ +#if MSVCRT #include <windows.h> #define getpid() GetCurrentProcessId() #endif diff --git a/converter/other/fiasco/input/basis.c b/converter/other/fiasco/input/basis.c index cef075e6..4a748f61 100644 --- a/converter/other/fiasco/input/basis.c +++ b/converter/other/fiasco/input/basis.c @@ -16,6 +16,8 @@ #include "config.h" +#include "nstring.h" + #include "types.h" #include "macros.h" #include "error.h" diff --git a/converter/other/fiasco/input/read.c b/converter/other/fiasco/input/read.c index 26bae7e4..e6e2d7e8 100644 --- a/converter/other/fiasco/input/read.c +++ b/converter/other/fiasco/input/read.c @@ -23,6 +23,8 @@ #include <string.h> +#include "nstring.h" + #include "types.h" #include "macros.h" #include "error.h" @@ -155,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->level = MAX(lx, ly) * 2 - ((ly == lx + 1) ? 1 : 0); } wi->chroma_max_states = wi->color ? read_rice_code (rice_k, input) : -1; wi->p_min_level = read_rice_code (rice_k, input); @@ -275,7 +277,7 @@ read_basis (const char *filename, wfa_t *wfa) * string |MAGIC Number "Wfa" * int |Number of basis states 'N' * bool_t-array[N] |use vector in linear combinations, - * |0: don't use vector (auxilliary state) + * |0: don't use vector (auxiliary state) * |1: use vector in linear combinations * float-array[N] |final distribution of every state * @@ -395,7 +397,7 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) /* * Compute domain pool. - * Large images have not been used due to image tiling. + * Large images have not been used because of image tiling. */ { unsigned state; diff --git a/converter/other/fiasco/input/weights.c b/converter/other/fiasco/input/weights.c index 55339980..15c35731 100644 --- a/converter/other/fiasco/input/weights.c +++ b/converter/other/fiasco/input/weights.c @@ -1,8 +1,8 @@ /* - * weights.c: Input of weights + * weights.c: Input of weights * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO («F»ractal «I»mage «A»nd «S»equence «CO»dec) * Copyright (C) 1994-2000 Ullrich Hafner <hafner@bigfoot.de> */ @@ -16,6 +16,8 @@ #include "config.h" +#include "pm_c_util.h" + #include "types.h" #include "macros.h" #include "error.h" @@ -29,7 +31,7 @@ /***************************************************************************** - public code + public code *****************************************************************************/ @@ -42,17 +44,17 @@ read_weights (unsigned total, wfa_t *wfa, bitfile_t *input) * No return value. * * Side effects: - * 'wfa->weights' are filled with the decoded values + * 'wfa->weights' are filled with the decoded values */ { - unsigned state; - unsigned label; - unsigned edge; /* current edge */ - unsigned *weights_array; /* array of weights to encode */ - unsigned *level_array; /* array of corresponding levels */ - unsigned offset1, offset2; /* prob. model offsets. */ - unsigned offset3, offset4; /* prob. model offsets. */ - bool_t delta_approx = NO; /* true if delta has been used */ + unsigned state; + unsigned label; + unsigned edge; /* current edge */ + unsigned *weights_array; /* array of weights to encode */ + unsigned *level_array; /* array of corresponding levels */ + unsigned offset1, offset2; /* prob. model offsets. */ + unsigned offset3, offset4; /* prob. model offsets. */ + bool_t delta_approx = NO; /* true if delta has been used */ /* * Check whether delta approximation has been used @@ -60,52 +62,54 @@ read_weights (unsigned total, wfa_t *wfa, bitfile_t *input) for (state = wfa->basis_states; state < wfa->states; state++) if (wfa->delta_state [state]) { - delta_approx = YES; - break; + delta_approx = YES; + break; } /* * Generate array of corresponding levels (context of probability model) */ { - int min_level, max_level; /* min and max range level */ - int d_min_level, d_max_level; /* min and max range level (delta) */ - unsigned *lptr; /* pointer to current corresp. level */ - int domain; /* current domain */ - bool_t dc, d_dc; /* indicates whether DC is used */ + int min_level, max_level; /* min and max range level */ + int d_min_level, d_max_level; /* min and max range level (delta) */ + unsigned *lptr; /* pointer to current corresp. level */ + int domain; /* current domain */ + bool_t dc, d_dc; /* indicates whether DC is used */ /* * Compute minimum and maximum level of delta and normal approximations */ min_level = d_min_level = MAXLEVEL; max_level = d_max_level = 0; - dc = d_dc = NO; + dc = d_dc = NO; for (state = wfa->basis_states; state < wfa->states; state++) - for (label = 0; label < MAXLABELS; label++) - if (isrange (wfa->tree [state][label])) - { - if (delta_approx && wfa->delta_state [state]) - { - d_min_level = min (d_min_level, - wfa->level_of_state [state] - 1); - d_max_level = max (d_max_level, - wfa->level_of_state [state] - 1); - if (wfa->into [state][label][0] == 0) - d_dc = YES; - } - else - { - min_level = min (min_level, wfa->level_of_state [state] - 1); - max_level = max (max_level, wfa->level_of_state [state] - 1); - if (wfa->into [state][label][0] == 0) - dc = YES; - } - } - if (min_level > max_level) /* no lc found */ - max_level = min_level - 1; + for (label = 0; label < MAXLABELS; label++) + if (isrange (wfa->tree [state][label])) + { + if (delta_approx && wfa->delta_state [state]) + { + d_min_level = + MIN(d_min_level, wfa->level_of_state [state] - 1); + d_max_level = + MAX(d_max_level, wfa->level_of_state [state] - 1); + if (wfa->into [state][label][0] == 0) + d_dc = YES; + } + else + { + min_level = + MIN(min_level, wfa->level_of_state [state] - 1); + max_level = + MAX(max_level, wfa->level_of_state [state] - 1); + if (wfa->into [state][label][0] == 0) + dc = YES; + } + } + if (min_level > max_level) /* no lc found */ + max_level = min_level - 1; if (d_min_level > d_max_level) - d_max_level = d_min_level - 1; + d_max_level = d_min_level - 1; offset1 = dc ? 1 : 0; offset2 = offset1 + (d_dc ? 1 : 0); @@ -114,47 +118,47 @@ read_weights (unsigned total, wfa_t *wfa, bitfile_t *input) lptr = level_array = Calloc (total, sizeof (int)); for (state = wfa->basis_states; state < wfa->states; state++) - for (label = 0; label < MAXLABELS; label++) - if (isrange (wfa->tree[state][label])) - for (edge = 0; isedge (domain = wfa->into[state][label][edge]); - edge++) - { - if ((unsigned) (lptr - level_array) >= total) - error ("Can't read more than %d weights.", total); - if (domain) - { - if (delta_approx && wfa->delta_state [state]) - *lptr++ = offset3 + wfa->level_of_state [state] - - 1 - d_min_level; - else - *lptr++ = offset2 + wfa->level_of_state [state] - - 1 - min_level; - } - else - *lptr++ = delta_approx && wfa->delta_state [state] - ? offset1 : 0; - } + for (label = 0; label < MAXLABELS; label++) + if (isrange (wfa->tree[state][label])) + for (edge = 0; isedge (domain = wfa->into[state][label][edge]); + edge++) + { + if ((unsigned) (lptr - level_array) >= total) + error ("Can't read more than %d weights.", total); + if (domain) + { + if (delta_approx && wfa->delta_state [state]) + *lptr++ = offset3 + wfa->level_of_state [state] + - 1 - d_min_level; + else + *lptr++ = offset2 + wfa->level_of_state [state] + - 1 - min_level; + } + else + *lptr++ = delta_approx && wfa->delta_state [state] + ? offset1 : 0; + } } /* * Decode the list of weights with an arithmetic decoder */ { - unsigned i; - unsigned *c_symbols = Calloc (offset4, sizeof (unsigned)); - const unsigned scale = 500; /* scaling of probability model */ + unsigned i; + unsigned *c_symbols = Calloc (offset4, sizeof (unsigned)); + const unsigned scale = 500; /* scaling of probability model */ c_symbols [0] = 1 << (wfa->wfainfo->dc_rpf->mantissa_bits + 1); if (offset1 != offset2) - c_symbols [offset1] = 1 << (wfa->wfainfo->d_dc_rpf->mantissa_bits - + 1); + c_symbols [offset1] = 1 << (wfa->wfainfo->d_dc_rpf->mantissa_bits + + 1); for (i = offset2; i < offset3; i++) - c_symbols [i] = 1 << (wfa->wfainfo->rpf->mantissa_bits + 1); + c_symbols [i] = 1 << (wfa->wfainfo->rpf->mantissa_bits + 1); for (; i < offset4; i++) - c_symbols [i] = 1 << (wfa->wfainfo->d_rpf->mantissa_bits + 1); + c_symbols [i] = 1 << (wfa->wfainfo->d_rpf->mantissa_bits + 1); weights_array = decode_array (input, level_array, c_symbols, - offset4, total, scale); + offset4, total, scale); Free (c_symbols); } Free (level_array); @@ -163,36 +167,36 @@ read_weights (unsigned total, wfa_t *wfa, bitfile_t *input) * Update transitions with decoded weights */ { - unsigned *wptr = weights_array; /* pointer to current weight */ - int domain; /* current domain */ + unsigned *wptr = weights_array; /* pointer to current weight */ + int domain; /* current domain */ for (state = wfa->basis_states; state < wfa->states; state++) - for (label = 0; label < MAXLABELS; label++) - if (isrange (wfa->tree[state][label])) - for (edge = 0; isedge (domain = wfa->into[state][label][edge]); - edge++) - { - if (domain) /* not DC component */ - { - if (delta_approx && wfa->delta_state [state]) - wfa->weight [state][label][edge] - = btor (*wptr++, wfa->wfainfo->d_rpf); - else - wfa->weight [state][label][edge] - = btor (*wptr++, wfa->wfainfo->rpf); - } - else - { - if (delta_approx && wfa->delta_state [state]) - wfa->weight [state][label][edge] - = btor (*wptr++, wfa->wfainfo->d_dc_rpf); - else - wfa->weight [state][label][edge] - = btor (*wptr++, wfa->wfainfo->dc_rpf); - } - wfa->int_weight [state][label][edge] - = wfa->weight [state][label][edge] * 512 + 0.5; - } + for (label = 0; label < MAXLABELS; label++) + if (isrange (wfa->tree[state][label])) + for (edge = 0; isedge (domain = wfa->into[state][label][edge]); + edge++) + { + if (domain) /* not DC component */ + { + if (delta_approx && wfa->delta_state [state]) + wfa->weight [state][label][edge] + = btor (*wptr++, wfa->wfainfo->d_rpf); + else + wfa->weight [state][label][edge] + = btor (*wptr++, wfa->wfainfo->rpf); + } + else + { + if (delta_approx && wfa->delta_state [state]) + wfa->weight [state][label][edge] + = btor (*wptr++, wfa->wfainfo->d_dc_rpf); + else + wfa->weight [state][label][edge] + = btor (*wptr++, wfa->wfainfo->dc_rpf); + } + wfa->int_weight [state][label][edge] + = wfa->weight [state][label][edge] * 512 + 0.5; + } } Free (weights_array); diff --git a/converter/other/fiasco/lib/arith.c b/converter/other/fiasco/lib/arith.c index e3745bf7..dc35d1d1 100644 --- a/converter/other/fiasco/lib/arith.c +++ b/converter/other/fiasco/lib/arith.c @@ -90,7 +90,7 @@ encode_symbol (unsigned symbol, arith_t *arith, model_t *model) * The current state of the arithmetic coder is given by 'arith'. * Output bits are appended to the stream 'output'. * - * The model is updated after encoding the symbol (if neccessary the + * The model is updated after encoding the symbol (if necessary the * symbol counts are rescaled). * * Return value: @@ -354,7 +354,7 @@ decode_symbol (arith_t *arith, model_t *model) * Decode the next symbol - the state of the arithmetic decoder * 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 neccessary also rescale the symbol counts). + * deconding the symbol (if necessary also rescale the symbol counts). * * Return value: * decoded symbol diff --git a/converter/other/fiasco/lib/bit-io.c b/converter/other/fiasco/lib/bit-io.c index 364a1c05..1bfef598 100644 --- a/converter/other/fiasco/lib/bit-io.c +++ b/converter/other/fiasco/lib/bit-io.c @@ -20,9 +20,9 @@ #include "config.h" #include <string.h> -#if STDC_HEADERS -# include <stdlib.h> -#endif /* not STDC_HEADERS */ +#include <stdlib.h> + +#include "nstring.h" #include "macros.h" #include "types.h" diff --git a/converter/other/fiasco/lib/dither.c b/converter/other/fiasco/lib/dither.c index a39afa3c..accd9dd6 100644 --- a/converter/other/fiasco/lib/dither.c +++ b/converter/other/fiasco/lib/dither.c @@ -38,14 +38,8 @@ #include "pm_config.h" #include "config.h" -#if HAVE_STRING_H -# include <string.h> -#else /* not HAVE_STRING_H */ -# include <strings.h> -#endif /* not HAVE_STRING_H */ -#if STDC_HEADERS -# include <stdlib.h> -#endif /* not STDC_HEADERS */ +#include <string.h> +#include <stdlib.h> #include "types.h" #include "macros.h" @@ -65,19 +59,22 @@ static int display_16_bit (const struct fiasco_renderer *this, unsigned char *ximage, const fiasco_image_t *fiasco_image); + static int display_24_bit_bgr (const struct fiasco_renderer *this, unsigned char *ximage, const fiasco_image_t *fiasco_image); + static int display_24_bit_rgb (const struct fiasco_renderer *this, unsigned char *ximage, const fiasco_image_t *fiasco_image); + static int display_32_bit (const struct fiasco_renderer *this, unsigned char *ximage, const fiasco_image_t *fiasco_image); + static int free_bits_at_bottom (unsigned long a); -static int -free_bits_at_top (unsigned long a); + static int number_of_bits_set (unsigned long a); @@ -345,21 +342,6 @@ number_of_bits_set (unsigned long a) } static int -free_bits_at_top (unsigned long a) -/* - * How many 0 bits are there at most significant end of longword. - * Low performance, do not call often. - */ -{ - if(!a) /* assume char is 8 bits */ - return sizeof (unsigned long) * 8; - else if (((long) a) < 0l) /* assume twos complement */ - return 0; - else - return 1 + free_bits_at_top ( a << 1); -} - -static int free_bits_at_bottom (unsigned long a) /* * How many 0 bits are there at least significant end of longword. diff --git a/converter/other/fiasco/lib/error.c b/converter/other/fiasco/lib/error.c index b858badf..ee3afe1f 100644 --- a/converter/other/fiasco/lib/error.c +++ b/converter/other/fiasco/lib/error.c @@ -29,18 +29,9 @@ #include <stdio.h> #include <errno.h> -#if STDC_HEADERS -# include <stdarg.h> -# define VA_START(args, lastarg) va_start(args, lastarg) -#else /* not STDC_HEADERS */ -# include <varargs.h> -# define VA_START(args, lastarg) va_start(args) -#endif /* not STDC_HEADERS */ -#if HAVE_STRING_H -# include <string.h> -#else /* not HAVE_STRING_H */ -# include <strings.h> -#endif /* not HAVE_STRING_H */ +#include <stdarg.h> +#define VA_START(args, lastarg) va_start(args, lastarg) +#include <string.h> #if HAVE_SETJMP_H # include <setjmp.h> @@ -117,11 +108,7 @@ set_error (const char *format, ...) Free (error_message); error_message = Calloc (len, sizeof (char)); -#if HAVE_VPRINTF vsprintf (error_message, format, args); -#elif HAVE_DOPRNT - _doprnt (format, args, stderr); -#endif /* HAVE_DOPRNT */ va_end (args); } @@ -178,11 +165,7 @@ error (const char *format, ...) Free (error_message); error_message = Calloc (len, sizeof (char)); -#if HAVE_VPRINTF vsprintf (error_message, format, args); -#elif HAVE_DOPRNT - _doprnt (format, args, stderr); -#endif /* HAVE_DOPRNT */ va_end (args); @@ -236,11 +219,7 @@ warning (const char *format, ...) return; fprintf (stderr, "Warning: "); -#if HAVE_VPRINTF vfprintf (stderr, format, args); -#elif HAVE_DOPRNT - _doprnt (format, args, stderr); -#endif /* HAVE_DOPRNT */ fputc ('\n', stderr); va_end (args); @@ -259,11 +238,7 @@ message (const char *format, ...) if (verboselevel == FIASCO_NO_VERBOSITY) return; -#if HAVE_VPRINTF vfprintf (stderr, format, args); -#elif HAVE_DOPRNT - _doprnt (format, args, stderr); -#endif /* HAVE_DOPRNT */ fputc ('\n', stderr); va_end (args); } @@ -282,11 +257,7 @@ debug_message (const char *format, ...) return; fprintf (stderr, "*** "); -#if HAVE_VPRINTF vfprintf (stderr, format, args); -#elif HAVE_DOPRNT - _doprnt (format, args, stderr); -#endif /* HAVE_DOPRNT */ fputc ('\n', stderr); va_end (args); } @@ -304,11 +275,7 @@ info (const char *format, ...) if (verboselevel == FIASCO_NO_VERBOSITY) return; -#if HAVE_VPRINTF vfprintf (stderr, format, args); -#elif HAVE_DOPRNT - _doprnt (format, args, stderr); -#endif /* HAVE_DOPRNT */ fflush (stderr); va_end (args); } diff --git a/converter/other/fiasco/lib/image.c b/converter/other/fiasco/lib/image.c index 0168734c..fa3b2db5 100644 --- a/converter/other/fiasco/lib/image.c +++ b/converter/other/fiasco/lib/image.c @@ -18,6 +18,8 @@ #include <string.h> +#include "nstring.h" + #include "types.h" #include "macros.h" #include "error.h" @@ -239,7 +241,7 @@ alloc_image (unsigned width, unsigned height, bool_t color, format_e format) image->format = format; image->reference_count = 1; - strcpy (image->id, "IFIASCO"); + STRSCPY(image->id, "IFIASCO"); for (band = first_band (color); band <= last_band (color); band++) if (format == FORMAT_4_2_0 && band != Y) @@ -447,7 +449,7 @@ write_image (const char *image_name, const image_t *image) if (image->format == FORMAT_4_2_0) { - warning ("Writing of images in 4:2:0 format not supported."); + warning ("We cannot write images in 4:2:0 format."); return; } diff --git a/converter/other/fiasco/lib/list.c b/converter/other/fiasco/lib/list.c index 9f516c2e..bb4efae1 100644 --- a/converter/other/fiasco/lib/list.c +++ b/converter/other/fiasco/lib/list.c @@ -16,11 +16,7 @@ #include "config.h" -#if HAVE_STRING_H -# include <string.h> -#else /* not HAVE_STRING_H */ -# include <strings.h> -#endif /* not HAVE_STRING_H */ +#include <string.h> #include "types.h" #include "macros.h" diff --git a/converter/other/fiasco/lib/macros.h b/converter/other/fiasco/lib/macros.h index 877abeea..9968110a 100644 --- a/converter/other/fiasco/lib/macros.h +++ b/converter/other/fiasco/lib/macros.h @@ -28,11 +28,6 @@ # define SEEK_CUR 1 #endif /* not SEEK_CUR */ -#ifdef WIN32 -#undef max -#undef min -#endif /* not WIN32 */ - /***************************************************************************** Various macros @@ -50,12 +45,6 @@ #define address_of_level(l) ((unsigned) (size_of_level (l) - 1)) #define size_of_tree(l) ((unsigned) (address_of_level ((l) + 1))) #define is_odd(n) (abs (n) % 2) -#ifndef max -#define max(a,b) ((a) < (b) ? (b) : (a)) -#endif -#ifndef min -#define min(a,b) ((a) > (b) ? (b) : (a)) -#endif #define _(x) (x) diff --git a/converter/other/fiasco/lib/misc.c b/converter/other/fiasco/lib/misc.c index 12b94e7a..782ed1e9 100644 --- a/converter/other/fiasco/lib/misc.c +++ b/converter/other/fiasco/lib/misc.c @@ -1,5 +1,5 @@ /* - * misc.c: Some usefull functions, that don't fit in one of + * misc.c: Some useful functions, that don't fit in one of * the other files and that are needed by at least * two modules. * @@ -33,15 +33,10 @@ # endif /* not HAVE_SYS_TIME_H */ #endif /* not TIME_WITH_SYS_TIME */ -#if STDC_HEADERS -# include <stdlib.h> -#endif /* not STDC_HEADERS */ +#include <stdlib.h> +#include <string.h> -#if HAVE_STRING_H -# include <string.h> -#else /* not HAVE_STRING_H */ -# include <strings.h> -#endif /* not HAVE_STRING_H */ +#include "pm_c_util.h" #include "types.h" #include "macros.h" @@ -401,22 +396,6 @@ memmove (void *v_dst, const void *v_src, size_t n) } #endif /* not HAVE_MEMMOVE */ -#ifndef HAVE_STRDUP -char * -strdup (const char *s) -/* - * Duplicate given string 's'. - * - * Return value: - * pointer to new string value - */ -{ - assert (s); - - return strcpy (Calloc (strlen (s) + 1, sizeof (char)), s); -} -#endif /* not HAVE_STRDUP */ - /* Note that some systems have a "log2()" in the math library and some have a "log2" macro. So we name ours Log2. But to avoid lots of differences from the original fiasco source code, we define a @@ -452,13 +431,13 @@ variance (const word_t *pixels, unsigned x0, unsigned y0, assert (pixels); for (average = 0, n = 0, y = y0; y < y0 + height; y++) - for (x = x0; x < min (x0 + width, cols); x++, n++) + for (x = x0; x < MIN(x0 + width, cols); x++, n++) average += pixels [y * cols + x] / 16; average /= n; for (variance = 0, y = y0; y < y0 + height; y++) - for (x = x0; x < min (x0 + width, cols); x++) + for (x = x0; x < MIN(x0 + width, cols); x++) variance += square ((pixels [y * cols + x] / 16) - average); return variance; diff --git a/converter/other/fiasco/lib/misc.h b/converter/other/fiasco/lib/misc.h index 29456590..28fd8b5a 100644 --- a/converter/other/fiasco/lib/misc.h +++ b/converter/other/fiasco/lib/misc.h @@ -72,10 +72,6 @@ memmove(void *dest, const void *src, size_t n); double Log2 (double x); -#ifndef HAVE_STRDUP -char * -strdup (const char *s); -#endif #ifndef HAVE_STRCASECMP bool_t strcaseeq (const char *s1, const char *s2); diff --git a/converter/other/fiasco/output/matrices.c b/converter/other/fiasco/output/matrices.c index fd8d31e2..01189669 100644 --- a/converter/other/fiasco/output/matrices.c +++ b/converter/other/fiasco/output/matrices.c @@ -20,9 +20,9 @@ #include "config.h" -#if STDC_HEADERS -# include <stdlib.h> -#endif /* not STDC_HEADERS */ +#include <stdlib.h> + +#include "pm_c_util.h" #include "types.h" #include "macros.h" @@ -144,7 +144,7 @@ delta_encoding (bool_t use_normal_domains, bool_t use_delta_domains, ; count [edge]++; edges++; - M = max (edge, M); + M = MAX(edge, M); } write_rice_code (M, 3, output); for (n = 0; n <= M; n++) diff --git a/converter/other/fiasco/output/weights.c b/converter/other/fiasco/output/weights.c index 085a1f00..5aa17674 100644 --- a/converter/other/fiasco/output/weights.c +++ b/converter/other/fiasco/output/weights.c @@ -16,6 +16,8 @@ #include "config.h" +#include "pm_c_util.h" + #include "types.h" #include "macros.h" #include "error.h" @@ -43,158 +45,159 @@ write_weights (unsigned total, const wfa_t *wfa, bitfile_t *output) * No return value. */ { - unsigned state, label; /* current label */ - unsigned offset1, offset2; /* model offsets. */ - unsigned offset3, offset4; /* model offsets. */ - unsigned *weights_array; /* array of weights to encode */ - unsigned *wptr; /* pointer to current weight */ - unsigned *level_array; /* array of corresponding levels */ - unsigned *lptr; /* pointer to current corr. level */ - int min_level, max_level; /* min and max range level */ - int d_min_level, d_max_level; /* min and max delta range level */ - bool_t dc, d_dc; /* true if dc or delta dc are used */ - bool_t delta_approx = NO; /* true if delta has been used */ - unsigned delta_count = 0; /* number of delta ranges */ - unsigned bits = bits_processed (output); + unsigned state, label; /* current label */ + unsigned offset1, offset2; /* model offsets. */ + unsigned offset3, offset4; /* model offsets. */ + unsigned *weights_array; /* array of weights to encode */ + unsigned *wptr; /* pointer to current weight */ + unsigned *level_array; /* array of corresponding levels */ + unsigned *lptr; /* pointer to current corr. level */ + int min_level, max_level; /* min and max range level */ + int d_min_level, d_max_level; /* min and max delta range level */ + bool_t dc, d_dc; /* true if dc or delta dc are used */ + bool_t delta_approx = NO; /* true if delta has been used */ + unsigned delta_count = 0; /* number of delta ranges */ + unsigned bits = bits_processed (output); - /* - * Check whether delta approximation has been used - */ - for (state = wfa->basis_states; state < wfa->states; state++) - if (wfa->delta_state [state]) - { - delta_approx = YES; - break; - } + /* + * Check whether delta approximation has been used + */ + for (state = wfa->basis_states; state < wfa->states; state++) + if (wfa->delta_state [state]) + { + delta_approx = YES; + break; + } - /* - * Generate array of corresponding levels (context of probability model) - */ - min_level = d_min_level = MAXLEVEL; - max_level = d_max_level = 0; - dc = d_dc = NO; + /* + * Generate array of corresponding levels (context of probability model) + */ + min_level = d_min_level = MAXLEVEL; + max_level = d_max_level = 0; + dc = d_dc = NO; - for (state = wfa->basis_states; state < wfa->states; state++) - for (label = 0; label < MAXLABELS; label++) - if (isrange (wfa->tree [state][label])) - { - if (delta_approx && wfa->delta_state [state]) /* delta approx. */ - { - d_min_level = min (d_min_level, - wfa->level_of_state [state] - 1); - d_max_level = max (d_max_level, - wfa->level_of_state [state] - 1); - if (wfa->into [state][label][0] == 0) - d_dc = YES; - } - else - { - min_level = min (min_level, wfa->level_of_state [state] - 1); - max_level = max (max_level, wfa->level_of_state [state] - 1); - if (wfa->into [state][label][0] == 0) - dc = YES; - } - } - if (min_level > max_level) /* no lc found */ - max_level = min_level - 1; - if (d_min_level > d_max_level) - d_max_level = d_min_level - 1; - - /* - * Context model: - * 0 DC weight - * 1 Delta DC weight - * 2-k normal weights per level - * k+1 - m Delta weights per level - */ - - offset1 = dc ? 1 : 0; - offset2 = offset1 + (d_dc ? 1 : 0); - offset3 = offset2 + (max_level - min_level + 1); - offset4 = offset3 + (d_max_level - d_min_level + 1); + for (state = wfa->basis_states; state < wfa->states; state++) + for (label = 0; label < MAXLABELS; label++) + if (isrange (wfa->tree [state][label])) + { + if (delta_approx && wfa->delta_state [state]) /* delta approx. */ + { + d_min_level = MIN(d_min_level, wfa->level_of_state [state] - 1); + d_max_level = MAX(d_max_level, wfa->level_of_state [state] - 1); + if (wfa->into [state][label][0] == 0) + d_dc = YES; + } + else + { + min_level = MIN(min_level, wfa->level_of_state [state] - 1); + max_level = MAX(max_level, wfa->level_of_state [state] - 1); + if (wfa->into [state][label][0] == 0) + dc = YES; + } + } + if (min_level > max_level) /* no lc found */ + max_level = min_level - 1; + if (d_min_level > d_max_level) + d_max_level = d_min_level - 1; + + /* + * Context model: + * 0 DC weight + * 1 Delta DC weight + * 2-k normal weights per level + * k+1 - m Delta weights per level + */ + + offset1 = dc ? 1 : 0; + offset2 = offset1 + (d_dc ? 1 : 0); + offset3 = offset2 + (max_level - min_level + 1); + offset4 = offset3 + (d_max_level - d_min_level + 1); - /* - * Weights are encoded as follows: - * all weights of state n - * sorted by label - * sorted by domain number - */ - - wptr = weights_array = Calloc (total, sizeof (unsigned)); - lptr = level_array = Calloc (total, sizeof (unsigned)); - - for (state = wfa->basis_states; state < wfa->states; state++) - for (label = 0; label < MAXLABELS; label++) - if (isrange (wfa->tree [state][label])) - { - int edge; /* current edge */ - int domain; /* current domain (context of model) */ - - for (edge = 0; isedge (domain = wfa->into [state][label][edge]); - edge++) + /* + * Weights are encoded as follows: + * all weights of state n + * sorted by label + * sorted by domain number + */ + + wptr = weights_array = Calloc (total, sizeof (unsigned)); + lptr = level_array = Calloc (total, sizeof (unsigned)); + + for (state = wfa->basis_states; state < wfa->states; state++) + for (label = 0; label < MAXLABELS; label++) + if (isrange (wfa->tree [state][label])) { - if (wptr - weights_array >= (int) total) - error ("Can't write more than %d weights.", total); - if (domain) /* not DC component */ - { - if (delta_approx && wfa->delta_state [state]) /* delta */ - { - *wptr++ = rtob (wfa->weight [state][label][edge], - wfa->wfainfo->d_rpf); - *lptr++ = offset3 - + wfa->level_of_state [state] - 1 - d_min_level; - delta_count++; - } - else - { - *wptr++ = rtob (wfa->weight [state][label][edge], - wfa->wfainfo->rpf); - *lptr++ = offset2 - + wfa->level_of_state [state] - 1 - min_level; - } - } - else /* DC component */ - { - if (delta_approx && wfa->delta_state [state]) /* delta */ - { - *wptr++ = rtob (wfa->weight [state][label][edge], - wfa->wfainfo->d_dc_rpf); - *lptr++ = offset1; - } - else - { - *wptr++ = rtob (wfa->weight [state][label][edge], - wfa->wfainfo->dc_rpf); - *lptr++ = 0; - } - } + int edge; /* current edge */ + int domain; /* current domain (context of model) */ + + for (edge = 0; isedge (domain = wfa->into [state][label][edge]); + edge++) + { + if (wptr - weights_array >= (int) total) + error ("Can't write more than %d weights.", total); + if (domain) /* not DC component */ + { + if (delta_approx && wfa->delta_state [state]) /* delta */ + { + *wptr++ = rtob (wfa->weight [state][label][edge], + wfa->wfainfo->d_rpf); + *lptr++ = offset3 + + wfa->level_of_state [state] - 1 - d_min_level; + delta_count++; + } + else + { + *wptr++ = rtob (wfa->weight [state][label][edge], + wfa->wfainfo->rpf); + *lptr++ = offset2 + + wfa->level_of_state [state] - 1 - min_level; + } + } + else /* DC component */ + { + if (delta_approx && wfa->delta_state [state]) /* delta */ + { + *wptr++ = rtob (wfa->weight [state][label][edge], + wfa->wfainfo->d_dc_rpf); + *lptr++ = offset1; + } + else + { + *wptr++ = rtob (wfa->weight [state][label][edge], + wfa->wfainfo->dc_rpf); + *lptr++ = 0; + } + } + } } - } - - { - unsigned i; - unsigned *c_symbols = Calloc (offset4, sizeof (int)); - const int scale = 500; /* scaling of probability model */ - - c_symbols [0] = 1 << (wfa->wfainfo->dc_rpf->mantissa_bits + 1); - if (offset1 != offset2) - c_symbols [offset1] = 1 << (wfa->wfainfo->d_dc_rpf->mantissa_bits - + 1); - for (i = offset2; i < offset3; i++) - c_symbols [i] = 1 << (wfa->wfainfo->rpf->mantissa_bits + 1); - for (; i < offset4; i++) - c_symbols [i] = 1 << (wfa->wfainfo->d_rpf->mantissa_bits + 1); + + { + unsigned i; + unsigned *c_symbols = Calloc (offset4, sizeof (int)); + const int scale = 500; /* scaling of probability model */ + + c_symbols [0] = 1 << (wfa->wfainfo->dc_rpf->mantissa_bits + 1); + if (offset1 != offset2) + c_symbols [offset1] = 1 << (wfa->wfainfo->d_dc_rpf->mantissa_bits + + 1); + for (i = offset2; i < offset3; i++) + c_symbols [i] = 1 << (wfa->wfainfo->rpf->mantissa_bits + 1); + for (; i < offset4; i++) + c_symbols [i] = 1 << (wfa->wfainfo->d_rpf->mantissa_bits + 1); - encode_array (output, weights_array, level_array, c_symbols, offset4, - total, scale); - Free (c_symbols); - } + encode_array (output, weights_array, level_array, c_symbols, offset4, + total, scale); + Free (c_symbols); + } - debug_message ("%d delta weights out of %d.", delta_count, total); - debug_message ("weights: %5d bits. (%5d symbols => %5.2f bps)", - bits_processed (output) - bits, total, - (bits_processed (output) - bits) / (double) total); + debug_message ("%d delta weights out of %d.", delta_count, total); + debug_message ("weights: %5d bits. (%5d symbols => %5.2f bps)", + bits_processed (output) - bits, total, + (bits_processed (output) - bits) / (double) total); - Free (weights_array); - Free (level_array); + Free (weights_array); + Free (level_array); } + + + diff --git a/converter/other/fiasco/params.c b/converter/other/fiasco/params.c index 7a302b82..afacbada 100644 --- a/converter/other/fiasco/params.c +++ b/converter/other/fiasco/params.c @@ -30,6 +30,7 @@ #include <getopt.h> /* system or ../lib */ +#include "pm_c_util.h" #include "nstring.h" #include "types.h" @@ -631,6 +632,8 @@ read_parameter_file (param_t *params, FILE *file) } } + + static void usage (const param_t *params, const char *progname, const char *synopsis, const char *comment, const char *non_opt_string, @@ -647,82 +650,84 @@ usage (const param_t *params, const char *progname, const char *synopsis, * No return value. */ { - int i; - size_t width = 0; + int i; + size_t width = 0; - fprintf (stderr, "Usage: %s [OPTION]...%s\n", progname, - non_opt_string ? non_opt_string : " "); - if (synopsis != NULL) - fprintf (stderr, synopsis); - fprintf (stderr, "\n\n"); - fprintf (stderr, "Mandatory or optional arguments to long options " - "are mandatory or optional\nfor short options too. " - "Default values are surrounded by {}.\n"); - for (i = 0; params [i].name != NULL; i++) - if (params [i].optchar != '\0' || show_all_options) - { - if (params [i].type == POSTR) - width = max (width, (strlen (params [i].name) - + strlen (params [i].argument_name) + 2)); - else if (params [i].type != PFLAG) - width = max (width, (strlen (params [i].name) - + strlen (params [i].argument_name))); - else - width = max (width, (strlen (params [i].name)) - 1); - } + fprintf (stderr, "Usage: %s [OPTION]...%s\n", progname, + non_opt_string ? non_opt_string : " "); + if (synopsis != NULL) + fprintf (stderr, "%s", synopsis); + fprintf (stderr, "\n\n"); + fprintf (stderr, "Mandatory or optional arguments to long options " + "are mandatory or optional\nfor short options too. " + "Default values are surrounded by {}.\n"); + for (i = 0; params [i].name != NULL; i++) + if (params [i].optchar != '\0' || show_all_options) + { + if (params [i].type == POSTR) + width = MAX(width, (strlen (params [i].name) + + strlen (params [i].argument_name) + 2)); + else if (params [i].type != PFLAG) + width = MAX(width, (strlen (params [i].name) + + strlen (params [i].argument_name))); + 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) - { - if (params [i].optchar != '\0') - fprintf (stderr, " -%c, --", params [i].optchar); - else - fprintf (stderr, " --"); + for (i = 0; params [i].name != NULL; i++) + if (params [i].optchar != '\0' || show_all_options) + { + if (params [i].optchar != '\0') + 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, - max (0, (width - 2 - strlen (params [i].name) - - strlen (params [i].argument_name))), ""); - else if (params [i].type != PFLAG) - fprintf (stderr, "%s=%-*s ", params [i].name, - width - strlen (params [i].name), - params [i].argument_name); - else - fprintf (stderr, "%-*s ", width + 1, params [i].name); - - fprintf (stderr, params [i].use, params [i].argument_name); + if (params [i].type == POSTR) + fprintf (stderr, "%s=[%s]%-*s ", params [i].name, + params [i].argument_name, + (unsigned) + MAX(0, (width - 2 - strlen (params [i].name) + - strlen (params [i].argument_name))), ""); + else if (params [i].type != PFLAG) + fprintf (stderr, "%s=%-*s ", params [i].name, + (unsigned)(width - strlen (params [i].name)), + params [i].argument_name); + else + fprintf (stderr, "%-*s ", + (unsigned)(width + 1), params [i].name); + + fprintf (stderr, params [i].use, params [i].argument_name); - switch (params [i].type) - { - case PFLAG: - break; - case PINT: - fprintf (stderr, "{%d}", params [i].value.i); - break; - case PFLOAT: - fprintf (stderr, "{%.2f}", (double) params [i].value.f); - break; - case PSTR: - case POSTR: - if (params [i].value.s) - fprintf (stderr, "{%s}", params [i].value.s); - break; - default: - error ("type %d for %s invalid", - params [i].type, params [i].name); - } - fprintf (stderr, "\n"); - } - fprintf (stderr, "\n"); - fprintf (stderr, "Parameter initialization order:\n"); - fprintf (stderr, - "1.) %s\n2.) $HOME/%s\t 3.) command line\t 4.) --config=file", - sys_file_name, usr_file_name); - fprintf (stderr, "\n\n"); - if (comment != NULL) - fprintf (stderr, "%s\n", comment); - - exit (1); + switch (params [i].type) + { + case PFLAG: + break; + case PINT: + fprintf (stderr, "{%d}", params [i].value.i); + break; + case PFLOAT: + fprintf (stderr, "{%.2f}", (double) params [i].value.f); + break; + case PSTR: + case POSTR: + if (params [i].value.s) + fprintf (stderr, "{%s}", params [i].value.s); + break; + default: + error ("type %d for %s invalid", + params [i].type, params [i].name); + } + fprintf (stderr, "\n"); + } + fprintf (stderr, "\n"); + fprintf (stderr, "Parameter initialization order:\n"); + fprintf (stderr, + "1.) %s\n2.) $HOME/%s\t 3.) command line\t 4.) --config=file", + sys_file_name, usr_file_name); + fprintf (stderr, "\n\n"); + if (comment != NULL) + fprintf (stderr, "%s\n", comment); + + exit (1); } diff --git a/converter/other/fiasco/pnmtofiasco.c b/converter/other/fiasco/pnmtofiasco.c index 2218256d..eebd09a9 100644 --- a/converter/other/fiasco/pnmtofiasco.c +++ b/converter/other/fiasco/pnmtofiasco.c @@ -1,8 +1,8 @@ /* - * cwfa.c: FIASCO coder + * cwfa.c: FIASCO coder * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO («F»ractal «I»mage «A»nd «S»equence «CO»dec) * Copyright (C) 1994-2000 Ullrich Hafner <hafner@bigfoot.de> */ @@ -15,18 +15,12 @@ */ #include "config.h" +#include "pm_c_util.h" #include "pnm.h" -#if STDC_HEADERS -# include <stdlib.h> -# include <string.h> -#else /* not STDC_HEADERS */ -# if HAVE_STRING_H -# include <string.h> -# else /* not HAVE_STRING_H */ -# include <strings.h> -# endif /* not HAVE_STRING_H */ -#endif /* not STDC_HEADERS */ +#include <stdlib.h> +#include <string.h> +#include <string.h> #include "types.h" #include "macros.h" @@ -38,7 +32,7 @@ /***************************************************************************** - local variables + local variables *****************************************************************************/ @@ -144,27 +138,27 @@ static param_t params [] = /***************************************************************************** - prototypes + prototypes *****************************************************************************/ static void checkargs (int argc, char **argv, char const ***image_template, - char **wfa_name, float *quality, fiasco_c_options_t **options); + char **wfa_name, float *quality, fiasco_c_options_t **options); /***************************************************************************** - public code + public code *****************************************************************************/ int main (int argc, char **argv) { - char const **image_template; /* template for input image files */ - char *wfa_name; /* filename of output WFA */ - float quality; /* approximation quality */ - fiasco_c_options_t *options; /* additional coder options */ + char const **image_template; /* template for input image files */ + char *wfa_name; /* filename of output WFA */ + float quality; /* approximation quality */ + fiasco_c_options_t *options; /* additional coder options */ pnm_init(&argc, argv); @@ -176,7 +170,7 @@ main (int argc, char **argv) return 0; else { - fprintf (stderr, fiasco_get_error_message ()); + fprintf (stderr, "%s", fiasco_get_error_message ()); fprintf (stderr, "\n"); return 1; } @@ -184,228 +178,228 @@ main (int argc, char **argv) /***************************************************************************** - private code + private code *****************************************************************************/ static void checkargs (int argc, char **argv, char const ***image_template, - char **wfa_name, float *quality, fiasco_c_options_t **options) + char **wfa_name, float *quality, fiasco_c_options_t **options) /* * Check validness of command line parameters and of the parameter files. * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise * * * Side effects: - * 'image_template', 'wfa_name', 'quality' and 'options' are set. + * 'image_template', 'wfa_name', 'quality' and 'options' are set. */ { - int optind; /* last processed commandline param */ - char *image_name; /* filename given by option '-i' */ - int i; /* counter */ + int optind; /* last processed commandline param */ + char *image_name; /* filename given by option '--input_name' */ + int i; /* counter */ - optind = parseargs (params, argc, argv, - "Compress raw PPM/PGM image FILEs to a FIASCO file.", - "With no image FILE, or if FILE is -, " - "read standard input.\n" - "FILE must be either a filename" - " or an image template of the form:\n" - "`prefix[start-end{+,-}step]suffix'\n" - "e.g., img0[12-01-1].pgm is substituted by" - " img012.pgm ... img001.pgm\n\n" - "Environment:\n" - "FIASCO_DATA Search and save path for FIASCO files. " - "Default: ./\n" - "FIASCO_IMAGES Search path for image files. " - "Default: ./", " [FILE]...", - FIASCO_SHARE, "system.fiascorc", ".fiascorc"); + optind = parseargs (params, argc, argv, + "Compress raw PPM/PGM image FILEs to a FIASCO file.", + "With no image FILE, or if FILE is -, " + "read standard input.\n" + "FILE must be either a filename" + " or an image template of the form:\n" + "`prefix[start-end{+,-}step]suffix'\n" + "e.g., img0[12-01-1].pgm is substituted by" + " img012.pgm ... img001.pgm\n\n" + "Environment:\n" + "FIASCO_DATA Search and save path for FIASCO files. " + "Default: ./\n" + "FIASCO_IMAGES Search path for image files. " + "Default: ./", " [FILE]...", + FIASCO_SHARE, "system.fiascorc", ".fiascorc"); - /* - * Default options ... - */ - image_name = (char *) parameter_value (params, "image-name"); - *wfa_name = (char *) parameter_value (params, "output-name"); - for (;;) - { - *quality = * (float *) parameter_value (params, "quality"); - if (*quality > 100) - fprintf (stderr, "Typical range of quality: (0,100].\n" - "Expect some trouble on slow machines.\n"); - if (*quality > 0) - break; - ask_and_set (params, "quality", - "Please enter coding quality 'q' ('q' > 0): "); - } + /* + * Default options ... + */ + image_name = (char *) parameter_value (params, "image-name"); + *wfa_name = (char *) parameter_value (params, "output-name"); + for (;;) + { + *quality = * (float *) parameter_value (params, "quality"); + if (*quality > 100) + fprintf (stderr, "Typical range of quality: (0,100].\n" + "Expect some trouble on slow machines.\n"); + if (*quality > 0) + break; + ask_and_set (params, "quality", + "Please enter coding quality 'q' ('q' > 0): "); + } - if (optind < argc) /* Additional command line param */ - { - if (image_name) - error ("Multiple image_template arguments." - "\nOption -i %s already specified!", image_name); + if (optind < argc) /* Additional command line param */ + { + if (image_name) + error ("Multiple image_template arguments." + "\nOption --input-name %s already specified!", image_name); - *image_template = calloc (argc - optind + 1, sizeof (char *)); - if (!*image_template) - error ("Out of memory."); - for (i = 0; optind < argc; i++, optind++) - (*image_template) [i] = argv [optind]; - (*image_template) [i] = NULL; - } - else /* option -i image_name */ - { - *image_template = calloc (2, sizeof (char *)); - if (!*image_template) - error ("Out of memory."); - (*image_template) [0] = image_name; - (*image_template) [1] = NULL; - } - /* - * Additional options ... (have to be set with the fiasco_set_... methods) - */ - { - *options = fiasco_c_options_new (); + *image_template = calloc (argc - optind + 1, sizeof (char *)); + if (!*image_template) + error ("Out of memory."); + for (i = 0; optind < argc; i++, optind++) + (*image_template) [i] = argv [optind]; + (*image_template) [i] = NULL; + } + else /* option -i image_name */ + { + *image_template = calloc (2, sizeof (char *)); + if (!*image_template) + error ("Out of memory."); + (*image_template) [0] = image_name; + (*image_template) [1] = NULL; + } + /* + * Additional options ... (have to be set with the fiasco_set_... methods) + */ + { + *options = fiasco_c_options_new (); - { - char *pattern = (char *) parameter_value (params, "pattern"); + { + char *pattern = (char *) parameter_value (params, "pattern"); - if (!fiasco_c_options_set_frame_pattern (*options, pattern)) - error (fiasco_get_error_message ()); - } + if (!fiasco_c_options_set_frame_pattern (*options, pattern)) + error (fiasco_get_error_message ()); + } - { - char *basis = (char *) parameter_value (params, "basis-name"); - - if (!fiasco_c_options_set_basisfile (*options, basis)) - error (fiasco_get_error_message ()); - } + { + char *basis = (char *) parameter_value (params, "basis-name"); + + if (!fiasco_c_options_set_basisfile (*options, basis)) + error (fiasco_get_error_message ()); + } - { - int n = * (int *) parameter_value (params, "chroma-dictionary"); - float q = * (float *) parameter_value (params, "chroma-qfactor"); + { + int n = * (int *) parameter_value (params, "chroma-dictionary"); + float q = * (float *) parameter_value (params, "chroma-qfactor"); - if (!fiasco_c_options_set_chroma_quality (*options, q, max (0, n))) - error (fiasco_get_error_message ()); - } + if (!fiasco_c_options_set_chroma_quality (*options, q, MAX(0, n))) + error (fiasco_get_error_message ()); + } - { - int n = *((int *) parameter_value (params, "smooth")); - - if (!fiasco_c_options_set_smoothing (*options, max (0, n))) - error (fiasco_get_error_message ()); - } + { + int n = *((int *) parameter_value (params, "smooth")); + + if (!fiasco_c_options_set_smoothing (*options, MAX(0, n))) + error (fiasco_get_error_message ()); + } - { - int n = * (int *) parameter_value (params, "progress-meter"); - fiasco_progress_e type = (n < 0) ? - FIASCO_PROGRESS_NONE : (fiasco_progress_e) n; + { + int n = * (int *) parameter_value (params, "progress-meter"); + fiasco_progress_e type = (n < 0) ? + FIASCO_PROGRESS_NONE : (fiasco_progress_e) n; - if (!fiasco_c_options_set_progress_meter (*options, type)) - error (fiasco_get_error_message ()); - } + if (!fiasco_c_options_set_progress_meter (*options, type)) + error (fiasco_get_error_message ()); + } - { - char *t = (char *) parameter_value (params, "title"); - - if (strlen (t) > 0 && !fiasco_c_options_set_title (*options, t)) - error (fiasco_get_error_message ()); - } + { + char *t = (char *) parameter_value (params, "title"); + + if (strlen (t) > 0 && !fiasco_c_options_set_title (*options, t)) + error (fiasco_get_error_message ()); + } - { - char *c = (char *) parameter_value (params, "comment"); + { + char *c = (char *) parameter_value (params, "comment"); - if (strlen (c) > 0 && !fiasco_c_options_set_comment (*options, c)) - error (fiasco_get_error_message ()); - } + if (strlen (c) > 0 && !fiasco_c_options_set_comment (*options, c)) + error (fiasco_get_error_message ()); + } - { - fiasco_tiling_e method = FIASCO_TILING_VARIANCE_DSC; - int e = * (int *) parameter_value (params, "tiling-exponent"); - char *m = (char *) parameter_value (params, "tiling-method"); + { + fiasco_tiling_e method = FIASCO_TILING_VARIANCE_DSC; + int e = * (int *) parameter_value (params, "tiling-exponent"); + char *m = (char *) parameter_value (params, "tiling-method"); - if (strcaseeq (m, "desc-variance")) - method = FIASCO_TILING_VARIANCE_DSC; - else if (strcaseeq (m, "asc-variance")) - method = FIASCO_TILING_VARIANCE_ASC; - else if (strcaseeq (m, "asc-spiral")) - method = FIASCO_TILING_SPIRAL_ASC; - else if (strcaseeq (m, "dsc-spiral")) - method = FIASCO_TILING_SPIRAL_DSC; - else - error (_("Invalid tiling method `%s' specified."), m); + if (strcaseeq (m, "desc-variance")) + method = FIASCO_TILING_VARIANCE_DSC; + else if (strcaseeq (m, "asc-variance")) + method = FIASCO_TILING_VARIANCE_ASC; + else if (strcaseeq (m, "asc-spiral")) + method = FIASCO_TILING_SPIRAL_ASC; + else if (strcaseeq (m, "dsc-spiral")) + method = FIASCO_TILING_SPIRAL_DSC; + else + error (_("Invalid tiling method `%s' specified."), m); - if (!fiasco_c_options_set_tiling (*options, method, max (0, e))) - error (fiasco_get_error_message ()); - } + if (!fiasco_c_options_set_tiling (*options, method, MAX(0, e))) + error (fiasco_get_error_message ()); + } - { - int M/* = * (int *) parameter_value (params, "max-level") */; - int m/* = * (int *) parameter_value (params, "min-level") */; - int N/* = * (int *) parameter_value (params, "max-elements") */; - int D = * (int *) parameter_value (params, "dictionary-size"); - int o = * (int *) parameter_value (params, "optimize"); + { + int M/* = * (int *) parameter_value (params, "max-level") */; + int m/* = * (int *) parameter_value (params, "min-level") */; + int N/* = * (int *) parameter_value (params, "max-elements") */; + int D = * (int *) parameter_value (params, "dictionary-size"); + int o = * (int *) parameter_value (params, "optimize"); - if (o <= 0) - { - o = 0; - M = 10; - m = 6; - N = 3; - } - else - { - o -= 1; - M = 12; - m = 4; - N = 5; - } - - if (!fiasco_c_options_set_optimizations (*options, m, M, N, - max (0, D), o)) - error (fiasco_get_error_message ()); - } - { - int M = * (int *) parameter_value (params, "max-level"); - int m = * (int *) parameter_value (params, "min-level"); - int p = * (int *) parameter_value (params, "prediction"); - - if (!fiasco_c_options_set_prediction (*options, - p, max (0, m), max (0, M))) - error (fiasco_get_error_message ()); - } - { - float r = * (float *) parameter_value (params, "rpf-range"); - float dc_r = * (float *) parameter_value (params, "dc-rpf-range"); - int m = * (int *) parameter_value (params, "rpf-mantissa"); - int dc_m = * (int *) parameter_value (params, "dc-rpf-mantissa"); - fiasco_rpf_range_e range, dc_range; - - if (r < 1) - range = FIASCO_RPF_RANGE_0_75; - else if (r < 1.5) - range = FIASCO_RPF_RANGE_1_00; - else if (r < 2.0) - range = FIASCO_RPF_RANGE_1_50; - else - range = FIASCO_RPF_RANGE_2_00; - - if (dc_r < 1) - dc_range = FIASCO_RPF_RANGE_0_75; - else if (dc_r < 1.5) - dc_range = FIASCO_RPF_RANGE_1_00; - else if (dc_r < 2.0) - dc_range = FIASCO_RPF_RANGE_1_50; - else - dc_range = FIASCO_RPF_RANGE_2_00; - - if (!fiasco_c_options_set_quantization (*options, - max (0, m), range, - max (0, dc_m), dc_range)) - error (fiasco_get_error_message ()); - } + if (o <= 0) + { + o = 0; + M = 10; + m = 6; + N = 3; + } + else + { + o -= 1; + M = 12; + m = 4; + N = 5; + } + + if (!fiasco_c_options_set_optimizations (*options, m, M, N, + MAX(0, D), o)) + error (fiasco_get_error_message ()); + } + { + int M = * (int *) parameter_value (params, "max-level"); + int m = * (int *) parameter_value (params, "min-level"); + int p = * (int *) parameter_value (params, "prediction"); + + if (!fiasco_c_options_set_prediction (*options, + p, MAX(0, m), MAX(0, M))) + error (fiasco_get_error_message ()); + } + { + float r = * (float *)parameter_value(params, "rpf-range"); + float dc_r = * (float *)parameter_value(params, "dc-rpf-range"); + int m = * (int *) parameter_value(params, "rpf-mantissa"); + int dc_m = * (int *) parameter_value(params, "dc-rpf-mantissa"); + fiasco_rpf_range_e range, dc_range; + + if (r < 1) + range = FIASCO_RPF_RANGE_0_75; + else if (r < 1.5) + range = FIASCO_RPF_RANGE_1_00; + else if (r < 2.0) + range = FIASCO_RPF_RANGE_1_50; + else + range = FIASCO_RPF_RANGE_2_00; + + if (dc_r < 1) + dc_range = FIASCO_RPF_RANGE_0_75; + else if (dc_r < 1.5) + dc_range = FIASCO_RPF_RANGE_1_00; + else if (dc_r < 2.0) + dc_range = FIASCO_RPF_RANGE_1_50; + else + dc_range = FIASCO_RPF_RANGE_2_00; + + if (!fiasco_c_options_set_quantization (*options, + MAX(0, m), range, + MAX(0, dc_m), dc_range)) + error (fiasco_get_error_message ()); + } - if (fiasco_get_verbosity () == FIASCO_ULTIMATE_VERBOSITY) - write_parameters (params, stderr); - } -} + if (fiasco_get_verbosity () == FIASCO_ULTIMATE_VERBOSITY) + write_parameters (params, stderr); + } +} |