diff options
163 files changed, 16793 insertions, 16793 deletions
diff --git a/converter/other/fiasco/binerror.c b/converter/other/fiasco/binerror.c index 9820d853..dd40dc9b 100644 --- a/converter/other/fiasco/binerror.c +++ b/converter/other/fiasco/binerror.c @@ -1,11 +1,11 @@ /* - * error.c: Error handling + * error.c: Error handling * - * Written by: Stefan Frank - * Ullrich Hafner - * - * Credits: Modelled after variable argument routines from Jef - * Poskanzer's pbmplus package. + * Written by: Stefan Frank + * Ullrich Hafner + * + * Credits: Modelled after variable argument routines from Jef + * Poskanzer's pbmplus package. * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -29,16 +29,16 @@ #include <stdio.h> #if STDC_HEADERS -# include <stdarg.h> -# define VA_START(args, lastarg) va_start(args, lastarg) +# 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) +# include <varargs.h> +# define VA_START(args, lastarg) va_start(args) #endif /* not STDC_HEADERS */ #include <string.h> #if HAVE_SETJMP_H -# include <setjmp.h> +# include <setjmp.h> #endif /* HAVE_SETJMP_H */ #include "fiasco.h" @@ -46,8 +46,8 @@ /***************************************************************************** - global variables - + global variables + *****************************************************************************/ int error_line = 0; @@ -55,16 +55,16 @@ const char *error_file = NULL; /***************************************************************************** - local variables - + local variables + *****************************************************************************/ static const char *executable = "(name not initialized)"; /***************************************************************************** - public code - + public code + *****************************************************************************/ void @@ -87,12 +87,12 @@ _error (const char *format, ...) * No return value. */ { - va_list args; + va_list args; VA_START (args, format); fprintf (stderr, "%s: %s: line %d:\nError: ", - executable, error_file, error_line); + executable, error_file, error_line); vfprintf (stderr, format, args); fputc ('\n', stderr); va_end(args); @@ -109,13 +109,13 @@ _file_error (const char *filename) */ { fprintf (stderr, "%s: %s: line %d:\nError: ", - executable, error_file, error_line); + executable, error_file, error_line); perror (filename); exit (2); } -void +void _warning (const char *format, ...) /* * Issue a warning and continue execution. @@ -128,7 +128,7 @@ _warning (const char *format, ...) VA_START (args, format); fprintf (stderr, "%s: %s: line %d:\nWarning: ", - executable, error_file, error_line); + executable, error_file, error_line); vfprintf (stderr, format, args); fputc ('\n', stderr); diff --git a/converter/other/fiasco/binerror.h b/converter/other/fiasco/binerror.h index 4f313aca..b30f53e0 100644 --- a/converter/other/fiasco/binerror.h +++ b/converter/other/fiasco/binerror.h @@ -1,8 +1,8 @@ /* * error.h - * - * Written by: Stefan Frank - * Ullrich Hafner + * + * Written by: Stefan Frank + * Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -25,7 +25,7 @@ #ifdef _ERROR_C #define _EXTERN_TYPE #else -#define _EXTERN_TYPE extern +#define _EXTERN_TYPE extern #endif _EXTERN_TYPE int error_line; @@ -41,9 +41,9 @@ void _file_error (const char *filename); #if HAVE_ASSERT_H -# include <assert.h> +# include <assert.h> #else /* not HAVE_ASSERT_H */ -# define assert(exp) {if (!(exp)) error ("Assertion `" #exp " != NULL' failed.");} +# define assert(exp) {if (!(exp)) error ("Assertion `" #exp " != NULL' failed.");} #endif /* not HAVE_ASSERT_H */ #endif /* not _ERROR_H */ diff --git a/converter/other/fiasco/buttons.c b/converter/other/fiasco/buttons.c index fc54d84a..7a6c77a3 100644 --- a/converter/other/fiasco/buttons.c +++ b/converter/other/fiasco/buttons.c @@ -1,8 +1,8 @@ /* - * buttons.c: Draw MWFA player buttons in X11 window + * buttons.c: Draw MWFA player buttons in X11 window + * + * Written by: Ullrich Hafner * - * Written by: Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -23,7 +23,7 @@ #include <X11/StringDefs.h> #if STDC_HEADERS -# include <stdlib.h> +# include <stdlib.h> #endif /* not STDC_HEADERS */ #include "types.h" @@ -35,38 +35,38 @@ /***************************************************************************** - local variables - + local variables + *****************************************************************************/ static const int EVENT_MASK = (KeyPressMask | ButtonPressMask | - ButtonReleaseMask | ExposureMask); + ButtonReleaseMask | ExposureMask); /***************************************************************************** - prototypes - + prototypes + *****************************************************************************/ static void draw_progress_bar (x11_info_t *xinfo, binfo_t *binfo, unsigned n, - unsigned n_frames); + unsigned n_frames); static void draw_button (x11_info_t *xinfo, binfo_t *binfo, - buttons_t button, bool_t pressed); + buttons_t button, bool_t pressed); static void draw_control_panel (x11_info_t *xinfo, binfo_t *binfo, - unsigned n, unsigned n_frames); + unsigned n, unsigned n_frames); /***************************************************************************** - public code - + public code + *****************************************************************************/ -binfo_t * +binfo_t * init_buttons (x11_info_t *xinfo, unsigned n, unsigned n_frames, - unsigned buttons_height, unsigned progbar_height) + unsigned buttons_height, unsigned progbar_height) /* * Initialize a toolbar with the typical collection of video player * buttons (pause, play, record, next, etc.) in the window given by 'xinfo'. @@ -76,7 +76,7 @@ init_buttons (x11_info_t *xinfo, unsigned n, unsigned n_frames, * the size of the progressbar is given by 'progbar_height'. * * Return value: - * struct managing the toolbar and progressbar information + * struct managing the toolbar and progressbar information */ { XGCValues values; @@ -84,12 +84,12 @@ init_buttons (x11_info_t *xinfo, unsigned n, unsigned n_frames, Colormap cmap; XColor gray, dgray, lgray, red; XColor graye, dgraye, lgraye, rede; - buttons_t button; /* counter */ + buttons_t button; /* counter */ binfo_t *binfo = calloc (1, sizeof (binfo_t)); if (!binfo) error ("Out of memory."); - + binfo->width = xinfo->ximage->width; binfo->height = buttons_height; binfo->progbar_height = progbar_height; @@ -99,12 +99,12 @@ init_buttons (x11_info_t *xinfo, unsigned n, unsigned n_frames, * Generate sub-window for control panel */ binfo->window = XCreateSimpleWindow (xinfo->display, xinfo->window, - 0, xinfo->ximage->height, - binfo->width, binfo->height, 0, - BlackPixel (xinfo->display, - xinfo->screen), - WhitePixel (xinfo->display, - xinfo->screen)); + 0, xinfo->ximage->height, + binfo->width, binfo->height, 0, + BlackPixel (xinfo->display, + xinfo->screen), + WhitePixel (xinfo->display, + xinfo->screen)); XSelectInput(xinfo->display, binfo->window, StructureNotifyMask); XMapWindow (xinfo->display, binfo->window); do @@ -122,47 +122,47 @@ init_buttons (x11_info_t *xinfo, unsigned n, unsigned n_frames, XAllocNamedColor (xinfo->display, cmap, "white", &lgray, &lgraye); XAllocNamedColor (xinfo->display, cmap, "#a8a8a8", &gray, &graye); XAllocNamedColor (xinfo->display, cmap, "red", &red, &rede); - + values.foreground = BlackPixel (xinfo->display, xinfo->screen); values.background = WhitePixel (xinfo->display, xinfo->screen); binfo->gc [BLACK] = XCreateGC (xinfo->display, - RootWindow (xinfo->display, xinfo->screen), - (GCForeground | GCBackground), &values); + RootWindow (xinfo->display, xinfo->screen), + (GCForeground | GCBackground), &values); values.foreground = BlackPixel (xinfo->display, xinfo->screen); values.background = WhitePixel (xinfo->display, xinfo->screen); values.line_width = 3; values.join_style = JoinRound; binfo->gc [THICKBLACK] = XCreateGC (xinfo->display, - RootWindow (xinfo->display, - xinfo->screen), - (GCForeground | GCBackground - | GCLineWidth | GCJoinStyle), &values); + RootWindow (xinfo->display, + xinfo->screen), + (GCForeground | GCBackground + | GCLineWidth | GCJoinStyle), &values); values.foreground = gray.pixel; values.background = WhitePixel (xinfo->display, xinfo->screen); binfo->gc [NGRAY] = XCreateGC (xinfo->display, - RootWindow (xinfo->display, xinfo->screen), - (GCForeground | GCBackground), &values); + RootWindow (xinfo->display, xinfo->screen), + (GCForeground | GCBackground), &values); values.foreground = lgray.pixel; values.background = WhitePixel (xinfo->display, xinfo->screen); binfo->gc [LGRAY] = XCreateGC (xinfo->display, - RootWindow (xinfo->display, xinfo->screen), - (GCForeground | GCBackground), &values); + RootWindow (xinfo->display, xinfo->screen), + (GCForeground | GCBackground), &values); values.foreground = dgray.pixel; values.background = WhitePixel (xinfo->display, xinfo->screen); binfo->gc [DGRAY] = XCreateGC (xinfo->display, - RootWindow (xinfo->display, xinfo->screen), - (GCForeground | GCBackground), &values); + RootWindow (xinfo->display, xinfo->screen), + (GCForeground | GCBackground), &values); values.foreground = red.pixel; values.background = WhitePixel (xinfo->display, xinfo->screen); binfo->gc [RED] = XCreateGC (xinfo->display, - RootWindow (xinfo->display, xinfo->screen), - (GCForeground | GCBackground), &values); + RootWindow (xinfo->display, xinfo->screen), + (GCForeground | GCBackground), &values); for (button = 0; button < NO_BUTTON; button++) binfo->pressed [button] = NO; - draw_control_panel (xinfo, binfo, n, n_frames); - + draw_control_panel (xinfo, binfo, n, n_frames); + return binfo; } @@ -176,11 +176,11 @@ wait_for_input (x11_info_t *xinfo) * No return value. * * Side effect: - * program is terminated after key press or mouse click. + * program is terminated after key press or mouse click. */ { bool_t leave_loop = NO; - + XSelectInput (xinfo->display, xinfo->window, EVENT_MASK); while (!leave_loop) @@ -190,13 +190,13 @@ wait_for_input (x11_info_t *xinfo) XMaskEvent (xinfo->display, EVENT_MASK, &event); switch (event.type) { - case ButtonPress: - case KeyPress: - leave_loop = YES; - break; - default: - display_image (0, 0, xinfo); - break; + case ButtonPress: + case KeyPress: + leave_loop = YES; + break; + default: + display_image (0, 0, xinfo); + break; } } } @@ -214,17 +214,17 @@ check_events (x11_info_t *xinfo, binfo_t *binfo, unsigned n, unsigned n_frames) * No return values. * * Side effects: - * status of buttons (binfo->pressed [button]) is changed accordingly. + * status of buttons (binfo->pressed [button]) is changed accordingly. */ { bool_t leave_eventloop; leave_eventloop = (!binfo->pressed [PAUSE_BUTTON] - && binfo->pressed [PLAY_BUTTON]) - || (!binfo->pressed [PAUSE_BUTTON] - && binfo->record_is_rewind - && binfo->pressed [RECORD_BUTTON]) - || binfo->pressed [RECORD_BUTTON]; + && binfo->pressed [PLAY_BUTTON]) + || (!binfo->pressed [PAUSE_BUTTON] + && binfo->record_is_rewind + && binfo->pressed [RECORD_BUTTON]) + || binfo->pressed [RECORD_BUTTON]; draw_progress_bar (xinfo, binfo, n, n_frames); if (binfo->pressed [PAUSE_BUTTON] && binfo->pressed [PLAY_BUTTON]) @@ -253,48 +253,48 @@ check_events (x11_info_t *xinfo, binfo_t *binfo, unsigned n, unsigned n_frames) XEvent event; int button; bool_t wait_release = NO; - - + + if (XCheckMaskEvent (xinfo->display, EVENT_MASK, &event)) { - switch (event.type) - { - case ButtonPress: - wait_release = NO; - if (!(binfo->pressed [RECORD_BUTTON] && - !binfo->record_is_rewind)) - for (button = 0; button < NO_BUTTON; button++) - { - int x0, y0, x1, y1; /* button coordinates */ - - x0 = button * (binfo->width / NO_BUTTON); - y0 = binfo->progbar_height; - x1 = x0 + binfo->width / NO_BUTTON; - y1 = y0 + binfo->height - binfo->progbar_height - 1; - if (event.xbutton.x > x0 && event.xbutton.x < x1 - && event.xbutton.y > y0 && event.xbutton.y < y1) - { - draw_button (xinfo, binfo, button, - !binfo->pressed [button]); - wait_release = YES; - break; - } - } - break; - case ButtonRelease: - wait_release = NO; - break; - default: - wait_release = NO; - draw_control_panel (xinfo, binfo, n, n_frames); - display_image (0, 0, xinfo); - break; - } - leave_eventloop = !wait_release - && (binfo->pressed [PLAY_BUTTON] - || binfo->pressed [STOP_BUTTON] - || binfo->pressed [RECORD_BUTTON] - || binfo->pressed [QUIT_BUTTON]); + switch (event.type) + { + case ButtonPress: + wait_release = NO; + if (!(binfo->pressed [RECORD_BUTTON] && + !binfo->record_is_rewind)) + for (button = 0; button < NO_BUTTON; button++) + { + int x0, y0, x1, y1; /* button coordinates */ + + x0 = button * (binfo->width / NO_BUTTON); + y0 = binfo->progbar_height; + x1 = x0 + binfo->width / NO_BUTTON; + y1 = y0 + binfo->height - binfo->progbar_height - 1; + if (event.xbutton.x > x0 && event.xbutton.x < x1 + && event.xbutton.y > y0 && event.xbutton.y < y1) + { + draw_button (xinfo, binfo, button, + !binfo->pressed [button]); + wait_release = YES; + break; + } + } + break; + case ButtonRelease: + wait_release = NO; + break; + default: + wait_release = NO; + draw_control_panel (xinfo, binfo, n, n_frames); + display_image (0, 0, xinfo); + break; + } + leave_eventloop = !wait_release + && (binfo->pressed [PLAY_BUTTON] + || binfo->pressed [STOP_BUTTON] + || binfo->pressed [RECORD_BUTTON] + || binfo->pressed [QUIT_BUTTON]); } } while (!leave_eventloop); @@ -308,13 +308,13 @@ check_events (x11_info_t *xinfo, binfo_t *binfo, unsigned n, unsigned n_frames) /***************************************************************************** - private code - + private code + *****************************************************************************/ static void draw_control_panel (x11_info_t *xinfo, binfo_t *binfo, - unsigned n, unsigned n_frames) + unsigned n, unsigned n_frames) /* * Draw control panel 'binfo' with all buttons and progressbar in * the given 'window'. @@ -325,9 +325,9 @@ draw_control_panel (x11_info_t *xinfo, binfo_t *binfo, */ { buttons_t button; - + XFillRectangle (xinfo->display, binfo->window, binfo->gc [NGRAY], - 0, 0, binfo->width, binfo->height); + 0, 0, binfo->width, binfo->height); draw_progress_bar (xinfo, binfo, n, n_frames); for (button = 0; button < NO_BUTTON; button++) draw_button (xinfo, binfo, button, binfo->pressed [button]); @@ -335,7 +335,7 @@ draw_control_panel (x11_info_t *xinfo, binfo_t *binfo, static void draw_progress_bar (x11_info_t *xinfo, binfo_t *binfo, unsigned n, - unsigned n_frames) + unsigned n_frames) /* * Draw progressbar of control panel 'binfo' in the given 'window'. * 'n' gives the current frame, whereas 'n_frames' is the total number of @@ -346,32 +346,32 @@ draw_progress_bar (x11_info_t *xinfo, binfo_t *binfo, unsigned n, { unsigned x, y, width, height; - x = 2; - y = 1; + x = 2; + y = 1; width = binfo->width - 5; height = binfo->progbar_height - 3; - + XDrawLine (xinfo->display, binfo->window, binfo->gc [DGRAY], - x, y, x + width, y); + x, y, x + width, y); XDrawLine (xinfo->display, binfo->window, binfo->gc [DGRAY], - x, y, x, y + height - 1); + x, y, x, y + height - 1); XDrawLine (xinfo->display, binfo->window, binfo->gc [LGRAY], - x + width, y + 1, x + width, y + height); + x + width, y + 1, x + width, y + height); XDrawLine (xinfo->display, binfo->window, binfo->gc [LGRAY], - x, y + height, x + width, y + height); + x, y + height, x + width, y + height); x++; y++; width -= 2; height -= 2; XFillRectangle (xinfo->display, binfo->window, binfo->gc [NGRAY], - x, y, width, height); + x, y, width, height); XFillRectangle (xinfo->display, binfo->window, binfo->gc [BLACK], - x + n * max (1, width / n_frames), y, - max (1, width / n_frames), height); + x + n * max (1, width / n_frames), y, + max (1, width / n_frames), height); } static void draw_button (x11_info_t *xinfo, binfo_t *binfo, - buttons_t button, bool_t pressed) + buttons_t button, bool_t pressed) /* * Draw 'button' of control panel 'binfo' in the given 'window'. * 'pressed' indicates whether the button is pressed or not. @@ -379,17 +379,17 @@ draw_button (x11_info_t *xinfo, binfo_t *binfo, * No return value. */ { - grayscale_t top, bottom; /* index of GC */ - unsigned x, y, width, height; /* coordinates of button */ - - x = button * (binfo->width / NO_BUTTON); - y = binfo->progbar_height; + grayscale_t top, bottom; /* index of GC */ + unsigned x, y, width, height; /* coordinates of button */ + + x = button * (binfo->width / NO_BUTTON); + y = binfo->progbar_height; width = binfo->width / NO_BUTTON; height = binfo->height - binfo->progbar_height - 1; - + if (width < 4 || height < 4) return; - + if (pressed) { top = DGRAY; @@ -401,108 +401,108 @@ draw_button (x11_info_t *xinfo, binfo_t *binfo, bottom = DGRAY; } - x += 2; + x += 2; width -= 4; - + XDrawLine (xinfo->display, binfo->window, binfo->gc [top], - x, y, x + width, y); + x, y, x + width, y); XDrawLine (xinfo->display, binfo->window, binfo->gc [top], - x, y, x, y + height - 1); + x, y, x, y + height - 1); XDrawLine (xinfo->display, binfo->window, binfo->gc [bottom], - x + width, y + 1, x + width, y + height); + x + width, y + 1, x + width, y + height); XDrawLine (xinfo->display, binfo->window, binfo->gc [bottom], - x, y + height, x + width, y + height); + x, y + height, x + width, y + height); x++; y++; width -= 2; height -= 2; XFillRectangle (xinfo->display, binfo->window, binfo->gc [NGRAY], - x, y, width, height); + x, y, width, height); switch (button) { case STOP_BUTTON: - XFillRectangle (xinfo->display, binfo->window, binfo->gc [BLACK], - x + width / 2 - 6, y + height / 2 - 4, 11, 11); - if (pressed && !binfo->pressed [STOP_BUTTON]) - { - draw_button (xinfo, binfo, PLAY_BUTTON, NO); - draw_button (xinfo, binfo, PAUSE_BUTTON, NO); - draw_button (xinfo, binfo, RECORD_BUTTON, NO); - } - break; + XFillRectangle (xinfo->display, binfo->window, binfo->gc [BLACK], + x + width / 2 - 6, y + height / 2 - 4, 11, 11); + if (pressed && !binfo->pressed [STOP_BUTTON]) + { + draw_button (xinfo, binfo, PLAY_BUTTON, NO); + draw_button (xinfo, binfo, PAUSE_BUTTON, NO); + draw_button (xinfo, binfo, RECORD_BUTTON, NO); + } + break; case PAUSE_BUTTON: - XFillRectangle (xinfo->display, binfo->window, binfo->gc [BLACK], - x + width / 2 - 6, y + height / 2 - 4, 5, 11); - XFillRectangle (xinfo->display, binfo->window, binfo->gc [BLACK], - x + width / 2 + 1, y + height / 2 - 4, 5, 11); - break; + XFillRectangle (xinfo->display, binfo->window, binfo->gc [BLACK], + x + width / 2 - 6, y + height / 2 - 4, 5, 11); + XFillRectangle (xinfo->display, binfo->window, binfo->gc [BLACK], + x + width / 2 + 1, y + height / 2 - 4, 5, 11); + break; case PLAY_BUTTON: - { - XPoint triangle [3]; - - triangle [0].x = x + width / 2 - 5; - triangle [0].y = y + height / 2 - 5; - triangle [1].x = 10; - triangle [1].y = 6; - triangle [2].x = -10; - triangle [2].y = 6; - - XFillPolygon (xinfo->display, binfo->window, binfo->gc [BLACK], - triangle, 3, Convex, CoordModePrevious); - if (pressed && !binfo->pressed [PLAY_BUTTON] - && binfo->pressed [RECORD_BUTTON]) - draw_button (xinfo, binfo, RECORD_BUTTON, NO); - } - break; + { + XPoint triangle [3]; + + triangle [0].x = x + width / 2 - 5; + triangle [0].y = y + height / 2 - 5; + triangle [1].x = 10; + triangle [1].y = 6; + triangle [2].x = -10; + triangle [2].y = 6; + + XFillPolygon (xinfo->display, binfo->window, binfo->gc [BLACK], + triangle, 3, Convex, CoordModePrevious); + if (pressed && !binfo->pressed [PLAY_BUTTON] + && binfo->pressed [RECORD_BUTTON]) + draw_button (xinfo, binfo, RECORD_BUTTON, NO); + } + break; case RECORD_BUTTON: - if (!binfo->record_is_rewind) - { - XFillArc (xinfo->display, binfo->window, binfo->gc [RED], - x + width / 2 - 5, y + height / 2 - 5, 11, 11, 0, - 360 * 64); - if (pressed && !binfo->pressed [RECORD_BUTTON]) - { - draw_button (xinfo, binfo, STOP_BUTTON, YES); - draw_button (xinfo, binfo, PLAY_BUTTON, NO); - draw_button (xinfo, binfo, PAUSE_BUTTON, NO); - } - } - else - { - XPoint triangle [3]; - - triangle [0].x = x + width / 2 + 5; - triangle [0].y = y + height / 2 - 5; - triangle [1].x = -10; - triangle [1].y = 6; - triangle [2].x = 10; - triangle [2].y = 6; - - XFillPolygon (xinfo->display, binfo->window, binfo->gc [BLACK], - triangle, 3, Convex, CoordModePrevious); - if (pressed && !binfo->pressed [RECORD_BUTTON] - && binfo->pressed [PLAY_BUTTON]) - draw_button (xinfo, binfo, PLAY_BUTTON, NO); - } - break; + if (!binfo->record_is_rewind) + { + XFillArc (xinfo->display, binfo->window, binfo->gc [RED], + x + width / 2 - 5, y + height / 2 - 5, 11, 11, 0, + 360 * 64); + if (pressed && !binfo->pressed [RECORD_BUTTON]) + { + draw_button (xinfo, binfo, STOP_BUTTON, YES); + draw_button (xinfo, binfo, PLAY_BUTTON, NO); + draw_button (xinfo, binfo, PAUSE_BUTTON, NO); + } + } + else + { + XPoint triangle [3]; + + triangle [0].x = x + width / 2 + 5; + triangle [0].y = y + height / 2 - 5; + triangle [1].x = -10; + triangle [1].y = 6; + triangle [2].x = 10; + triangle [2].y = 6; + + XFillPolygon (xinfo->display, binfo->window, binfo->gc [BLACK], + triangle, 3, Convex, CoordModePrevious); + if (pressed && !binfo->pressed [RECORD_BUTTON] + && binfo->pressed [PLAY_BUTTON]) + draw_button (xinfo, binfo, PLAY_BUTTON, NO); + } + break; case QUIT_BUTTON: - { - XPoint triangle [3]; - - triangle [0].x = x + width / 2 - 6; - triangle [0].y = y + height / 2 + 2; - triangle [1].x = 6; - triangle [1].y = -7; - triangle [2].x = 6; - triangle [2].y = 7; - - XFillPolygon (xinfo->display, binfo->window, binfo->gc [BLACK], - triangle, 3, Convex, CoordModePrevious); - XFillRectangle (xinfo->display, binfo->window, binfo->gc [BLACK], - x + width / 2 - 5, y + height / 2 + 4, 11, 3); - } - break; + { + XPoint triangle [3]; + + triangle [0].x = x + width / 2 - 6; + triangle [0].y = y + height / 2 + 2; + triangle [1].x = 6; + triangle [1].y = -7; + triangle [2].x = 6; + triangle [2].y = 7; + + XFillPolygon (xinfo->display, binfo->window, binfo->gc [BLACK], + triangle, 3, Convex, CoordModePrevious); + XFillRectangle (xinfo->display, binfo->window, binfo->gc [BLACK], + x + width / 2 - 5, y + height / 2 + 4, 11, 3); + } + break; default: - break; + break; } binfo->pressed [button] = pressed; } diff --git a/converter/other/fiasco/buttons.h b/converter/other/fiasco/buttons.h index 079715f5..19c4935e 100644 --- a/converter/other/fiasco/buttons.h +++ b/converter/other/fiasco/buttons.h @@ -1,8 +1,8 @@ /* * buttons.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -20,15 +20,15 @@ #ifndef X_DISPLAY_MISSING typedef enum grayscale_e {BLACK, NGRAY, LGRAY, DGRAY, RED, - THICKBLACK, NO_GC} grayscale_t; + THICKBLACK, NO_GC} grayscale_t; typedef enum buttons_e {STOP_BUTTON, PLAY_BUTTON, PAUSE_BUTTON, RECORD_BUTTON, - QUIT_BUTTON, NO_BUTTON} buttons_t; + QUIT_BUTTON, NO_BUTTON} buttons_t; typedef struct buttoninfo { Window window; bool_t pressed [NO_BUTTON]; - GC gc [NO_GC]; + GC gc [NO_GC]; unsigned width; unsigned height; unsigned progbar_height; @@ -37,12 +37,12 @@ typedef struct buttoninfo void check_events (x11_info_t *xinfo, binfo_t *binfo, unsigned n, - unsigned n_frames); + unsigned n_frames); void wait_for_input (x11_info_t *xinfo); -binfo_t * +binfo_t * init_buttons (x11_info_t *xinfo, unsigned n, unsigned n_frames, - unsigned buttons_height, unsigned progbar_height); + unsigned buttons_height, unsigned progbar_height); #endif /* not X_DISPLAY_MISSING */ diff --git a/converter/other/fiasco/codec/approx.c b/converter/other/fiasco/codec/approx.c index d8fefcaa..a3f6523d 100644 --- a/converter/other/fiasco/codec/approx.c +++ b/converter/other/fiasco/codec/approx.c @@ -2,7 +2,7 @@ * approx.c: Approximation of range images with matching pursuit * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -35,7 +35,7 @@ /***************************************************************************** local variables - + *****************************************************************************/ typedef struct mp @@ -53,13 +53,13 @@ typedef struct mp /***************************************************************************** prototypes - + *****************************************************************************/ static void orthogonalize (unsigned index, unsigned n, unsigned level, real_t min_norm, const word_t *domain_blocks, const coding_t *c); -static void +static void matching_pursuit (mp_t *mp, bool_t full_search, real_t price, unsigned max_edges, int y_state, const range_t *range, const domain_pool_t *domain_pool, const coeff_t *coeff, @@ -68,14 +68,14 @@ matching_pursuit (mp_t *mp, bool_t full_search, real_t price, /***************************************************************************** public code - + *****************************************************************************/ -real_t +real_t approximate_range (real_t max_costs, real_t price, int max_edges, int y_state, range_t *range, domain_pool_t *domain_pool, coeff_t *coeff, const wfa_t *wfa, const coding_t *c) { -/*---------------------------------------------------------------------------- +/*---------------------------------------------------------------------------- Approximate image block 'range' by matching pursuit. This functions calls the matching pursuit algorithm several times (with different parameters) in order to find the best approximation. Refer to function @@ -99,15 +99,15 @@ approximate_range (real_t max_costs, real_t price, int max_edges, */ if (c->options.second_domain_block) { mp_t tmp_mp; - + tmp_mp = mp; /* initial value */ tmp_mp.exclude[0] = tmp_mp.indices [0]; tmp_mp.exclude[1] = NO_EDGE; - + matching_pursuit(&tmp_mp, c->options.full_search, price, max_edges, y_state, range, domain_pool, coeff, wfa, c); - if (tmp_mp.costs < mp.costs) /* success */ + if (tmp_mp.costs < mp.costs) /* success */ mp = tmp_mp; } @@ -123,23 +123,23 @@ approximate_range (real_t max_costs, real_t price, int max_edges, tmp_mp = mp; /* initial value */ iteration = -1; /* initial value */ - + do { int i; - + ++iteration; tmp_mp.exclude[iteration] = NO_EDGE; - + for (i = 0; isdomain(tmp_mp.indices[i]); ++i) { if (tmp_mp.weight [i] == 0) { tmp_mp.exclude[iteration] = tmp_mp.indices [i]; break; } - } + } if (isdomain (tmp_mp.exclude [iteration])) { /* try again */ tmp_mp.exclude [iteration + 1] = NO_EDGE; - + matching_pursuit(&tmp_mp, c->options.full_search, price, max_edges, y_state, range, domain_pool, coeff, wfa, c); @@ -165,25 +165,25 @@ approximate_range (real_t max_costs, real_t price, int max_edges, do { int i; - + ++iteration; tmp_mp.exclude[iteration] = NO_EDGE; - + for (i = 0; isdomain (tmp_mp.indices [i]); ++i) { rpf_t * const rpf = tmp_mp.indices [i] ? coeff->rpf : coeff->dc_rpf; - + if (tmp_mp.weight [i] == btor (rtob (200, rpf), rpf) || tmp_mp.weight [i] == btor (rtob (-200, rpf), rpf)) { tmp_mp.exclude [iteration] = tmp_mp.indices [i]; break; } } - + if (isdomain(tmp_mp.exclude[iteration])) { /* try again */ tmp_mp.exclude[iteration + 1] = NO_EDGE; - + matching_pursuit(&tmp_mp, c->options.full_search, price, max_edges, y_state, range, domain_pool, coeff, wfa, c); @@ -226,10 +226,10 @@ approximate_range (real_t max_costs, real_t price, int max_edges, range->level, y_state, wfa, domain_pool->model); coeff->update (mp.weight, mp.into, range->level, coeff); - + Free(domain_blocks); } - + for (edge = 0; isedge (mp.indices [edge]); ++edge) { range->into [edge] = mp.into [edge]; range->weight [edge] = mp.weight [edge]; @@ -242,7 +242,7 @@ approximate_range (real_t max_costs, real_t price, int max_edges, range->into [0] = NO_EDGE; mp.costs = MAXCOSTS; } - + return mp.costs; } @@ -251,25 +251,25 @@ approximate_range (real_t max_costs, real_t price, int max_edges, /***************************************************************************** local variables - + *****************************************************************************/ -static real_t norm_ortho_vector [MAXSTATES]; +static real_t norm_ortho_vector [MAXSTATES]; /* * Square-norm of the i-th vector of the orthogonal basis (OB) * ||o_i||^2; i = 0, ... ,n */ static real_t ip_image_ortho_vector [MAXEDGES]; -/* - * Inner product between the i-th vector of the OB and the given range: - * <b, o_i>; i = 0, ... ,n +/* + * Inner product between the i-th vector of the OB and the given range: + * <b, o_i>; i = 0, ... ,n */ static real_t ip_domain_ortho_vector [MAXSTATES][MAXEDGES]; -/* - * Inner product between the i-th vector of the OB and the image of domain j: - * <s_j, o_i>; j = 0, ... , wfa->states; i = 0, ... ,n, +/* + * Inner product between the i-th vector of the OB and the image of domain j: + * <s_j, o_i>; j = 0, ... , wfa->states; i = 0, ... ,n, */ -static real_t rem_denominator [MAXSTATES]; +static real_t rem_denominator [MAXSTATES]; static real_t rem_numerator [MAXSTATES]; /* * At step n of the orthogonalization the comparative value @@ -280,7 +280,7 @@ static real_t rem_numerator [MAXSTATES]; * the constant (remaining) parts of every domain are * stored in 'rem_numerator' and 'rem_denominator' separately */ -static bool_t used [MAXSTATES]; +static bool_t used [MAXSTATES]; /* * Shows whether a domain image was already used in a * linear combination (YES) or not (NO) @@ -289,10 +289,10 @@ static bool_t used [MAXSTATES]; /***************************************************************************** private code - + *****************************************************************************/ -static void +static void matching_pursuit (mp_t *mp, bool_t full_search, real_t price, unsigned max_edges, int y_state, const range_t *range, const domain_pool_t *domain_pool, const coeff_t *coeff, @@ -313,7 +313,7 @@ matching_pursuit (mp_t *mp, bool_t full_search, real_t price, * elements in the linear combination is limited by 'max_edges'. In * 'mp', vectors may be specified which should be excluded during the * approximation. - * + * * No return value. * * Side effects: @@ -329,7 +329,7 @@ matching_pursuit (mp_t *mp, bool_t full_search, real_t price, const real_t min_norm = 2e-3; /* lower bound of norm */ unsigned best_n = 0; unsigned size = size_of_level (range->level); - + /* * Initialize domain pool and inner product arrays */ @@ -378,7 +378,7 @@ matching_pursuit (mp_t *mp, bool_t full_search, real_t price, + additional_bits) * price + mp->err; n = 0; - do + do { /* * Current approximation is: b = d_0 o_0 + ... + d_(n-1) o_(n-1) @@ -390,15 +390,15 @@ matching_pursuit (mp_t *mp, bool_t full_search, real_t price, * which has minimal costs: s_index. * (No progress is indicated by index == -1) */ - + real_t min_matrix_bits = 0; real_t min_weights_bits = 0; real_t min_error = 0; real_t min_weight [MAXEDGES]; real_t min_costs = full_search ? MAXCOSTS : mp->costs; - - for (index = -1, domain = 0; domain_blocks [domain] >= 0; domain++) - if (!used [domain]) + + for (index = -1, domain = 0; domain_blocks [domain] >= 0; domain++) + if (!used [domain]) { real_t matrix_bits, weights_bits; /* @@ -413,7 +413,7 @@ matching_pursuit (mp_t *mp, bool_t full_search, real_t price, word_t states [MAXEDGES + 1]; real_t weights [MAXEDGES + 1]; unsigned i, k; - + for (i = 0, k = 0; k < n; k++) if (mp->weight [k] != 0) { @@ -477,7 +477,7 @@ matching_pursuit (mp_t *mp, bool_t full_search, real_t price, f[k] = ip_image_ortho_vector[k] / norm_ortho_vector[k]; v [k] = mp->indices [k]; } - + for (l = n; l >= 0; --l) { rpf_t * const rpf = domain_blocks[v[l]] ? coeff->rpf : coeff->dc_rpf; @@ -488,13 +488,13 @@ matching_pursuit (mp_t *mp, bool_t full_search, real_t price, { real_t const fl = f[l]; - + for (k = 0; k < l; ++k) { f[k] -= fl * ip_domain_ortho_vector[v[l]][k] / norm_ortho_vector[k]; } } - } + } /* * Compute the number of output bits of the linear @@ -507,7 +507,7 @@ matching_pursuit (mp_t *mp, bool_t full_search, real_t price, word_t states [MAXEDGES + 1]; real_t weights [MAXEDGES + 1]; int i; - + for (i = 0, k = 0; k <= n; k++) if (f [k] != 0) { @@ -525,10 +525,10 @@ matching_pursuit (mp_t *mp, bool_t full_search, real_t price, range->level, y_state, wfa, domain_pool->model); } - + /* * To compute the approximation error, the corresponding - * linear factors of the linear combination + * linear factors of the linear combination * b = r_0 o_0 + ... + r_(n-1) o_(n-1) + r_n o_'domain' * with orthogonal vectors must be computed with following * formula: @@ -546,7 +546,7 @@ matching_pursuit (mp_t *mp, bool_t full_search, real_t price, a = get_ip_state_state (domain_blocks [v [l]], domain_blocks [domain], range->level, c); - for (k = 0; k < n; k++) + for (k = 0; k < n; k++) a -= ip_domain_ortho_vector [v [l]][k] / norm_ortho_vector [k] * ip_domain_ortho_vector [domain][k]; @@ -554,7 +554,7 @@ matching_pursuit (mp_t *mp, bool_t full_search, real_t price, } norm_ortho_vector [n] = rem_denominator [domain]; ip_image_ortho_vector [n] = rem_numerator [domain]; - + for (k = 0; k <= n; k++) for (l = k + 1; (unsigned) l <= n; l++) r [k] += ip_domain_ortho_vector [v [l]][k] * r [l] @@ -586,40 +586,40 @@ matching_pursuit (mp_t *mp, bool_t full_search, real_t price, } } } - + if (index >= 0) /* found a better approximation */ { if (min_costs < mp->costs) { unsigned k; - + mp->costs = min_costs; mp->err = min_error; mp->matrix_bits = min_matrix_bits; mp->weights_bits = min_weights_bits; - + for (k = 0; k <= n; k++) mp->weight [k] = min_weight [k]; best_n = n + 1; } - + mp->indices [n] = index; mp->into [n] = domain_blocks [index]; used [index] = YES; - /* - * Gram-Schmidt orthogonalization step n + /* + * Gram-Schmidt orthogonalization step n */ orthogonalize (index, n, range->level, min_norm, domain_blocks, c); n++; - } - } + } + } while (n < max_edges && index >= 0); mp->indices [best_n] = NO_EDGE; - + mp->costs = (mp->matrix_bits + mp->weights_bits + additional_bits) * price + mp->err; @@ -641,31 +641,31 @@ orthogonalize (unsigned index, unsigned n, unsigned level, real_t min_norm, * * Side effects: * The remainder values (numerator and denominator) of - * all 'domain_blocks' are updated. + * all 'domain_blocks' are updated. */ { unsigned domain; - + ip_image_ortho_vector [n] = rem_numerator [index]; norm_ortho_vector [n] = rem_denominator [index]; /* - * Compute inner products between all domain images and + * Compute inner products between all domain images and * vector n of the orthogonal basis: - * for (i = 0, ... , wfa->states) + * 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 comparative * value are updated. */ - for (domain = 0; domain_blocks [domain] >= 0; domain++) - if (!used [domain]) + for (domain = 0; domain_blocks [domain] >= 0; domain++) + if (!used [domain]) { unsigned k; real_t tmp = get_ip_state_state (domain_blocks [index], domain_blocks [domain], level, c); - - for (k = 0; k < n; k++) + + for (k = 0; k < n; k++) tmp -= ip_domain_ortho_vector [domain][k] / norm_ortho_vector [k] * ip_domain_ortho_vector [index][k]; ip_domain_ortho_vector [domain][n] = tmp; @@ -677,8 +677,8 @@ orthogonalize (unsigned index, unsigned n, unsigned level, real_t min_norm, /* * Exclude vectors with small denominator */ - if (!used [domain]) - if (rem_denominator [domain] / size_of_level (level) < min_norm) + if (!used [domain]) + if (rem_denominator [domain] / size_of_level (level) < min_norm) used [domain] = YES; } } diff --git a/converter/other/fiasco/codec/approx.h b/converter/other/fiasco/codec/approx.h index 42f1458a..cce27eb6 100644 --- a/converter/other/fiasco/codec/approx.h +++ b/converter/other/fiasco/codec/approx.h @@ -1,8 +1,8 @@ /* * approx.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -21,10 +21,10 @@ #include "cwfa.h" #include "domain-pool.h" -real_t +real_t approximate_range (real_t max_costs, real_t price, int max_edges, - int y_state, range_t *range, domain_pool_t *domain_pool, - coeff_t *coeff, const wfa_t *wfa, const coding_t *c); + int y_state, range_t *range, domain_pool_t *domain_pool, + coeff_t *coeff, const wfa_t *wfa, const coding_t *c); #endif /* not _APPROX_H */ diff --git a/converter/other/fiasco/codec/bintree.c b/converter/other/fiasco/codec/bintree.c index b050ab63..ca828fb2 100644 --- a/converter/other/fiasco/codec/bintree.c +++ b/converter/other/fiasco/codec/bintree.c @@ -1,8 +1,8 @@ /* - * bintree.c: Bintree model of WFA tree + * bintree.c: Bintree model of WFA tree + * + * Written by: Ullrich Hafner * - * Written by: Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -28,8 +28,8 @@ /***************************************************************************** - public code - + public code + *****************************************************************************/ void @@ -40,7 +40,7 @@ tree_update (bool_t child, unsigned level, tree_t *model) * No return value. * * Side effects: - * tree model is changed. + * tree model is changed. */ { if (!child) @@ -59,7 +59,7 @@ tree_bits (bool_t child, unsigned level, const tree_t *model) * For each 'level' a different context is used. * * Return value: - * # bits + * # bits */ { real_t prob = model->counts [level] / (real_t) model->total [level]; @@ -80,13 +80,13 @@ init_tree_model (tree_t *tree_model) { unsigned level; unsigned counts_0 [MAXLEVEL] = {20, 17, 15, 10, 5, 4, 3, - 2, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1 , 1, 1, 1}; + 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1 , 1, 1, 1}; unsigned counts_1 [MAXLEVEL] = {1 , 1, 1, 1, 1, 1, 1, - 1, 1, 2, 3, 5, 10, 15, 20, - 25, 30, 35, 60, 60, 60, 60}; - - for (level = 0; level < MAXLEVEL ; level++) + 1, 1, 2, 3, 5, 10, 15, 20, + 25, 30, 35, 60, 60, 60, 60}; + + for (level = 0; level < MAXLEVEL ; level++) { tree_model->counts [level] = counts_1 [level]; tree_model->total [level] = counts_0 [level] + counts_1 [level]; diff --git a/converter/other/fiasco/codec/bintree.h b/converter/other/fiasco/codec/bintree.h index 3dc88ac1..c68b2e7b 100644 --- a/converter/other/fiasco/codec/bintree.h +++ b/converter/other/fiasco/codec/bintree.h @@ -1,8 +1,8 @@ /* * bintree.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -28,8 +28,8 @@ typedef struct tree * which indicate whether there exists a tree edge or not. */ { - unsigned counts [MAXLEVEL]; /* # NO_RANGE symbols at given level */ - unsigned total [MAXLEVEL]; /* total number of symbols at '' */ + unsigned counts [MAXLEVEL]; /* # NO_RANGE symbols at given level */ + unsigned total [MAXLEVEL]; /* total number of symbols at '' */ } tree_t; real_t diff --git a/converter/other/fiasco/codec/coder.h b/converter/other/fiasco/codec/coder.h index 2fe81d81..4e8e400d 100644 --- a/converter/other/fiasco/codec/coder.h +++ b/converter/other/fiasco/codec/coder.h @@ -1,8 +1,8 @@ /* * coder.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ diff --git a/converter/other/fiasco/codec/coeff.c b/converter/other/fiasco/codec/coeff.c index 6d33bad5..3a5a6a0a 100644 --- a/converter/other/fiasco/codec/coeff.c +++ b/converter/other/fiasco/codec/coeff.c @@ -1,8 +1,8 @@ /* - * coeff.c: Matching pursuit coefficients probability model + * coeff.c: Matching pursuit coefficients probability model + * + * Written by: Ullrich Hafner * - * Written by: Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -28,9 +28,9 @@ /* * Coefficient model interface: * Implementing the coefficients model interface requires the - * following steps: + * following steps: * - Add a constructor that initializes the coeff_t structure - * - Allocate new model with default_alloc() + * - Allocate new model with default_alloc() * - Fill the c_array_t coeff_models[] array with constructor and name * - Write code for methods bits() and update() * - Either use default functions for remaining methods or override them @@ -38,21 +38,21 @@ */ /***************************************************************************** - uniform distribution coefficients model + uniform distribution coefficients model *****************************************************************************/ static coeff_t * alloc_uniform_coeff_model (rpf_t *rpf, rpf_t *dc_rpf, - unsigned min_level, unsigned max_level); + unsigned min_level, unsigned max_level); static void uniform_update (const real_t *used_coeff, const word_t *used_states, - unsigned level, coeff_t *coeff); + unsigned level, coeff_t *coeff); static real_t uniform_bits (const real_t *used_coeff, const word_t *used_states, - unsigned level, const coeff_t *coeff); + unsigned level, const coeff_t *coeff); /***************************************************************************** - default functions + default functions *****************************************************************************/ static void @@ -63,15 +63,15 @@ static void default_free (coeff_t *coeff); static coeff_t * default_alloc (rpf_t *rpf, rpf_t *dc_rpf, - unsigned min_level, unsigned max_level); + unsigned min_level, unsigned max_level); /***************************************************************************** - adaptive arithmetic coding model + adaptive arithmetic coding model *****************************************************************************/ static coeff_t * alloc_aac_coeff_model (rpf_t *rpf, rpf_t *dc_rpf, - unsigned min_level, unsigned max_level); + unsigned min_level, unsigned max_level); static void aac_model_free (void *model); static void * @@ -80,70 +80,70 @@ static void * aac_model_duplicate (const coeff_t *coeff, const void *model); static void aac_update (const real_t *used_coeff, const word_t *used_states, - unsigned level, coeff_t *coeff); + unsigned level, coeff_t *coeff); static real_t aac_bits (const real_t *used_coeff, const word_t *used_states, - unsigned level, const coeff_t *coeff); + unsigned level, const coeff_t *coeff); /***************************************************************************** - public code - + public code + *****************************************************************************/ typedef struct c_array { const char *identifier; coeff_t *(*function) (rpf_t *rpf, rpf_t *dc_rpf, - unsigned min_level, unsigned max_level); + unsigned min_level, unsigned max_level); } c_array_t; c_array_t coeff_models[] = {{"adaptive", alloc_aac_coeff_model}, - {"uniform", alloc_uniform_coeff_model}, - {NULL, NULL}}; + {"uniform", alloc_uniform_coeff_model}, + {NULL, NULL}}; coeff_t * alloc_coeff_model (const char *coeff_model_name, rpf_t *rpf, rpf_t *dc_rpf, - unsigned min_level, unsigned max_level) + unsigned min_level, unsigned max_level) /* * Allocate a new coefficients model which is identified by the string * 'coeff_model_name'. 'rpf' and 'dc_rpf' define the reduced * precision formats the should be used to quantize normal and DC * components, respectively. 'min_level' and 'max_level' define the * range of range approximations. - * + * * Return value: - * pointer to the allocated coefficients model + * pointer to the allocated coefficients model * * Note: * Refer to 'coeff.h' for a short description of the member functions. */ { unsigned n; - + for (n = 0; coeff_models [n].identifier; n++) /* step through all id's */ - if (strcaseeq (coeff_models [n].identifier, coeff_model_name)) - return coeff_models [n].function (rpf, dc_rpf, min_level, max_level); + if (strcaseeq (coeff_models [n].identifier, coeff_model_name)) + return coeff_models [n].function (rpf, dc_rpf, min_level, max_level); warning ("Can't initialize coefficients model '%s'. " - "Using default value '%s'.", - coeff_model_name, coeff_models [0].identifier); + "Using default value '%s'.", + coeff_model_name, coeff_models [0].identifier); return coeff_models [0].function (rpf, dc_rpf, min_level, max_level); } /***************************************************************************** - private code - + private code + *****************************************************************************/ /***************************************************************************** - uniform distribution coefficients model + uniform distribution coefficients model *****************************************************************************/ static coeff_t * alloc_uniform_coeff_model (rpf_t *rpf, rpf_t *dc_rpf, - unsigned min_level, unsigned max_level) + unsigned min_level, unsigned max_level) /* * Underlying probability model: uniform distribution. * I.e. each coefficient is written as such with @@ -154,21 +154,21 @@ alloc_uniform_coeff_model (rpf_t *rpf, rpf_t *dc_rpf, coeff->bits = uniform_bits; coeff->update = uniform_update; - + return coeff; } static real_t uniform_bits (const real_t *used_coeff, const word_t *used_states, - unsigned level, const coeff_t *coeff) + unsigned level, const coeff_t *coeff) { unsigned edge; - real_t bits = 0; /* #bits to store coefficients */ - + real_t bits = 0; /* #bits to store coefficients */ + for (edge = 0; isedge (used_states [edge]); edge++) { rpf_t *rpf = used_states [edge] ? coeff->rpf : coeff->dc_rpf; - + bits += rpf->mantissa_bits + 1; } @@ -177,13 +177,13 @@ uniform_bits (const real_t *used_coeff, const word_t *used_states, static void uniform_update (const real_t *used_coeff, const word_t *used_states, - unsigned level, coeff_t *coeff) + unsigned level, coeff_t *coeff) { - return; /* nothing to do */ + return; /* nothing to do */ } /***************************************************************************** - adaptive arithmetic coding model + adaptive arithmetic coding model *****************************************************************************/ typedef struct aac_model @@ -194,74 +194,74 @@ typedef struct aac_model static coeff_t * alloc_aac_coeff_model (rpf_t *rpf, rpf_t *dc_rpf, - unsigned min_level, unsigned max_level) + unsigned min_level, unsigned max_level) /* * Underlying probability model: adaptive arithmetic coding using * the level of a range as context. */ { coeff_t *coeff = default_alloc (rpf, dc_rpf, min_level, max_level); - + coeff->bits = aac_bits; coeff->update = aac_update; coeff->model_free = aac_model_free; coeff->model_duplicate = aac_model_duplicate; - coeff->model = aac_model_alloc (coeff); - + coeff->model = aac_model_alloc (coeff); + return coeff; } static real_t aac_bits (const real_t *used_coeff, const word_t *used_states, - unsigned level, const coeff_t *coeff) + unsigned level, const coeff_t *coeff) { - real_t bits = 0; /* # bits to store coefficients */ - unsigned edge; - int state; + real_t bits = 0; /* # bits to store coefficients */ + unsigned edge; + int state; word_t *counts; aac_model_t *model = (aac_model_t *) coeff->model; counts = model->counts - + (1 << (1 + coeff->dc_rpf->mantissa_bits)) - + ((level - coeff->min_level) - * (1 << (1 + coeff->rpf->mantissa_bits))); - + + (1 << (1 + coeff->dc_rpf->mantissa_bits)) + + ((level - coeff->min_level) + * (1 << (1 + coeff->rpf->mantissa_bits))); + for (edge = 0; isedge (state = used_states [edge]); edge++) if (state) - bits -= log2 (counts [rtob (used_coeff [edge], coeff->rpf)] - / (real_t) model->totals [level - - coeff->min_level + 1]); + bits -= log2 (counts [rtob (used_coeff [edge], coeff->rpf)] + / (real_t) model->totals [level + - coeff->min_level + 1]); else - bits -= log2 (model->counts [rtob (used_coeff [edge], coeff->dc_rpf)] - / (real_t) model->totals [0]); - + bits -= log2 (model->counts [rtob (used_coeff [edge], coeff->dc_rpf)] + / (real_t) model->totals [0]); + return bits; } static void aac_update (const real_t *used_coeff, const word_t *used_states, - unsigned level, coeff_t *coeff) + unsigned level, coeff_t *coeff) { - unsigned edge; - int state; + unsigned edge; + int state; word_t *counts; aac_model_t *model = (aac_model_t *) coeff->model; counts = model->counts - + (1 << (1 + coeff->dc_rpf->mantissa_bits)) - + ((level - coeff->min_level) - * (1 << (1 + coeff->rpf->mantissa_bits))); + + (1 << (1 + coeff->dc_rpf->mantissa_bits)) + + ((level - coeff->min_level) + * (1 << (1 + coeff->rpf->mantissa_bits))); for (edge = 0; isedge (state = used_states [edge]); edge++) if (state) { - counts [rtob (used_coeff [edge], coeff->rpf)]++; - model->totals [level - coeff->min_level + 1]++; + counts [rtob (used_coeff [edge], coeff->rpf)]++; + model->totals [level - coeff->min_level + 1]++; } else { - model->counts [rtob (used_coeff [edge], coeff->dc_rpf)]++; - model->totals [0]++; + model->counts [rtob (used_coeff [edge], coeff->dc_rpf)]++; + model->totals [0]++; } } @@ -272,12 +272,12 @@ aac_model_duplicate (const coeff_t *coeff, const void *model) aac_model_t *dst = aac_model_alloc (coeff); memcpy (dst->counts, src->counts, - sizeof (word_t) * ((coeff->max_level - coeff->min_level + 1) - * (1 << (1 + coeff->rpf->mantissa_bits)) - + (1 << (1 + coeff->dc_rpf->mantissa_bits)))); + sizeof (word_t) * ((coeff->max_level - coeff->min_level + 1) + * (1 << (1 + coeff->rpf->mantissa_bits)) + + (1 << (1 + coeff->dc_rpf->mantissa_bits)))); memcpy (dst->totals, src->totals, - sizeof (word_t) * (coeff->max_level - coeff->min_level + 1 + 1)); - + sizeof (word_t) * (coeff->max_level - coeff->min_level + 1 + 1)); + return dst; } @@ -285,36 +285,36 @@ static void * aac_model_alloc (const coeff_t *coeff) { aac_model_t *model; - unsigned size = (coeff->max_level - coeff->min_level + 1) - * (1 << (1 + coeff->rpf->mantissa_bits)) - + (1 << (1 + coeff->dc_rpf->mantissa_bits)); - - model = Calloc (1, sizeof (aac_model_t)); + unsigned size = (coeff->max_level - coeff->min_level + 1) + * (1 << (1 + coeff->rpf->mantissa_bits)) + + (1 << (1 + coeff->dc_rpf->mantissa_bits)); + + model = Calloc (1, sizeof (aac_model_t)); model->counts = Calloc (size, sizeof (word_t)); model->totals = Calloc (coeff->max_level - coeff->min_level + 1 + 1, - sizeof (word_t)); + sizeof (word_t)); /* * Initialize model */ { unsigned n; word_t *ptr = model->counts; - + for (n = size; n; n--) - *ptr++ = 1; + *ptr++ = 1; model->totals [0] = 1 << (1 + coeff->dc_rpf->mantissa_bits); for (n = coeff->min_level; n <= coeff->max_level; n++) - model->totals [n - coeff->min_level + 1] - = 1 << (1 + coeff->rpf->mantissa_bits); + model->totals [n - coeff->min_level + 1] + = 1 << (1 + coeff->rpf->mantissa_bits); } - + return (void *) model; } static void aac_model_free (void *model) { - aac_model_t *aac_model = (aac_model_t *) model; + aac_model_t *aac_model = (aac_model_t *) model; if (aac_model) { @@ -325,26 +325,26 @@ aac_model_free (void *model) } /***************************************************************************** - default functions + default functions *****************************************************************************/ static coeff_t * default_alloc (rpf_t *rpf, rpf_t *dc_rpf, - unsigned min_level, unsigned max_level) + unsigned min_level, unsigned max_level) { coeff_t *coeff = Calloc (1, sizeof (coeff_t)); - coeff->rpf = rpf; - coeff->dc_rpf = dc_rpf; - coeff->min_level = min_level; - coeff->max_level = max_level; - coeff->model = NULL; - coeff->bits = NULL; - coeff->update = NULL; - coeff->free = default_free; - coeff->model_free = default_model_free; + coeff->rpf = rpf; + coeff->dc_rpf = dc_rpf; + coeff->min_level = min_level; + coeff->max_level = max_level; + coeff->model = NULL; + coeff->bits = NULL; + coeff->update = NULL; + coeff->free = default_free; + coeff->model_free = default_model_free; coeff->model_duplicate = default_model_duplicate; - + return coeff; } diff --git a/converter/other/fiasco/codec/coeff.h b/converter/other/fiasco/codec/coeff.h index 6193e2ee..f22de2d7 100644 --- a/converter/other/fiasco/codec/coeff.h +++ b/converter/other/fiasco/codec/coeff.h @@ -1,8 +1,8 @@ /* * coeff.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -23,23 +23,23 @@ typedef struct coeff { - rpf_t *rpf; /* reduced precision format */ - rpf_t *dc_rpf; /* RPF of DC (state 0) component */ - unsigned min_level, max_level; /* allocate memory for [min,..,max] */ - void *model; /* generic pointer to prob. model */ + rpf_t *rpf; /* reduced precision format */ + rpf_t *dc_rpf; /* RPF of DC (state 0) component */ + unsigned min_level, max_level; /* allocate memory for [min,..,max] */ + void *model; /* generic pointer to prob. model */ real_t (*bits) (const real_t *used_coeff, const word_t *used_domains, - unsigned level, const struct coeff *coeff); + unsigned level, const struct coeff *coeff); /* * Compute bit-rate of a range approximation with coefficients given by * -1 terminated list 'used_domains'. */ void (*update) (const real_t *used_coeff, const word_t *used_domains, - unsigned level, struct coeff *coeff); + unsigned level, struct coeff *coeff); /* * Update the probability model according to the chosen approximation. * (given by the -1 terminated list 'used_domains'). */ - void (*free) (struct coeff *coeff); + void (*free) (struct coeff *coeff); /* * Discard the given coefficients struct. */ @@ -55,7 +55,7 @@ typedef struct coeff coeff_t * alloc_coeff_model (const char *coeff_model_name, rpf_t *rpf, rpf_t *dc_rpf, - unsigned min_level, unsigned max_level); + unsigned min_level, unsigned max_level); #endif /* not _COEFF_H */ diff --git a/converter/other/fiasco/codec/control.c b/converter/other/fiasco/codec/control.c index 2ea06052..0588623f 100644 --- a/converter/other/fiasco/codec/control.c +++ b/converter/other/fiasco/codec/control.c @@ -1,8 +1,8 @@ /* - * control.c: Control unit of WFA structure + * control.c: Control unit of WFA structure + * + * Written by: Ullrich Hafner * - * Written by: Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -17,7 +17,7 @@ #include "config.h" #include <string.h> - + #include "types.h" #include "macros.h" #include "error.h" @@ -30,24 +30,24 @@ /***************************************************************************** - prototypes - + prototypes + *****************************************************************************/ -static void +static void clear_or_alloc (real_t **ptr, size_t size); -static void +static void compute_images (unsigned from, unsigned to, const wfa_t *wfa, coding_t *c); /***************************************************************************** - public code - + public code + *****************************************************************************/ -void +void append_state (bool_t auxiliary_state, real_t final, unsigned level_of_state, - wfa_t *wfa, coding_t *c) + wfa_t *wfa, coding_t *c) /* * Append a 'wfa' state. If 'auxiliary_state' == YES then * allocate memory for inner products and state images. 'final' is @@ -57,13 +57,13 @@ append_state (bool_t auxiliary_state, real_t final, unsigned level_of_state, * No return value. * * Side effects: - * The WFA information are updated in structure 'wfa' - * State images are computed and inner products are cleared (in 'c') + * The WFA information are updated in structure 'wfa' + * State images are computed and inner products are cleared (in 'c') */ { wfa->final_distribution [wfa->states] = final; wfa->level_of_state [wfa->states] = level_of_state; - + if (!auxiliary_state) { unsigned level; @@ -74,63 +74,63 @@ append_state (bool_t auxiliary_state, real_t final, unsigned level_of_state, * Allocate memory for inner products and for state images */ clear_or_alloc (&c->images_of_state [wfa->states], - size_of_tree (c->options.images_level)); - + size_of_tree (c->options.images_level)); + for (level = c->options.images_level + 1; - level <= c->options.lc_max_level; level++) - clear_or_alloc (&c->ip_states_state [wfa->states][level], - wfa->states + 1); + level <= c->options.lc_max_level; level++) + clear_or_alloc (&c->ip_states_state [wfa->states][level], + wfa->states + 1); clear_or_alloc (&c->ip_images_state [wfa->states], - size_of_tree (c->products_level)); + size_of_tree (c->products_level)); /* * Compute the images of the current state at level 0,..,'imageslevel' */ - + c->images_of_state [wfa->states][0] = final; - compute_images (wfa->states, wfa->states, wfa, c); + compute_images (wfa->states, wfa->states, wfa, c); /* * Compute the inner products between the current state and the * old states 0,...,'states'-1 - */ - + */ + compute_ip_states_state (wfa->states, wfa->states, wfa, c); } else { unsigned level; - + wfa->domain_type [wfa->states] = 0; - + /* * Free the allocated memory */ if (c->images_of_state [wfa->states] != NULL) { - Free (c->images_of_state [wfa->states]); - c->images_of_state [wfa->states] = NULL; + Free (c->images_of_state [wfa->states]); + c->images_of_state [wfa->states] = NULL; } for (level = 0; level <= c->options.lc_max_level; level++) - if (c->ip_states_state [wfa->states][level]) - { - Free (c->ip_states_state [wfa->states][level]); - c->ip_states_state [wfa->states][level] = NULL; - } + if (c->ip_states_state [wfa->states][level]) + { + Free (c->ip_states_state [wfa->states][level]); + c->ip_states_state [wfa->states][level] = NULL; + } if (c->ip_images_state [wfa->states]) { - Free (c->ip_images_state [wfa->states]); - c->ip_images_state [wfa->states] = NULL; + Free (c->ip_images_state [wfa->states]); + c->ip_images_state [wfa->states] = NULL; } } - + wfa->states++; - if (wfa->states >= MAXSTATES) + if (wfa->states >= MAXSTATES) error ("Maximum number of states reached!"); -} - -void +} + +void append_basis_states (unsigned basis_states, wfa_t *wfa, coding_t *c) /* * Append the WFA basis states 0, ... , ('basis_states' - 1). @@ -138,8 +138,8 @@ append_basis_states (unsigned basis_states, wfa_t *wfa, coding_t *c) * No return value. * * Side effects: - * The WFA information are updated in structure 'wfa' - * State images and inner products are computed (in 'c') + * The WFA information are updated in structure 'wfa' + * State images and inner products are computed (in 'c') */ { unsigned level, state; @@ -151,30 +151,30 @@ append_basis_states (unsigned basis_states, wfa_t *wfa, coding_t *c) for (state = 0; state < basis_states; state++) { clear_or_alloc (&c->images_of_state [state], - size_of_tree (c->options.images_level)); + size_of_tree (c->options.images_level)); for (level = c->options.images_level + 1; - level <= c->options.lc_max_level; level++) - clear_or_alloc (&c->ip_states_state [state][level], state + 1); + level <= c->options.lc_max_level; level++) + clear_or_alloc (&c->ip_states_state [state][level], state + 1); clear_or_alloc (&c->ip_images_state [state], - size_of_tree (c->products_level)); + size_of_tree (c->products_level)); c->images_of_state [state][0] = wfa->final_distribution [state]; wfa->level_of_state [state] = -1; } - - compute_images (0, basis_states - 1, wfa, c); + + compute_images (0, basis_states - 1, wfa, c); compute_ip_states_state (0, basis_states - 1, wfa, c); wfa->states = basis_states; - - if (wfa->states >= MAXSTATES) + + if (wfa->states >= MAXSTATES) error ("Maximum number of states reached!"); -} - -void +} + +void append_transitions (unsigned state, unsigned label, const real_t *weight, - const word_t *into, wfa_t *wfa) + const word_t *into, wfa_t *wfa) /* * Append the 'wfa' transitions (given by the arrays 'weight' and 'into') * of the range ('state','label'). @@ -182,7 +182,7 @@ append_transitions (unsigned state, unsigned label, const real_t *weight, * No return value. * * Side effects: - * new 'wfa' edges are appended + * new 'wfa' edges are appended */ { unsigned edge; @@ -192,81 +192,81 @@ append_transitions (unsigned state, unsigned label, const real_t *weight, { append_edge (state, into [edge], weight [edge], label, wfa); if (into [edge] == wfa->y_state [state][label]) - wfa->y_column [state][label] = 1; + wfa->y_column [state][label] = 1; } } /***************************************************************************** - private code - + private code + *****************************************************************************/ -static void +static void compute_images (unsigned from, unsigned to, const wfa_t *wfa, coding_t *c) /* - * Computes the images of the given states 'from', ... , 'to' + * Computes the images of the given states 'from', ... , 'to' * at level 0,...,'c->imagelevel'. * Uses the fact that each state image is a linear combination of state * images, i.e. s_i := c_0 s_0 + ... + c_i s_i. */ { unsigned label, level, state; - + /* * Compute the images Phi(state) - * # level = 0 - * ## level = 1 - * #### level = 2 - * ######## level = 3 + * # level = 0 + * ## level = 1 + * #### level = 2 + * ######## level = 3 * ... * ########...## level = imageslevel */ - + for (level = 1; level <= c->options.images_level; level++) for (state = from; state <= to; state++) - for (label = 0; label < MAXLABELS; label++) - { - real_t *dst, *src; - unsigned edge; - int domain; /* current domain */ - - if (ischild (domain = wfa->tree[state][label])) - { - dst = c->images_of_state [state] + address_of_level (level) + - label * size_of_level (level - 1); - src = c->images_of_state [domain] - + address_of_level (level - 1); - memcpy (dst, src, size_of_level (level - 1) * sizeof (real_t)); - } - for (edge = 0; isedge (domain = wfa->into[state][label][edge]); - edge++) - { - unsigned n; - real_t weight = wfa->weight [state][label][edge]; - - dst = c->images_of_state [state] + address_of_level (level) + - label * size_of_level (level - 1); - src = c->images_of_state [domain] - + address_of_level (level - 1); - - for (n = size_of_level (level - 1); n; n--) - *dst++ += *src++ * weight; - } - } + for (label = 0; label < MAXLABELS; label++) + { + real_t *dst, *src; + unsigned edge; + int domain; /* current domain */ + + if (ischild (domain = wfa->tree[state][label])) + { + dst = c->images_of_state [state] + address_of_level (level) + + label * size_of_level (level - 1); + src = c->images_of_state [domain] + + address_of_level (level - 1); + memcpy (dst, src, size_of_level (level - 1) * sizeof (real_t)); + } + for (edge = 0; isedge (domain = wfa->into[state][label][edge]); + edge++) + { + unsigned n; + real_t weight = wfa->weight [state][label][edge]; + + dst = c->images_of_state [state] + address_of_level (level) + + label * size_of_level (level - 1); + src = c->images_of_state [domain] + + address_of_level (level - 1); + + for (n = size_of_level (level - 1); n; n--) + *dst++ += *src++ * weight; + } + } } -static void +static void clear_or_alloc (real_t **ptr, size_t size) /* - * if *ptr == NULL allocate memory with Calloc - * otherwise fill the real_t-array ptr[] with 0 + * if *ptr == NULL allocate memory with Calloc + * otherwise fill the real_t-array ptr[] with 0 */ { - if (*ptr == NULL) + if (*ptr == NULL) *ptr = Calloc (size, sizeof (real_t)); - else + else memset (*ptr, 0, size * sizeof (real_t)); - + } diff --git a/converter/other/fiasco/codec/control.h b/converter/other/fiasco/codec/control.h index 6c0834a1..9bfc9b50 100644 --- a/converter/other/fiasco/codec/control.h +++ b/converter/other/fiasco/codec/control.h @@ -1,8 +1,8 @@ /* * control.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -20,14 +20,14 @@ #include "cwfa.h" #include "types.h" -void +void append_transitions (unsigned state, unsigned label, const real_t *weight, - const word_t *into, wfa_t *wfa); -void + const word_t *into, wfa_t *wfa); +void append_basis_states (unsigned basis_states, wfa_t *wfa, coding_t *c); -void +void append_state (bool_t auxiliary_state, real_t final, unsigned level_of_state, - wfa_t *wfa, coding_t *c); + wfa_t *wfa, coding_t *c); #endif /* not _CONTROL_H */ diff --git a/converter/other/fiasco/codec/cwfa.h b/converter/other/fiasco/codec/cwfa.h index e8e2d474..4fed343c 100644 --- a/converter/other/fiasco/codec/cwfa.h +++ b/converter/other/fiasco/codec/cwfa.h @@ -1,8 +1,8 @@ /* * cwfa.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -32,15 +32,15 @@ extern const real_t MAXCOSTS; typedef struct motion { - image_t *original; /* Current image */ - image_t *past; /* Preceding image */ - image_t *future; /* Succeeding image */ - frame_type_e frame_type; /* frame type: B_, P_ I_FRAME */ - unsigned number; /* display number of frame */ - real_t *xbits; /* # bits for mv x-component */ - real_t *ybits; /* # bits for mv y-component */ - real_t **mc_forward_norms; /* norms of mcpe */ - real_t **mc_backward_norms; /* norms of mcpe */ + image_t *original; /* Current image */ + image_t *past; /* Preceding image */ + image_t *future; /* Succeeding image */ + frame_type_e frame_type; /* frame type: B_, P_ I_FRAME */ + unsigned number; /* display number of frame */ + real_t *xbits; /* # bits for mv x-component */ + real_t *ybits; /* # bits for mv y-component */ + real_t **mc_forward_norms; /* norms of mcpe */ + real_t **mc_backward_norms; /* norms of mcpe */ } motion_t; typedef struct range @@ -48,30 +48,30 @@ typedef struct range * Information about current range in the original image. * Approximation data (error, encoding bits, approximation type and factors * of the linear combination) are also saved. - */ + */ { unsigned global_address; /* We need absolute image addresses - for distance calculations. */ - unsigned x, y; /* Coordinates of upper left corner */ - unsigned image; /* Position in the tree */ - unsigned address; /* Address of the pixel data */ - unsigned level; /* Level of the range */ - real_t weight [MAXEDGES + 1]; /* coeff. of the approximation */ - word_t into [MAXEDGES + 1]; /* used domains of the approximation */ - int tree; /* == domain : range is approximated - with new state 'domain' - == RANGE : - with a linear comb. */ - real_t err; /* approximation error */ - real_t tree_bits; /* # bits to encode tree */ - real_t matrix_bits; /* # bits to encode matrices */ - real_t weights_bits; /* # bits to encode weights */ - mv_t mv; /* motion vector */ - real_t mv_tree_bits; /* # bits to encode mv tree */ - real_t mv_coord_bits; /* # bits to encode mv coordinates */ - real_t nd_tree_bits; /* # bits to encode nd tree */ - real_t nd_weights_bits; /* # bits to encode nd factors */ - bool_t prediction; /* range is predicted? */ + for distance calculations. */ + unsigned x, y; /* Coordinates of upper left corner */ + unsigned image; /* Position in the tree */ + unsigned address; /* Address of the pixel data */ + unsigned level; /* Level of the range */ + real_t weight [MAXEDGES + 1]; /* coeff. of the approximation */ + word_t into [MAXEDGES + 1]; /* used domains of the approximation */ + int tree; /* == domain : range is approximated + with new state 'domain' + == RANGE : + with a linear comb. */ + real_t err; /* approximation error */ + real_t tree_bits; /* # bits to encode tree */ + real_t matrix_bits; /* # bits to encode matrices */ + real_t weights_bits; /* # bits to encode weights */ + mv_t mv; /* motion vector */ + real_t mv_tree_bits; /* # bits to encode mv tree */ + real_t mv_coord_bits; /* # bits to encode mv coordinates */ + real_t nd_tree_bits; /* # bits to encode nd tree */ + real_t nd_weights_bits; /* # bits to encode nd factors */ + bool_t prediction; /* range is predicted? */ } range_t; typedef struct coding @@ -80,27 +80,27 @@ typedef struct coding * process. */ { - real_t price; /* determines quality of approx. */ - real_t **images_of_state; /* image of state i at level - 0, ... , imageslevel */ + real_t price; /* determines quality of approx. */ + real_t **images_of_state; /* image of state i at level + 0, ... , imageslevel */ real_t *(*ip_states_state)[MAXLEVEL]; /* inner products between state i - and states 0, ... , i - at all image levels */ - real_t **ip_images_state; /* inner products between all - ranges and state i */ - real_t *pixels; /* current image pixels stored in tree - order (only leaves are stored) */ - unsigned products_level; /* inner products are stored up to - this level */ - tiling_t *tiling; /* tiling of the entire image */ - tree_t tree; /* probability model */ - tree_t p_tree; /* prediction probability model */ - motion_t *mt; /* motion compensation information */ - coeff_t *coeff; - coeff_t *d_coeff; + and states 0, ... , i + at all image levels */ + real_t **ip_images_state; /* inner products between all + ranges and state i */ + real_t *pixels; /* current image pixels stored in tree + order (only leaves are stored) */ + unsigned products_level; /* inner products are stored up to + this level */ + tiling_t *tiling; /* tiling of the entire image */ + tree_t tree; /* probability model */ + tree_t p_tree; /* prediction probability model */ + motion_t *mt; /* motion compensation information */ + coeff_t *coeff; + coeff_t *d_coeff; domain_pool_t *domain_pool; domain_pool_t *d_domain_pool; - c_options_t options; /* global options */ + c_options_t options; /* global options */ } coding_t; #endif /* not _CWFA_H */ diff --git a/converter/other/fiasco/codec/decoder.h b/converter/other/fiasco/codec/decoder.h index 7823ab91..d11ccefd 100644 --- a/converter/other/fiasco/codec/decoder.h +++ b/converter/other/fiasco/codec/decoder.h @@ -1,8 +1,8 @@ /* * decode.h - * - * Written by: Ullrich Hafner - * + * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -23,41 +23,41 @@ typedef struct video { - unsigned future_display; /* number of a future frame */ - unsigned display; /* current display number */ - image_t *frame; /* current frame */ - image_t *sframe; /* current smoothed frame */ - image_t *future; /* future reference */ - image_t *sfuture; /* future (smmothed) reference */ - image_t *past ; /* past reference */ - wfa_t *wfa; /* current wfa */ - wfa_t *wfa_future; /* future wfa */ - wfa_t *wfa_past; /* past wfa */ + unsigned future_display; /* number of a future frame */ + unsigned display; /* current display number */ + image_t *frame; /* current frame */ + image_t *sframe; /* current smoothed frame */ + image_t *future; /* future reference */ + image_t *sfuture; /* future (smmothed) reference */ + image_t *past ; /* past reference */ + wfa_t *wfa; /* current wfa */ + wfa_t *wfa_future; /* future wfa */ + wfa_t *wfa_past; /* past wfa */ } video_t; typedef struct dectimer { - unsigned int input [3]; - unsigned int preprocessing [3]; - unsigned int decoder [3]; - unsigned int cleanup [3]; - unsigned int motion [3]; - unsigned int smooth [3]; - unsigned int display [3]; - unsigned int frames [3]; + unsigned int input [3]; + unsigned int preprocessing [3]; + unsigned int decoder [3]; + unsigned int cleanup [3]; + unsigned int motion [3]; + unsigned int smooth [3]; + unsigned int display [3]; + unsigned int frames [3]; } dectimer_t; 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); 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); 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); image_t * decode_state (unsigned state, unsigned level, wfa_t *wfa); void diff --git a/converter/other/fiasco/codec/dfiasco.c b/converter/other/fiasco/codec/dfiasco.c index ce25654a..3f5d3fcc 100644 --- a/converter/other/fiasco/codec/dfiasco.c +++ b/converter/other/fiasco/codec/dfiasco.c @@ -1,7 +1,7 @@ /* - * dfiasco.c: Decoder public interface + * dfiasco.c: Decoder public interface * - * Written by: Ullrich Hafner + * Written by: Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -37,7 +37,7 @@ /***************************************************************************** - prototypes + prototypes *****************************************************************************/ @@ -47,11 +47,11 @@ static void free_dfiasco (dfiasco_t *dfiasco); static dfiasco_t * alloc_dfiasco (wfa_t *wfa, video_t *video, bitfile_t *input, - int enlarge_factor, int smoothing, format_e image_format); + int enlarge_factor, int smoothing, format_e image_format); /***************************************************************************** - public code + public code *****************************************************************************/ @@ -60,24 +60,24 @@ fiasco_decoder_new (const char *filename, const fiasco_d_options_t *options) { try { - bitfile_t *input; /* pointer to WFA FIASCO stream */ - wfa_t *wfa; /* wfa structure */ - video_t *video; /* information about decoder state */ - const d_options_t *dop; /* decoder additional options */ - dfiasco_t *dfiasco; /* decoder internal state */ - fiasco_decoder_t *decoder; /* public interface to decoder */ + bitfile_t *input; /* pointer to WFA FIASCO stream */ + wfa_t *wfa; /* wfa structure */ + video_t *video; /* information about decoder state */ + const d_options_t *dop; /* decoder additional options */ + dfiasco_t *dfiasco; /* decoder internal state */ + fiasco_decoder_t *decoder; /* public interface to decoder */ fiasco_d_options_t *default_options = NULL; if (options) { - dop = cast_d_options ((fiasco_d_options_t *) options); - if (!dop) - return NULL; + dop = cast_d_options ((fiasco_d_options_t *) options); + if (!dop) + return NULL; } else { - default_options = fiasco_d_options_new (); - dop = cast_d_options (default_options); + default_options = fiasco_d_options_new (); + dop = cast_d_options (default_options); } wfa = alloc_wfa (NO); @@ -85,8 +85,8 @@ fiasco_decoder_new (const char *filename, const fiasco_d_options_t *options) input = open_wfa (filename, wfa->wfainfo); read_basis (wfa->wfainfo->basis_name, wfa); - decoder = Calloc (1, sizeof (fiasco_decoder_t)); - decoder->delete = fiasco_decoder_delete; + decoder = Calloc (1, sizeof (fiasco_decoder_t)); + decoder->delete = fiasco_decoder_delete; decoder->write_frame = fiasco_decoder_write_frame; decoder->get_frame = fiasco_decoder_get_frame; decoder->get_length = fiasco_decoder_get_length; @@ -98,46 +98,46 @@ fiasco_decoder_new (const char *filename, const fiasco_d_options_t *options) decoder->is_color = fiasco_decoder_is_color; decoder->private = dfiasco - = alloc_dfiasco (wfa, video, input, - dop->magnification, - dop->smoothing, - dop->image_format); + = alloc_dfiasco (wfa, video, input, + dop->magnification, + dop->smoothing, + dop->image_format); if (default_options) - fiasco_d_options_delete (default_options); + fiasco_d_options_delete (default_options); if (dfiasco->enlarge_factor >= 0) { - int n; - unsigned long pixels = wfa->wfainfo->width * wfa->wfainfo->height; - - for (n = 1; n <= (int) dfiasco->enlarge_factor; n++) - { - if (pixels << (n << 1) > 2048 * 2048) - { - set_error (_("Magnifaction factor `%d' is too large. " - "Maximum value is %d."), - dfiasco->enlarge_factor, MAX(0, n - 1)); - fiasco_decoder_delete (decoder); - return NULL; - } - } + int n; + unsigned long pixels = wfa->wfainfo->width * wfa->wfainfo->height; + + for (n = 1; n <= (int) dfiasco->enlarge_factor; n++) + { + if (pixels << (n << 1) > 2048 * 2048) + { + set_error (_("Magnifaction factor `%d' is too large. " + "Maximum value is %d."), + dfiasco->enlarge_factor, MAX(0, n - 1)); + fiasco_decoder_delete (decoder); + return NULL; + } + } } else { - int n; - - for (n = 0; n <= (int) - dfiasco->enlarge_factor; n++) - { - if (wfa->wfainfo->width >> n < 32 - || wfa->wfainfo->height >> n < 32) - { - set_error (_("Magnifaction factor `%d' is too small. " - "Minimum value is %d."), - dfiasco->enlarge_factor, - MAX(0, n - 1)); - fiasco_decoder_delete (decoder); - return NULL; - } - } + int n; + + for (n = 0; n <= (int) - dfiasco->enlarge_factor; n++) + { + if (wfa->wfainfo->width >> n < 32 + || wfa->wfainfo->height >> n < 32) + { + set_error (_("Magnifaction factor `%d' is too small. " + "Minimum value is %d."), + dfiasco->enlarge_factor, - MAX(0, n - 1)); + fiasco_decoder_delete (decoder); + return NULL; + } + } } return (fiasco_decoder_t *) decoder; } @@ -149,7 +149,7 @@ fiasco_decoder_new (const char *filename, const fiasco_d_options_t *options) int fiasco_decoder_write_frame (fiasco_decoder_t *decoder, - const char *filename) + const char *filename) { dfiasco_t *dfiasco = cast_dfiasco (decoder); @@ -159,15 +159,15 @@ fiasco_decoder_write_frame (fiasco_decoder_t *decoder, { try { - image_t *frame = get_next_frame (NO, dfiasco->enlarge_factor, - dfiasco->smoothing, NULL, - FORMAT_4_4_4, dfiasco->video, NULL, - dfiasco->wfa, dfiasco->input); - write_image (filename, frame); + image_t *frame = get_next_frame (NO, dfiasco->enlarge_factor, + dfiasco->smoothing, NULL, + FORMAT_4_4_4, dfiasco->video, NULL, + dfiasco->wfa, dfiasco->input); + write_image (filename, frame); } catch { - return 0; + return 0; } return 1; } @@ -184,25 +184,25 @@ fiasco_decoder_get_frame (fiasco_decoder_t *decoder) { try { - fiasco_image_t *image = Calloc (1, sizeof (fiasco_image_t)); - image_t *frame = get_next_frame (NO, dfiasco->enlarge_factor, - dfiasco->smoothing, NULL, - dfiasco->image_format, - dfiasco->video, NULL, - dfiasco->wfa, dfiasco->input); - - frame->reference_count++; /* for motion compensation */ - image->private = frame; - image->delete = fiasco_image_delete; - image->get_width = fiasco_image_get_width; - image->get_height = fiasco_image_get_height; - image->is_color = fiasco_image_is_color; - - return image; + fiasco_image_t *image = Calloc (1, sizeof (fiasco_image_t)); + image_t *frame = get_next_frame (NO, dfiasco->enlarge_factor, + dfiasco->smoothing, NULL, + dfiasco->image_format, + dfiasco->video, NULL, + dfiasco->wfa, dfiasco->input); + + frame->reference_count++; /* for motion compensation */ + image->private = frame; + image->delete = fiasco_image_delete; + image->get_width = fiasco_image_get_width; + image->get_height = fiasco_image_get_height; + image->is_color = fiasco_image_is_color; + + return image; } catch { - return NULL; + return NULL; } } } @@ -241,9 +241,9 @@ fiasco_decoder_get_width (fiasco_decoder_t *decoder) unsigned width; if (dfiasco->enlarge_factor >= 0) - width = dfiasco->wfa->wfainfo->width << dfiasco->enlarge_factor; + width = dfiasco->wfa->wfainfo->width << dfiasco->enlarge_factor; else - width = dfiasco->wfa->wfainfo->width >> - dfiasco->enlarge_factor; + width = dfiasco->wfa->wfainfo->width >> - dfiasco->enlarge_factor; return width & 1 ? width + 1 : width; } @@ -261,9 +261,9 @@ fiasco_decoder_get_height (fiasco_decoder_t *decoder) unsigned height; if (dfiasco->enlarge_factor >= 0) - height = dfiasco->wfa->wfainfo->height << dfiasco->enlarge_factor; + height = dfiasco->wfa->wfainfo->height << dfiasco->enlarge_factor; else - height = dfiasco->wfa->wfainfo->height >> - dfiasco->enlarge_factor; + height = dfiasco->wfa->wfainfo->height >> - dfiasco->enlarge_factor; return height & 1 ? height + 1 : height; } @@ -329,30 +329,30 @@ fiasco_decoder_delete (fiasco_decoder_t *decoder) /***************************************************************************** - private code + private code *****************************************************************************/ static dfiasco_t * alloc_dfiasco (wfa_t *wfa, video_t *video, bitfile_t *input, - int enlarge_factor, int smoothing, format_e image_format) + int enlarge_factor, int smoothing, format_e image_format) /* * FIASCO decoder constructor: * Initialize decoder structure. * * Return value: - * pointer to the new decoder structure + * pointer to the new decoder structure */ { dfiasco_t *dfiasco = Calloc (1, sizeof (dfiasco_t)); strcpy (dfiasco->id, "DFIASCO"); - dfiasco->wfa = wfa; - dfiasco->video = video; - dfiasco->input = input; + dfiasco->wfa = wfa; + dfiasco->video = video; + dfiasco->input = input; dfiasco->enlarge_factor = enlarge_factor; - dfiasco->smoothing = smoothing; + dfiasco->smoothing = smoothing; dfiasco->image_format = image_format; return dfiasco; @@ -367,7 +367,7 @@ free_dfiasco (dfiasco_t *dfiasco) * No return value. * * Side effects: - * 'video' struct is discarded. + * 'video' struct is discarded. */ { Free (dfiasco); @@ -380,7 +380,7 @@ cast_dfiasco (fiasco_decoder_t *dfiasco) * Check whether `dfiasco' is a valid object of type dfiasco_t. * * Return value: - * pointer to dfiasco_t struct on success + * pointer to dfiasco_t struct on success * NULL otherwise */ { @@ -389,8 +389,8 @@ cast_dfiasco (fiasco_decoder_t *dfiasco) { if (!streq (this->id, "DFIASCO")) { - set_error (_("Parameter `dfiasco' doesn't match required type.")); - return NULL; + set_error (_("Parameter `dfiasco' doesn't match required type.")); + return NULL; } } else diff --git a/converter/other/fiasco/codec/dfiasco.h b/converter/other/fiasco/codec/dfiasco.h index eed12b6b..765a09d4 100644 --- a/converter/other/fiasco/codec/dfiasco.h +++ b/converter/other/fiasco/codec/dfiasco.h @@ -1,8 +1,8 @@ /* * dfiasco.h - * - * Written by: Ullrich Hafner - * + * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -29,7 +29,7 @@ typedef struct dfiasco wfa_t *wfa; video_t *video; bitfile_t *input; - int enlarge_factor; + int enlarge_factor; int smoothing; format_e image_format; } dfiasco_t; diff --git a/converter/other/fiasco/codec/domain-pool.c b/converter/other/fiasco/codec/domain-pool.c index 1c14a30c..e9986269 100644 --- a/converter/other/fiasco/codec/domain-pool.c +++ b/converter/other/fiasco/codec/domain-pool.c @@ -2,7 +2,7 @@ * domain-pool.c: Domain pool management (probability model) * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -34,9 +34,9 @@ /* * Domain pool model interface: * Implementing the domain pool model interface requires the - * following steps: + * following steps: * - Add a constructor that initializes the domain_pool_t structure - * - Allocate new model with default_alloc() + * - Allocate new model with default_alloc() * - Fill the dp_array_t domain_pools array with constructor and name * - Write code for methods bits() and generate() * - Either use default functions for remaining methods or override them @@ -44,9 +44,9 @@ */ /***************************************************************************** - + local variables - + *****************************************************************************/ static real_t *matrix_0 = NULL; @@ -174,7 +174,7 @@ default_alloc (void); /***************************************************************************** public code - + *****************************************************************************/ typedef struct dp_array @@ -185,7 +185,7 @@ typedef struct dp_array } dp_array_t; dp_array_t const domain_pools[] = {{"adaptive", alloc_qac_domain_pool}, - {"constant", alloc_const_domain_pool}, + {"constant", alloc_const_domain_pool}, {"basis", alloc_basis_domain_pool}, {"uniform", alloc_uniform_domain_pool}, {"rle", alloc_rle_domain_pool}, @@ -199,8 +199,8 @@ alloc_domain_pool (const char *domain_pool_name, unsigned max_domains, * Allocate a new domain pool identified by the string * 'domain_pool_name'. Maximum number of domain images (each one * represented by one state of the given 'wfa') is specified by - * 'max_domains'. - * + * 'max_domains'. + * * Return value: * pointer to the allocated domain pool * @@ -209,16 +209,16 @@ alloc_domain_pool (const char *domain_pool_name, unsigned max_domains, */ { unsigned n; - + if (!max_domains) { warning ("Can't generate empty domain pool. " "Using at least DC component."); max_domains = 1; } - + for (n = 0; domain_pools [n].identifier; n++) /* step through all id's */ - if (strcaseeq (domain_pools [n].identifier, domain_pool_name)) + if (strcaseeq (domain_pools [n].identifier, domain_pool_name)) return domain_pools [n].function (max_domains, max_edges, wfa); warning ("Can't initialize domain pool '%s'. Using default value '%s'.", @@ -230,7 +230,7 @@ alloc_domain_pool (const char *domain_pool_name, unsigned max_domains, /***************************************************************************** private code - + *****************************************************************************/ /***************************************************************************** @@ -256,7 +256,7 @@ alloc_qac_domain_pool (unsigned max_domains, unsigned max_edges, { domain_pool_t *pool; unsigned state; - + pool = default_alloc (); pool->model = qac_model_alloc (max_domains); pool->generate = qac_generate; @@ -266,7 +266,7 @@ alloc_qac_domain_pool (unsigned max_domains, unsigned max_edges, pool->chroma = qac_chroma; pool->model_free = qac_model_free; pool->model_duplicate = qac_model_duplicate; - + for (state = 0; state < wfa->basis_states; state++) if (usedomain (state, wfa)) qac_append (state, -1, wfa, pool->model); @@ -308,7 +308,7 @@ qac_model_duplicate (const void *src) qdst = qac_model_alloc (qsrc->max_domains); qdst->y_index = qsrc->y_index; qdst->n = qsrc->n; - + memcpy (qdst->index, qsrc->index, qsrc->n * sizeof (word_t)); memcpy (qdst->states, qsrc->states, qsrc->n * sizeof (word_t)); @@ -325,14 +325,14 @@ qac_generate (unsigned level, int y_state, const wfa_t *wfa, const void *model) if (y_state >= 0 && !usedomain (y_state, wfa)) /* don't use y-state */ y_state = -1; - + domains = Calloc (qac_model->n + 2, sizeof (word_t)); memcpy (domains, qac_model->states, qac_model->n * sizeof (word_t)); for (n = 0; n < qac_model->n; n++) if (domains [n] == y_state) /* match */ - y_state_is_domain = YES; + y_state_is_domain = YES; if (y_state_is_domain) domains [qac_model->n] = -1; /* end marker */ @@ -361,11 +361,11 @@ qac_bits (const word_t *domains, const word_t *used_domains, bits += matrix_0 [qac_model->index [domain]]; if (y_state >= 0) bits += matrix_0 [qac_model->y_index]; - + if (used_domains != NULL) { unsigned edge; - + for (edge = 0; isedge (domain = used_domains [edge]); edge++) if (domains [domain] == y_state) { @@ -377,8 +377,8 @@ qac_bits (const word_t *domains, const word_t *used_domains, bits -= matrix_0 [qac_model->index [domain]]; bits += matrix_1 [qac_model->index [domain]]; } - } - + } + return bits; } @@ -391,7 +391,7 @@ qac_update (const word_t *domains, const word_t *used_domains, bool_t used_y_state = NO; qac_model_t *qac_model = (qac_model_t *) model; bool_t y_state_is_domain = NO; - + if (y_state >= 0 && !usedomain (y_state, wfa)) /* don't use y-state */ y_state = -1; @@ -399,9 +399,9 @@ qac_update (const word_t *domains, const word_t *used_domains, { qac_model->index [domain]++; /* mark domains unused. */ if (qac_model->states [domain] == y_state) /* match */ - y_state_is_domain = YES; + y_state_is_domain = YES; } - + for (edge = 0; isedge (domain = used_domains [edge]); edge++) if (domains [domain] == y_state) /* chroma coding */ { @@ -413,24 +413,24 @@ qac_update (const word_t *domains, const word_t *used_domains, else /* luminance coding */ { qac_model->index [used_domains [edge]]--; /* undo */ - qac_model->index [used_domains [edge]] >>= 1; + qac_model->index [used_domains [edge]] >>= 1; } if (y_state >= 0 && !used_y_state) qac_model->y_index++; /* update y-state model */ - + for (domain = 0; domain < qac_model->n; domain++) if (qac_model->index [domain] > 1020) /* check for overflow */ - qac_model->index [domain] = 1020; + qac_model->index [domain] = 1020; if (qac_model->y_index > 1020) /* check for overflow */ - qac_model->y_index = 1020; + qac_model->y_index = 1020; } static bool_t qac_append (unsigned new_state, unsigned level, const wfa_t *wfa, void *model) { qac_model_t *qac_model = (qac_model_t *) model; /* probability model */ - + if (qac_model->n >= qac_model->max_domains) return NO; /* don't use state in domain pool */ else @@ -448,14 +448,14 @@ static void qac_chroma (unsigned max_domains, const wfa_t *wfa, void *model) { qac_model_t *qac_model = (qac_model_t *) model; /* probability model */ - + if (max_domains < qac_model->n) /* choose most probable domains */ { word_t *domains; unsigned n, new, old; word_t *states = Calloc (max_domains, sizeof (word_t)); word_t *index = Calloc (max_domains, sizeof (word_t)); - + domains = compute_hits (wfa->basis_states, wfa->states - 1, max_domains, wfa); for (n = 0; n < max_domains && domains [n] >= 0; n++) @@ -491,11 +491,11 @@ alloc_const_domain_pool (unsigned max_domains, unsigned max_edges, */ { domain_pool_t *pool; - - pool = default_alloc (); + + pool = default_alloc (); pool->generate = const_generate; pool->bits = const_bits; - + return pool; } @@ -504,10 +504,10 @@ const_generate (unsigned level, int y_state, const wfa_t *wfa, const void *model) { word_t *domains = Calloc (2, sizeof (word_t)); - + domains [0] = 0; domains [1] = -1; - + return domains; } @@ -548,11 +548,11 @@ alloc_uniform_domain_pool (unsigned max_domains, unsigned max_edges, */ { domain_pool_t *pool; - - pool = default_alloc (); + + pool = default_alloc (); pool->generate = uniform_generate; pool->bits = uniform_bits; - + return pool; } @@ -567,17 +567,17 @@ uniform_generate (unsigned level, int y_state, const wfa_t *wfa, if (usedomain (state, wfa)) domains [n++] = state; domains [n] = -1; - + return domains; } - + static real_t uniform_bits (const word_t *domains, const word_t *used_domains, unsigned level, int y_state, const wfa_t *wfa, const void *model) { unsigned state, n; real_t bits = 0; - + for (state = 0, n = 0; state < wfa->states; state++) if (usedomain (state, wfa)) n++; @@ -587,7 +587,7 @@ uniform_bits (const word_t *domains, const word_t *used_domains, if (used_domains != NULL) { int edge; - + for (edge = 0; isedge (used_domains [edge]); edge++) bits -= log2 (1.0 / n); } @@ -615,13 +615,13 @@ alloc_rle_domain_pool (unsigned max_domains, unsigned max_edges, const wfa_t *wfa) /* * Domain pool with state images {0, ..., 'max_domains'). - * Underlying probability model: rle + * Underlying probability model: rle */ { domain_pool_t *pool; unsigned state; - - pool = default_alloc (); + + pool = default_alloc (); pool->model = rle_model_alloc (max_domains); pool->model_free = rle_model_free; pool->model_duplicate = rle_model_duplicate; @@ -643,7 +643,7 @@ rle_model_alloc (unsigned max_domains) { unsigned m; rle_model_t *model = Calloc (1, sizeof (rle_model_t)); - + for (m = model->total = 0; m < MAXEDGES + 1; m++, model->total++) model->count [m] = 1; @@ -652,7 +652,7 @@ rle_model_alloc (unsigned max_domains) model->n = 0; model->y_index = 0; model->max_domains = max_domains; - + return model; } @@ -676,12 +676,12 @@ rle_model_duplicate (const void *src) model->states = Calloc (model->max_domains, sizeof (word_t)); model->total = rle_src->total; model->y_index = rle_src->y_index; - + memcpy (model->states, rle_src->states, model->max_domains * sizeof (word_t)); memcpy (model->count, rle_src->count, (MAXEDGES + 1) * sizeof (word_t)); - + return model; } @@ -692,17 +692,17 @@ rle_generate (unsigned level, int y_state, const wfa_t *wfa, const void *model) unsigned n; rle_model_t *rle_model = (rle_model_t *) model; bool_t y_state_is_domain = NO; - + if (y_state >= 0 && !usedomain (y_state, wfa)) /* don't use y-state */ y_state = -1; - + domains = Calloc (rle_model->n + 2, sizeof (word_t)); memcpy (domains, rle_model->states, rle_model->n * sizeof (word_t)); for (n = 0; n < rle_model->n; n++) if (domains [n] == y_state) /* match */ - y_state_is_domain = YES; + y_state_is_domain = YES; if (y_state_is_domain) domains [rle_model->n] = -1; /* end marker */ @@ -726,17 +726,17 @@ rle_bits (const word_t *domains, const word_t *used_domains, rle_model_t *rle_model = (rle_model_t *) model; unsigned last; int into; - + if (y_state >= 0 && !usedomain (y_state, wfa)) /* don't use y-state */ y_state = -1; if (used_domains) { word_t domain; - + if (y_state >= 0) bits += matrix_0 [rle_model->y_index]; - + for (edge = n = 0; isedge (domain = used_domains [edge]); edge++) if (domains [domain] != y_state) sorted [n++] = used_domains [edge]; @@ -745,7 +745,7 @@ rle_bits (const word_t *domains, const word_t *used_domains, bits -= matrix_0 [rle_model->y_index]; bits += matrix_1 [rle_model->y_index]; } - + if (n > 1) qsort (sorted, n, sizeof (word_t), sort_asc_word); } @@ -761,7 +761,7 @@ rle_bits (const word_t *domains, const word_t *used_domains, word_t array0 [2] = {NO_EDGE}; bits += qac_bits (array0, array0, level, y_state, wfa, rle_model->domain_0); } - + last = 1; for (edge = 0; edge < n; edge++) if ((into = sorted [edge]) && rle_model->n - 1 - last) @@ -769,7 +769,7 @@ rle_bits (const word_t *domains, const word_t *used_domains, bits += bits_bin_code (into - last, rle_model->n - 1 - last); last = into + 1; } - + return bits; } @@ -781,21 +781,21 @@ rle_update (const word_t *domains, const word_t *used_domains, bool_t state_0 = NO, state_y = NO; word_t array0 [2] = {0, NO_EDGE}; unsigned edge = 0; - + if (y_state >= 0 && !usedomain (y_state, wfa)) /* don't use y-state */ y_state = -1; if (used_domains) { word_t domain; - + for (edge = 0; isedge (domain = used_domains [edge]); edge++) if (domains [domain] == 0) state_0 = YES; else if (domains [domain] == y_state) state_y = YES; } - + rle_model->count [edge]++; rle_model->total++; @@ -807,14 +807,14 @@ rle_update (const word_t *domains, const word_t *used_domains, else rle_model->y_index++; if (rle_model->y_index > 1020) /* check for overflow */ - rle_model->y_index = 1020; + rle_model->y_index = 1020; } static bool_t rle_append (unsigned new_state, unsigned level, const wfa_t *wfa, void *model) { rle_model_t *rle_model = (rle_model_t *) model; /* probability model */ - + if (rle_model->n >= rle_model->max_domains) return NO; /* don't use state in domain pool */ else @@ -827,7 +827,7 @@ rle_append (unsigned new_state, unsigned level, const wfa_t *wfa, void *model) assert (rle_model->n == 1); qac_append (0, -1, wfa, rle_model->domain_0); } - + return YES; /* state will be used in domain pool */ } } @@ -836,14 +836,14 @@ static void rle_chroma (unsigned max_domains, const wfa_t *wfa, void *model) { rle_model_t *rle_model = (rle_model_t *) model; /* probability model */ - + if (max_domains < rle_model->n) /* choose most probable domains */ { unsigned n; word_t *states = Calloc (max_domains, sizeof (word_t)); word_t *domains = compute_hits (wfa->basis_states, wfa->states - 1, max_domains, wfa); - + for (n = 0; n < max_domains && domains [n] >= 0; n++) states [n] = domains [n]; @@ -868,12 +868,12 @@ alloc_rle_no_chroma_domain_pool (unsigned max_domains, unsigned max_edges, const wfa_t *wfa) /* * Domain pool with state images {0, ..., 'max_domains'). - * Underlying probability model: rle + * Underlying probability model: rle * Domain pool is not changed for chroma bands */ { domain_pool_t *pool = alloc_rle_domain_pool (max_domains, max_edges, wfa); - + pool->chroma = default_chroma; return pool; @@ -898,7 +898,7 @@ default_alloc (void) pool->free = default_free; pool->model_free = default_model_free; pool->model_duplicate = default_model_duplicate; - + return pool; } @@ -964,12 +964,12 @@ init_matrix_probabilities (void) { if (matrix_0 == NULL || matrix_1 == NULL) { - unsigned index; + unsigned index; unsigned n, exp; - + matrix_0 = Calloc (1 << (MAX_PROB + 1), sizeof (real_t)); matrix_1 = Calloc (1 << (MAX_PROB + 1), sizeof (real_t)); - + for (index = 0, n = MIN_PROB; n <= MAX_PROB; n++) for (exp = 0; exp < (unsigned) 1 << n; exp++, index++) { diff --git a/converter/other/fiasco/codec/domain-pool.h b/converter/other/fiasco/codec/domain-pool.h index a2c46141..b3258b67 100644 --- a/converter/other/fiasco/codec/domain-pool.h +++ b/converter/other/fiasco/codec/domain-pool.h @@ -1,8 +1,8 @@ /* * domain-pool.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -22,42 +22,42 @@ typedef struct domain_pool { - void *model; /* probability model */ + void *model; /* probability model */ word_t *(*generate) (unsigned level, int y_state, const wfa_t *wfa, - const void *model); + const void *model); /* * Generate set of domain images which may be used for an approximation. * Use parameters 'level', 'y_state' and 'wfa' to make the decision. */ real_t (*bits) (const word_t *domains, const word_t *used_domains, - unsigned level, int y_state, const wfa_t *wfa, - const void *model); + unsigned level, int y_state, const wfa_t *wfa, + const void *model); /* * Compute bit-rate of a range approximation with domains given by * the -1 terminated list 'used_domains'. */ - void (*update) (const word_t *domains, const word_t *used_domains, - unsigned level, int y_state, const wfa_t *wfa, - void *model); + void (*update) (const word_t *domains, const word_t *used_domains, + unsigned level, int y_state, const wfa_t *wfa, + void *model); /* * Update the probability model according to the chosen approximation. * (given by the -1 terminated list 'used_domains'). */ bool_t (*append) (unsigned state, unsigned level, const wfa_t *wfa, - void *model); + void *model); /* * Try to append a new state to the domain pool. */ - void (*chroma) (unsigned max_domains, const wfa_t *wfa, void *model); + void (*chroma) (unsigned max_domains, const wfa_t *wfa, void *model); /* * Derive a new domain pool that will be used for chroma channel - * coding + * coding */ void (*free) (struct domain_pool *pool); /* * Discard the given domain pool struct. */ - void (*model_free) (void *model); + void (*model_free) (void *model); /* * Free given probability model. */ @@ -69,7 +69,7 @@ typedef struct domain_pool domain_pool_t * alloc_domain_pool (const char *domain_pool_name, unsigned max_domains, - unsigned max_edges, const wfa_t *wfa); + unsigned max_edges, const wfa_t *wfa); #endif /* not _DOMAIN_POOL_H */ diff --git a/converter/other/fiasco/codec/ip.c b/converter/other/fiasco/codec/ip.c index 18257a06..4209ab21 100644 --- a/converter/other/fiasco/codec/ip.c +++ b/converter/other/fiasco/codec/ip.c @@ -1,7 +1,7 @@ /* - * ip.c: Computation of inner products + * ip.c: Computation of inner products * - * Written by: Ullrich Hafner + * Written by: Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -26,29 +26,29 @@ /***************************************************************************** - prototypes + prototypes *****************************************************************************/ static real_t standard_ip_image_state (unsigned address, unsigned level, unsigned domain, - const coding_t *c); + const coding_t *c); static real_t standard_ip_state_state (unsigned domain1, unsigned domain2, unsigned level, - const coding_t *c); + const coding_t *c); /***************************************************************************** - public code + public code *****************************************************************************/ real_t get_ip_image_state (unsigned image, unsigned address, unsigned level, - unsigned domain, const coding_t *c) + unsigned domain, const coding_t *c) /* * Return value: - * Inner product between 'image' ('address') and + * Inner product between 'image' ('address') and * 'domain' at given 'level' */ { @@ -71,8 +71,8 @@ get_ip_image_state (unsigned image, unsigned address, unsigned level, void compute_ip_images_state (unsigned image, unsigned address, unsigned level, - unsigned n, unsigned from, - const wfa_t *wfa, coding_t *c) + unsigned n, unsigned from, + const wfa_t *wfa, coding_t *c) /* * Compute the inner products between all states * 'from', ... , 'wfa->max_states' and the range images 'image' @@ -81,84 +81,84 @@ compute_ip_images_state (unsigned image, unsigned address, unsigned level, * No return value. * * Side effects: - * inner product tables 'c->ip_images_states' are updated + * inner product tables 'c->ip_images_states' are updated */ { if (level > c->options.images_level) { unsigned state, label; - if (level > c->options.images_level + 1) /* recursive computation */ - compute_ip_images_state (MAXLABELS * image + 1, address * MAXLABELS, - level - 1, MAXLABELS * n, from, wfa, c); + if (level > c->options.images_level + 1) /* recursive computation */ + compute_ip_images_state (MAXLABELS * image + 1, address * MAXLABELS, + level - 1, MAXLABELS * n, from, wfa, c); /* * Compute inner product <f, Phi_i> */ for (label = 0; label < MAXLABELS; label++) - for (state = from; state < wfa->states; state++) - if (need_image (state, wfa)) - { - unsigned edge, count; - int domain; - real_t *dst, *src; - - if (ischild (domain = wfa->tree [state][label])) - { - if (level > c->options.images_level + 1) - { - dst = c->ip_images_state [state] + image; - src = c->ip_images_state [domain] - + image * MAXLABELS + label + 1; - for (count = n; count; count--, src += MAXLABELS) - *dst++ += *src; - } - else - { - unsigned newadr = address * MAXLABELS + label; - - dst = c->ip_images_state [state] + image; - - for (count = n; count; count--, newadr += MAXLABELS) - *dst++ += standard_ip_image_state (newadr, level - 1, - domain, c); - } - } - for (edge = 0; isedge (domain = wfa->into [state][label][edge]); - edge++) - { - real_t weight = wfa->weight [state][label][edge]; - - if (level > c->options.images_level + 1) - { - dst = c->ip_images_state [state] + image; - src = c->ip_images_state [domain] - + image * MAXLABELS + label + 1; - for (count = n; count; count--, src += MAXLABELS) - *dst++ += *src * weight; - } - else - { - unsigned newadr = address * MAXLABELS + label; - - dst = c->ip_images_state [state] + image; - - for (count = n; count; count--, newadr += MAXLABELS) - *dst++ += weight * - standard_ip_image_state (newadr, level - 1, - domain, c); - } - } - } + for (state = from; state < wfa->states; state++) + if (need_image (state, wfa)) + { + unsigned edge, count; + int domain; + real_t *dst, *src; + + if (ischild (domain = wfa->tree [state][label])) + { + if (level > c->options.images_level + 1) + { + dst = c->ip_images_state [state] + image; + src = c->ip_images_state [domain] + + image * MAXLABELS + label + 1; + for (count = n; count; count--, src += MAXLABELS) + *dst++ += *src; + } + else + { + unsigned newadr = address * MAXLABELS + label; + + dst = c->ip_images_state [state] + image; + + for (count = n; count; count--, newadr += MAXLABELS) + *dst++ += standard_ip_image_state (newadr, level - 1, + domain, c); + } + } + for (edge = 0; isedge (domain = wfa->into [state][label][edge]); + edge++) + { + real_t weight = wfa->weight [state][label][edge]; + + if (level > c->options.images_level + 1) + { + dst = c->ip_images_state [state] + image; + src = c->ip_images_state [domain] + + image * MAXLABELS + label + 1; + for (count = n; count; count--, src += MAXLABELS) + *dst++ += *src * weight; + } + else + { + unsigned newadr = address * MAXLABELS + label; + + dst = c->ip_images_state [state] + image; + + for (count = n; count; count--, newadr += MAXLABELS) + *dst++ += weight * + standard_ip_image_state (newadr, level - 1, + domain, c); + } + } + } } } real_t get_ip_state_state (unsigned domain1, unsigned domain2, unsigned level, - const coding_t *c) + const coding_t *c) /* * Return value: - * Inner product between 'domain1' and 'domain2' at given 'level'. + * Inner product between 'domain1' and 'domain2' at given 'level'. */ { if (level <= c->options.images_level) @@ -175,15 +175,15 @@ get_ip_state_state (unsigned domain1, unsigned domain2, unsigned level, * Use already computed inner products stored in 'ip_images_states' */ if (domain2 < domain1) - return c->ip_states_state [domain1][level][domain2]; + return c->ip_states_state [domain1][level][domain2]; else - return c->ip_states_state [domain2][level][domain1]; + return c->ip_states_state [domain2][level][domain1]; } } void compute_ip_states_state (unsigned from, unsigned to, - const wfa_t *wfa, coding_t *c) + const wfa_t *wfa, coding_t *c) /* * Computes the inner products between the current state 'state1' and the * old states 0,...,'state1'-1 @@ -191,7 +191,7 @@ compute_ip_states_state (unsigned from, unsigned to, * No return value. * * Side effects: - * inner product tables 'c->ip_states_state' are computed. + * inner product tables 'c->ip_states_state' are computed. */ { unsigned level; @@ -202,72 +202,72 @@ compute_ip_states_state (unsigned from, unsigned to, */ for (level = c->options.images_level + 1; - level <= c->options.lc_max_level; level++) + level <= c->options.lc_max_level; level++) for (state1 = from; state1 <= to; state1++) - for (state2 = 0; state2 <= state1; state2++) - if (need_image (state2, wfa)) - { - unsigned label; - real_t ip = 0; - - for (label = 0; label < MAXLABELS; label++) - { - int domain1, domain2; - unsigned edge1, edge2; - real_t sum, weight2; - - if (ischild (domain1 = wfa->tree [state1][label])) - { - sum = 0; - if (ischild (domain2 = wfa->tree [state2][label])) - sum = get_ip_state_state (domain1, domain2, - level - 1, c); - - for (edge2 = 0; - isedge (domain2 = wfa->into [state2][label][edge2]); - edge2++) - { - weight2 = wfa->weight [state2][label][edge2]; - sum += weight2 * get_ip_state_state (domain1, domain2, - level - 1, c); - } - ip += sum; - } - for (edge1 = 0; - isedge (domain1 = wfa->into [state1][label][edge1]); - edge1++) - { - real_t weight1 = wfa->weight [state1][label][edge1]; - - sum = 0; - if (ischild (domain2 = wfa->tree [state2][label])) - sum = get_ip_state_state (domain1, domain2, - level - 1, c); - - for (edge2 = 0; - isedge (domain2 = wfa->into [state2][label][edge2]); - edge2++) - { - weight2 = wfa->weight [state2][label][edge2]; - sum += weight2 * get_ip_state_state (domain1, domain2, - level - 1, c); - } - ip += weight1 * sum; - } - } - c->ip_states_state [state1][level][state2] = ip; - } + for (state2 = 0; state2 <= state1; state2++) + if (need_image (state2, wfa)) + { + unsigned label; + real_t ip = 0; + + for (label = 0; label < MAXLABELS; label++) + { + int domain1, domain2; + unsigned edge1, edge2; + real_t sum, weight2; + + if (ischild (domain1 = wfa->tree [state1][label])) + { + sum = 0; + if (ischild (domain2 = wfa->tree [state2][label])) + sum = get_ip_state_state (domain1, domain2, + level - 1, c); + + for (edge2 = 0; + isedge (domain2 = wfa->into [state2][label][edge2]); + edge2++) + { + weight2 = wfa->weight [state2][label][edge2]; + sum += weight2 * get_ip_state_state (domain1, domain2, + level - 1, c); + } + ip += sum; + } + for (edge1 = 0; + isedge (domain1 = wfa->into [state1][label][edge1]); + edge1++) + { + real_t weight1 = wfa->weight [state1][label][edge1]; + + sum = 0; + if (ischild (domain2 = wfa->tree [state2][label])) + sum = get_ip_state_state (domain1, domain2, + level - 1, c); + + for (edge2 = 0; + isedge (domain2 = wfa->into [state2][label][edge2]); + edge2++) + { + weight2 = wfa->weight [state2][label][edge2]; + sum += weight2 * get_ip_state_state (domain1, domain2, + level - 1, c); + } + ip += weight1 * sum; + } + } + c->ip_states_state [state1][level][state2] = ip; + } } /***************************************************************************** - private code + private code *****************************************************************************/ static real_t standard_ip_image_state (unsigned address, unsigned level, unsigned domain, - const coding_t *c) + const coding_t *c) /* * Returns the inner product between the subimage 'address' and the * state image 'domain' at given 'level'. The stored state images @@ -275,7 +275,7 @@ standard_ip_image_state (unsigned address, unsigned level, unsigned domain, * standard way by multiplying the corresponding pixel values. * * Return value: - * computed inner product + * computed inner product */ { unsigned i; @@ -296,7 +296,7 @@ standard_ip_image_state (unsigned address, unsigned level, unsigned domain, static real_t standard_ip_state_state (unsigned domain1, unsigned domain2, unsigned level, - const coding_t *c) + const coding_t *c) /* * Returns the inner product between the subimage 'address' and the * state image 'state' at given 'level'. The stored state images are @@ -304,7 +304,7 @@ standard_ip_state_state (unsigned domain1, unsigned domain2, unsigned level, * multiplying the corresponding pixel values. * * Return value: - * computed inner product + * computed inner product */ { unsigned i; diff --git a/converter/other/fiasco/codec/ip.h b/converter/other/fiasco/codec/ip.h index 0c693826..f7d7efac 100644 --- a/converter/other/fiasco/codec/ip.h +++ b/converter/other/fiasco/codec/ip.h @@ -1,8 +1,8 @@ /* * ip.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -19,19 +19,19 @@ #include "cwfa.h" -void +void compute_ip_states_state (unsigned from, unsigned to, - const wfa_t *wfa, coding_t *c); -real_t + const wfa_t *wfa, coding_t *c); +real_t get_ip_state_state (unsigned domain1, unsigned domain2, unsigned level, - const coding_t *c); -void + const coding_t *c); +void compute_ip_images_state (unsigned image, unsigned address, unsigned level, - unsigned n, unsigned from, - const wfa_t *wfa, coding_t *c); -real_t + unsigned n, unsigned from, + const wfa_t *wfa, coding_t *c); +real_t get_ip_image_state (unsigned image, unsigned address, unsigned level, - unsigned domain, const coding_t *c); + unsigned domain, const coding_t *c); #endif /* not _IP_H */ diff --git a/converter/other/fiasco/codec/motion.c b/converter/other/fiasco/codec/motion.c index 0d1fa099..18d3bdd3 100644 --- a/converter/other/fiasco/codec/motion.c +++ b/converter/other/fiasco/codec/motion.c @@ -1,9 +1,9 @@ /* - * motion.c: Motion compensation code + * motion.c: Motion compensation code + * + * Written by: Ullrich Hafner + * Michael Unger * - * Written by: Ullrich Hafner - * Michael Unger - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -31,13 +31,13 @@ /***************************************************************************** - public code - + public code + *****************************************************************************/ void restore_mc (int enlarge_factor, image_t *image, const image_t *past, - const image_t *future, const wfa_t *wfa) + const image_t *future, const wfa_t *wfa) /* * Restore motion compensated prediction of 'image' represented by 'wfa'. * If 'enlarge_factor' != 0 then enlarge image by given amount. @@ -48,193 +48,193 @@ restore_mc (int enlarge_factor, image_t *image, const image_t *past, { unsigned state, label; unsigned root_state; - word_t *mcblock1, *mcblock2; /* MC blocks */ + word_t *mcblock1, *mcblock2; /* MC blocks */ #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 - + 2 * enlarge_factor, 0)), - sizeof (word_t)); + + 2 * enlarge_factor, 0)), + sizeof (word_t)); mcblock2 = Calloc (size_of_level (MAX((int) wfa->wfainfo->p_max_level - + 2 * enlarge_factor, 0)), - sizeof (word_t)); + + 2 * enlarge_factor, 0)), + sizeof (word_t)); if (!image->color) root_state = wfa->root_state; else root_state = wfa->tree [wfa->tree [wfa->root_state][0]][0]; - + for (state = wfa->basis_states; state <= root_state; state++) for (label = 0; label < MAXLABELS; label++) - if (wfa->mv_tree[state][label].type != NONE) - { - color_e band; - unsigned level = wfa->level_of_state [state] - 1; - unsigned width = width_of_level (level); - unsigned height = height_of_level (level); - unsigned offset = image->width - width; - - switch (wfa->mv_tree [state][label].type) - { - case FORWARD: - for (band = first_band (image->color); - band <= last_band (image->color); band++) - { - extract_mc_block (mcblock1, FX (width), FX (height), - past->pixels [band], FX (past->width), - wfa->wfainfo->half_pixel, - FX (wfa->x [state][label]), - FX (wfa->y [state][label]), - FX (wfa->mv_tree [state][label].fx), - FX (wfa->mv_tree [state][label].fy)); - { - word_t *mc1; /* current pixel in MC block */ - word_t *orig; /* current pixel in original image */ - unsigned x, y; /* pixel coordinates */ - - mc1 = mcblock1; - orig = (word_t *) image->pixels [band] - + FX (wfa->x[state][label]) - + FX (wfa->y[state][label]) * FX (image->width); - - for (y = FX (height); y; y--) - { - for (x = FX (width); x; x--) - *orig++ += *mc1++; - - orig += FX (offset); - } - } - } - break; - case BACKWARD: - for (band = first_band (image->color); - band <= last_band (image->color); band++) - { - extract_mc_block (mcblock1, FX (width), FX (height), - future->pixels [band], - FX (future->width), - wfa->wfainfo->half_pixel, - FX (wfa->x [state][label]), - FX (wfa->y [state][label]), - FX (wfa->mv_tree [state][label].bx), - FX (wfa->mv_tree [state][label].by)); - { - word_t *mc1; /* current pixel in MC block 1 */ - word_t *orig; /* current pixel in original image */ - unsigned x, y; /* pixel coordinates */ - - mc1 = mcblock1; - orig = (word_t *) image->pixels [band] - + FX (wfa->x[state][label]) - + FX (wfa->y[state][label]) * FX (image->width); - - for (y = FX (height); y; y--) - { - for (x = FX (width); x; x--) - *orig++ += *mc1++; - - orig += FX (offset); - } - } - } - break; - case INTERPOLATED: - for (band = first_band (image->color); - band <= last_band (image->color); band++) - { - extract_mc_block (mcblock1, FX (width), FX (height), - past->pixels [band], FX (past->width), - wfa->wfainfo->half_pixel, - FX (wfa->x[state][label]), - FX (wfa->y[state][label]), - FX (wfa->mv_tree[state][label].fx), - FX (wfa->mv_tree[state][label].fy)); - extract_mc_block (mcblock2, FX (width), FX (height), - future->pixels [band], - FX (future->width), - wfa->wfainfo->half_pixel, - FX (wfa->x[state][label]), - FX (wfa->y[state][label]), - FX (wfa->mv_tree[state][label].bx), - FX (wfa->mv_tree[state][label].by)); - { - word_t *mc1; /* current pixel in MC block 1 */ - word_t *mc2; /* current pixel in MC block 1 */ - word_t *orig; /* current pixel in original image */ - unsigned x, y; /* pixel coordinates */ - - mc1 = mcblock1; - mc2 = mcblock2; - orig = (word_t *) image->pixels [band] - + FX (wfa->x[state][label]) - + FX (wfa->y[state][label]) * FX (image->width); - - for (y = FX (height); y; y--) - { - for (x = FX (width); x; x--) + if (wfa->mv_tree[state][label].type != NONE) + { + color_e band; + unsigned level = wfa->level_of_state [state] - 1; + unsigned width = width_of_level (level); + unsigned height = height_of_level (level); + unsigned offset = image->width - width; + + switch (wfa->mv_tree [state][label].type) + { + case FORWARD: + for (band = first_band (image->color); + band <= last_band (image->color); band++) + { + extract_mc_block (mcblock1, FX (width), FX (height), + past->pixels [band], FX (past->width), + wfa->wfainfo->half_pixel, + FX (wfa->x [state][label]), + FX (wfa->y [state][label]), + FX (wfa->mv_tree [state][label].fx), + FX (wfa->mv_tree [state][label].fy)); + { + word_t *mc1; /* current pixel in MC block */ + word_t *orig; /* current pixel in original image */ + unsigned x, y; /* pixel coordinates */ + + mc1 = mcblock1; + orig = (word_t *) image->pixels [band] + + FX (wfa->x[state][label]) + + FX (wfa->y[state][label]) * FX (image->width); + + for (y = FX (height); y; y--) + { + for (x = FX (width); x; x--) + *orig++ += *mc1++; + + orig += FX (offset); + } + } + } + break; + case BACKWARD: + for (band = first_band (image->color); + band <= last_band (image->color); band++) + { + extract_mc_block (mcblock1, FX (width), FX (height), + future->pixels [band], + FX (future->width), + wfa->wfainfo->half_pixel, + FX (wfa->x [state][label]), + FX (wfa->y [state][label]), + FX (wfa->mv_tree [state][label].bx), + FX (wfa->mv_tree [state][label].by)); + { + word_t *mc1; /* current pixel in MC block 1 */ + word_t *orig; /* current pixel in original image */ + unsigned x, y; /* pixel coordinates */ + + mc1 = mcblock1; + orig = (word_t *) image->pixels [band] + + FX (wfa->x[state][label]) + + FX (wfa->y[state][label]) * FX (image->width); + + for (y = FX (height); y; y--) + { + for (x = FX (width); x; x--) + *orig++ += *mc1++; + + orig += FX (offset); + } + } + } + break; + case INTERPOLATED: + for (band = first_band (image->color); + band <= last_band (image->color); band++) + { + extract_mc_block (mcblock1, FX (width), FX (height), + past->pixels [band], FX (past->width), + wfa->wfainfo->half_pixel, + FX (wfa->x[state][label]), + FX (wfa->y[state][label]), + FX (wfa->mv_tree[state][label].fx), + FX (wfa->mv_tree[state][label].fy)); + extract_mc_block (mcblock2, FX (width), FX (height), + future->pixels [band], + FX (future->width), + wfa->wfainfo->half_pixel, + FX (wfa->x[state][label]), + FX (wfa->y[state][label]), + FX (wfa->mv_tree[state][label].bx), + FX (wfa->mv_tree[state][label].by)); + { + word_t *mc1; /* current pixel in MC block 1 */ + word_t *mc2; /* current pixel in MC block 1 */ + word_t *orig; /* current pixel in original image */ + unsigned x, y; /* pixel coordinates */ + + mc1 = mcblock1; + mc2 = mcblock2; + orig = (word_t *) image->pixels [band] + + FX (wfa->x[state][label]) + + FX (wfa->y[state][label]) * FX (image->width); + + for (y = FX (height); y; y--) + { + for (x = FX (width); x; x--) #ifdef HAVE_SIGNED_SHIFT - *orig++ += (*mc1++ + *mc2++) >> 1; + *orig++ += (*mc1++ + *mc2++) >> 1; #else /* not HAVE_SIGNED_SHIFT */ - *orig++ += (*mc1++ + *mc2++) / 2; + *orig++ += (*mc1++ + *mc2++) / 2; #endif /* not HAVE_SIGNED_SHIFT */ - orig += FX (offset); - } - } - } - break; - default: - break; - } - } + orig += FX (offset); + } + } + } + break; + default: + break; + } + } if (image->color) { - unsigned n; - word_t *ptr; + unsigned n; + word_t *ptr; static int *clipping = NULL; - unsigned shift = image->format == FORMAT_4_2_0 ? 2 : 0; + unsigned shift = image->format == FORMAT_4_2_0 ? 2 : 0; - if (!clipping) /* initialize clipping table */ + if (!clipping) /* initialize clipping table */ { - int i; - - clipping = Calloc (256 * 3, sizeof (int)); - for (i = -128; i < 128; i++) - clipping [256 + i + 128] = i; - for (i = 0; i < 256; i++) - clipping [i] = clipping [256]; - for (i = 512; i < 512 + 256; i++) - clipping [i] = clipping [511]; - clipping += 256 + 128; + int i; + + clipping = Calloc (256 * 3, sizeof (int)); + for (i = -128; i < 128; i++) + clipping [256 + i + 128] = i; + for (i = 0; i < 256; i++) + clipping [i] = clipping [256]; + for (i = 512; i < 512 + 256; i++) + clipping [i] = clipping [511]; + clipping += 256 + 128; } - + ptr = image->pixels [Cb]; for (n = (image->width * image->height) >> shift; n; n--, ptr++) #ifdef HAVE_SIGNED_SHIFT - *ptr = clipping [*ptr >> 4] << 4; + *ptr = clipping [*ptr >> 4] << 4; #else /* not HAVE_SIGNED_SHIFT */ - *ptr = clipping [*ptr / 16] * 16; + *ptr = clipping [*ptr / 16] * 16; #endif /* not HAVE_SIGNED_SHIFT */ ptr = image->pixels [Cr]; for (n = (image->width * image->height) >> shift; n; n--, ptr++) #ifdef HAVE_SIGNED_SHIFT - *ptr = clipping [*ptr >> 4] << 4; + *ptr = clipping [*ptr >> 4] << 4; #else /* not HAVE_SIGNED_SHIFT */ *ptr = clipping [*ptr / 16] * 16; #endif /* not HAVE_SIGNED_SHIFT */ } - + Free (mcblock1); Free (mcblock2); } void extract_mc_block (word_t *mcblock, unsigned width, unsigned height, - const word_t *reference, unsigned ref_width, - bool_t half_pixel, unsigned xo, unsigned yo, - unsigned mx, unsigned my) + const word_t *reference, unsigned ref_width, + bool_t half_pixel, unsigned xo, unsigned yo, + unsigned mx, unsigned my) /* * Extract motion compensation image 'mcblock' of size 'width'x'height' * from 'reference' image (width is given by 'ref_width'). @@ -244,93 +244,93 @@ extract_mc_block (word_t *mcblock, unsigned width, unsigned height, * No return value. * * Side effects: - * 'mcblock[]' MCPE block is filled with reference pixels + * 'mcblock[]' MCPE block is filled with reference pixels */ { - if (!half_pixel) /* Fullpixel precision */ + if (!half_pixel) /* Fullpixel precision */ { - const word_t *rblock; /* pointer to reference image */ - unsigned y; /* current row */ - + const word_t *rblock; /* pointer to reference image */ + unsigned y; /* current row */ + rblock = reference + (yo + my) * ref_width + (xo + mx); - for (y = height; y; y--) + for (y = height; y; y--) { - memcpy (mcblock, rblock, width * sizeof (word_t)); + memcpy (mcblock, rblock, width * sizeof (word_t)); - mcblock += width; - rblock += ref_width; + mcblock += width; + rblock += ref_width; } } - else /* Halfpixel precision */ + else /* Halfpixel precision */ { - unsigned x, y; /* current coordinates */ - unsigned offset; /* remaining pixels in row */ - const word_t *rblock; /* pointer to reference image */ - const word_t *ryblock; /* pointer to next line */ - const word_t *rxblock; /* pointer to next column */ - const word_t *rxyblock; /* pointer to next column & row */ - + unsigned x, y; /* current coordinates */ + unsigned offset; /* remaining pixels in row */ + const word_t *rblock; /* pointer to reference image */ + const word_t *ryblock; /* pointer to next line */ + const word_t *rxblock; /* pointer to next column */ + const word_t *rxyblock; /* pointer to next column & row */ + rblock = reference + (yo + my / 2) * ref_width + (xo + mx / 2); - ryblock = rblock + ref_width; /* pixel in next row */ - rxblock = rblock + 1; /* pixel in next column */ - rxyblock = ryblock + 1; /* pixel in next row & column */ + ryblock = rblock + ref_width; /* pixel in next row */ + rxblock = rblock + 1; /* pixel in next column */ + rxyblock = ryblock + 1; /* pixel in next row & column */ offset = ref_width - width; - + if ((mx & 1) == 0) { - if ((my & 1) == 0) /* Don't use halfpixel refinement */ - for (y = height; y; y--) - { - memcpy (mcblock, rblock, width * sizeof (word_t)); - - mcblock += width; - rblock += ref_width; - } - else /* Halfpixel in y direction */ - for (y = height; y; y--) - { - for (x = width; x; x--) + if ((my & 1) == 0) /* Don't use halfpixel refinement */ + for (y = height; y; y--) + { + memcpy (mcblock, rblock, width * sizeof (word_t)); + + mcblock += width; + rblock += ref_width; + } + else /* Halfpixel in y direction */ + for (y = height; y; y--) + { + for (x = width; x; x--) #ifdef HAVE_SIGNED_SHIFT - *mcblock++ = (*rblock++ + *ryblock++) >> 1; + *mcblock++ = (*rblock++ + *ryblock++) >> 1; #else /* not HAVE_SIGNED_SHIFT */ - *mcblock++ = (*rblock++ + *ryblock++) / 2; + *mcblock++ = (*rblock++ + *ryblock++) / 2; #endif /* not HAVE_SIGNED_SHIFT */ - rblock += offset; - ryblock += offset; - } + rblock += offset; + ryblock += offset; + } } else { - if ((my & 1) == 0) /* Halfpixel in x direction */ - for (y = height; y; y--) - { - for (x = width; x; x--) + if ((my & 1) == 0) /* Halfpixel in x direction */ + for (y = height; y; y--) + { + for (x = width; x; x--) #ifdef HAVE_SIGNED_SHIFT - *mcblock++ = (*rblock++ + *rxblock++) >> 1; + *mcblock++ = (*rblock++ + *rxblock++) >> 1; #else /* not HAVE_SIGNED_SHIFT */ - *mcblock++ = (*rblock++ + *rxblock++) / 2; + *mcblock++ = (*rblock++ + *rxblock++) / 2; #endif /* not HAVE_SIGNED_SHIFT */ - rblock += offset; - rxblock += offset; - } - else /* Halfpixel in xy direction */ - for (y = height; y; y--) - { - for (x = width; x; x--) + rblock += offset; + rxblock += offset; + } + else /* Halfpixel in xy direction */ + for (y = height; y; y--) + { + for (x = width; x; x--) #ifdef HAVE_SIGNED_SHIFT - *mcblock++ = (*rblock++ + *rxblock++ - + *ryblock++ + *rxyblock++) >> 2; + *mcblock++ = (*rblock++ + *rxblock++ + + *ryblock++ + *rxyblock++) >> 2; #else /* not HAVE_SIGNED_SHIFT */ - *mcblock++ = (*rblock++ + *rxblock++ - + *ryblock++ + *rxyblock++) / 4; + *mcblock++ = (*rblock++ + *rxblock++ + + *ryblock++ + *rxyblock++) / 4; #endif /* not HAVE_SIGNED_SHIFT */ - rblock += offset; - ryblock += offset; - rxblock += offset; - rxyblock += offset; - } + rblock += offset; + ryblock += offset; + rxblock += offset; + rxyblock += offset; + } } } } diff --git a/converter/other/fiasco/codec/motion.h b/converter/other/fiasco/codec/motion.h index 82d1f1ec..f913c65d 100644 --- a/converter/other/fiasco/codec/motion.h +++ b/converter/other/fiasco/codec/motion.h @@ -1,9 +1,9 @@ /* * motion.h * - * Written by: Ullrich Hafner - * Michael Unger - * + * Written by: Ullrich Hafner + * Michael Unger + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -24,12 +24,12 @@ void restore_mc (int enlarge_factor, image_t *image, const image_t *past, - const image_t *future, const wfa_t *wfa); + const image_t *future, const wfa_t *wfa); void extract_mc_block (word_t *mcblock, unsigned width, unsigned height, - const word_t *reference, unsigned ref_width, - bool_t half_pixel, unsigned xo, unsigned yo, - unsigned mx, unsigned my); + const word_t *reference, unsigned ref_width, + bool_t half_pixel, unsigned xo, unsigned yo, + unsigned mx, unsigned my); #endif /* not _MOTION_H */ diff --git a/converter/other/fiasco/codec/mwfa.c b/converter/other/fiasco/codec/mwfa.c index 0be08a4f..f83f2d00 100644 --- a/converter/other/fiasco/codec/mwfa.c +++ b/converter/other/fiasco/codec/mwfa.c @@ -1,9 +1,9 @@ /* - * mwfa.c: Initialization of MWFA coder + * mwfa.c: Initialization of MWFA coder + * + * Written by: Michael Unger + * Ullrich Hafner * - * Written by: Michael Unger - * Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -38,33 +38,33 @@ static const unsigned local_range = 6; /***************************************************************************** - prototypes - + prototypes + *****************************************************************************/ static void get_mcpe (word_t *mcpe, const image_t *original, - unsigned x0, unsigned y0, unsigned width, unsigned height, - const word_t *mcblock1, const word_t *mcblock2); + unsigned x0, unsigned y0, unsigned width, unsigned height, + const word_t *mcblock1, const word_t *mcblock2); static real_t mcpe_norm (const image_t *original, unsigned x0, unsigned y0, unsigned width, - unsigned height, const word_t *mcblock1, const word_t *mcblock2); -static real_t + unsigned height, const word_t *mcblock1, const word_t *mcblock2); +static real_t find_best_mv (real_t price, const image_t *original, const image_t *reference, - unsigned x0, unsigned y0, unsigned width, unsigned height, - real_t *bits, int *mx, int *my, const real_t *mc_norms, - const wfa_info_t *wi, const motion_t *mt); + unsigned x0, unsigned y0, unsigned width, unsigned height, + real_t *bits, int *mx, int *my, const real_t *mc_norms, + const wfa_info_t *wi, const motion_t *mt); static real_t find_second_mv (real_t price, const image_t *original, - const image_t *reference, const word_t *mcblock1, - unsigned xr, unsigned yr, unsigned width, unsigned height, - real_t *bits, int *mx, int *my, const wfa_info_t *wi, - const motion_t *mt); + const image_t *reference, const word_t *mcblock1, + unsigned xr, unsigned yr, unsigned width, unsigned height, + real_t *bits, int *mx, int *my, const wfa_info_t *wi, + const motion_t *mt); /***************************************************************************** - public code - + public code + *****************************************************************************/ motion_t * @@ -75,32 +75,32 @@ alloc_motion (const wfa_info_t *wi) * fill in default values specified by 'wi'. * * Return value: - * pointer to the new option structure or NULL on error + * pointer to the new option structure or NULL on error */ { - int dx; /* motion vector coordinate */ + int dx; /* motion vector coordinate */ unsigned level; unsigned range_size = wi->half_pixel - ? square (wi->search_range) - : square (2 * wi->search_range); + ? square (wi->search_range) + : square (2 * wi->search_range); motion_t *mt = Calloc (1, sizeof (motion_t)); - + mt->original = NULL; mt->past = NULL; mt->future = NULL; - mt->xbits = Calloc (2 * wi->search_range, sizeof (real_t)); - mt->ybits = Calloc (2 * wi->search_range, sizeof (real_t)); + mt->xbits = Calloc (2 * wi->search_range, sizeof (real_t)); + mt->ybits = Calloc (2 * wi->search_range, sizeof (real_t)); for (dx = -wi->search_range; dx < (int) wi->search_range; dx++) { mt->xbits [dx + wi->search_range] - = mt->ybits [dx + wi->search_range] - = mv_code_table [dx + wi->search_range][1]; + = mt->ybits [dx + wi->search_range] + = mv_code_table [dx + wi->search_range][1]; } - + mt->mc_forward_norms = Calloc (MAXLEVEL, sizeof (real_t *)); mt->mc_backward_norms = Calloc (MAXLEVEL, sizeof (real_t *)); - + for (level = wi->p_min_level; level <= wi->p_max_level; level++) { mt->mc_forward_norms [level] = Calloc (range_size, sizeof (real_t)); @@ -119,7 +119,7 @@ free_motion (motion_t *mt) * No return value. * * Side effects: - * structure 'motion' is discarded. + * structure 'motion' is discarded. */ { unsigned level; @@ -129,9 +129,9 @@ free_motion (motion_t *mt) for (level = 0; level < MAXLEVEL; level++) { if (mt->mc_forward_norms [level]) - Free (mt->mc_forward_norms [level]); + Free (mt->mc_forward_norms [level]); if (mt->mc_backward_norms [level]) - Free (mt->mc_backward_norms [level]); + Free (mt->mc_backward_norms [level]); } Free (mt->mc_forward_norms); Free (mt->mc_backward_norms); @@ -140,7 +140,7 @@ free_motion (motion_t *mt) void subtract_mc (image_t *image, const image_t *past, const image_t *future, - const wfa_t *wfa) + const wfa_t *wfa) /* * Subtract motion compensation from chrom channels of 'image'. * Reference frames are given by 'past' and 'future'. @@ -150,135 +150,135 @@ subtract_mc (image_t *image, const image_t *past, const image_t *future, { unsigned state, label; word_t *mcblock1 = Calloc (size_of_level (wfa->wfainfo->p_max_level), - sizeof (word_t)); + sizeof (word_t)); word_t *mcblock2 = Calloc (size_of_level (wfa->wfainfo->p_max_level), - sizeof (word_t)); + sizeof (word_t)); for (state = wfa->basis_states; state < wfa->states; state++) for (label = 0; label < MAXLABELS; label++) - if (wfa->mv_tree [state][label].type != NONE) - { - color_e band; /* current color band */ - unsigned width, height; /* size of mcblock */ - unsigned offset; /* remaining pixels in original */ - - width = width_of_level (wfa->level_of_state [state] - 1); - height = height_of_level (wfa->level_of_state [state] - 1); - offset = image->width - width; - - switch (wfa->mv_tree [state][label].type) - { - case FORWARD: - for (band = first_band (image->color) + 1; - band <= last_band (image->color); band++) - { - unsigned y; /* row of block */ - word_t *mc1; /* pixel in MC block 1 */ - word_t *orig; /* pixel in original image */ - - extract_mc_block (mcblock1, width, height, - past->pixels [band], past->width, - wfa->wfainfo->half_pixel, - wfa->x [state][label], - wfa->y [state][label], - (wfa->mv_tree [state][label].fx / 2) - * 2, - (wfa->mv_tree [state][label].fy / 2) - * 2); - mc1 = mcblock1; - orig = image->pixels [band] + wfa->x [state][label] - + wfa->y [state][label] * image->width; - - for (y = height; y; y--) - { - unsigned x; /* column of block */ - - for (x = width; x; x--) - *orig++ -= *mc1++; - - orig += offset; - } - } - break; - case BACKWARD: - for (band = first_band (image->color) + 1; - band <= last_band (image->color); band++) - { - unsigned y; /* row of block */ - word_t *mc1; /* pixel in MC block 1 */ - word_t *orig; /* pixel in original image */ - - extract_mc_block (mcblock1, width, height, - future->pixels [band], future->width, - wfa->wfainfo->half_pixel, - wfa->x [state][label], - wfa->y [state][label], - (wfa->mv_tree [state][label].bx / 2) - * 2, - (wfa->mv_tree [state][label].by / 2) - * 2); - mc1 = mcblock1; - orig = image->pixels [band] + wfa->x [state][label] - + wfa->y [state][label] * image->width; - - for (y = height; y; y--) - { - unsigned x; /* column of block */ - - for (x = width; x; x--) - *orig++ -= *mc1++; - - orig += offset; - } - } - break; - case INTERPOLATED: - for (band = first_band (image->color) + 1; - band <= last_band (image->color); band++) - { - unsigned y; /* row of block */ - word_t *mc1; /* pixel in MC block 1 */ - word_t *mc2; /* pixel in MC block 2 */ - word_t *orig; /* pixel in original image */ - - extract_mc_block (mcblock1, width, height, - past->pixels [band], past->width, - wfa->wfainfo->half_pixel, - wfa->x [state][label], - wfa->y [state][label], - (wfa->mv_tree[state][label].fx / 2) - * 2, - (wfa->mv_tree[state][label].fy / 2) - * 2); - extract_mc_block (mcblock2, width, height, - future->pixels [band], future->width, - wfa->wfainfo->half_pixel, - wfa->x [state][label], - wfa->y [state][label], - (wfa->mv_tree[state][label].bx / 2) - * 2, - (wfa->mv_tree[state][label].by / 2) - * 2); - mc1 = mcblock1; - mc2 = mcblock2; - orig = image->pixels [band] + wfa->x [state][label] - + wfa->y [state][label] * image->width; - - for (y = height; y; y--) - { - unsigned x; /* column of block */ - - for (x = width; x; x--) - *orig++ -= (*mc1++ + *mc2++) / 2; - - orig += offset; - } - } - break; - default: - break; - } - } + if (wfa->mv_tree [state][label].type != NONE) + { + color_e band; /* current color band */ + unsigned width, height; /* size of mcblock */ + unsigned offset; /* remaining pixels in original */ + + width = width_of_level (wfa->level_of_state [state] - 1); + height = height_of_level (wfa->level_of_state [state] - 1); + offset = image->width - width; + + switch (wfa->mv_tree [state][label].type) + { + case FORWARD: + for (band = first_band (image->color) + 1; + band <= last_band (image->color); band++) + { + unsigned y; /* row of block */ + word_t *mc1; /* pixel in MC block 1 */ + word_t *orig; /* pixel in original image */ + + extract_mc_block (mcblock1, width, height, + past->pixels [band], past->width, + wfa->wfainfo->half_pixel, + wfa->x [state][label], + wfa->y [state][label], + (wfa->mv_tree [state][label].fx / 2) + * 2, + (wfa->mv_tree [state][label].fy / 2) + * 2); + mc1 = mcblock1; + orig = image->pixels [band] + wfa->x [state][label] + + wfa->y [state][label] * image->width; + + for (y = height; y; y--) + { + unsigned x; /* column of block */ + + for (x = width; x; x--) + *orig++ -= *mc1++; + + orig += offset; + } + } + break; + case BACKWARD: + for (band = first_band (image->color) + 1; + band <= last_band (image->color); band++) + { + unsigned y; /* row of block */ + word_t *mc1; /* pixel in MC block 1 */ + word_t *orig; /* pixel in original image */ + + extract_mc_block (mcblock1, width, height, + future->pixels [band], future->width, + wfa->wfainfo->half_pixel, + wfa->x [state][label], + wfa->y [state][label], + (wfa->mv_tree [state][label].bx / 2) + * 2, + (wfa->mv_tree [state][label].by / 2) + * 2); + mc1 = mcblock1; + orig = image->pixels [band] + wfa->x [state][label] + + wfa->y [state][label] * image->width; + + for (y = height; y; y--) + { + unsigned x; /* column of block */ + + for (x = width; x; x--) + *orig++ -= *mc1++; + + orig += offset; + } + } + break; + case INTERPOLATED: + for (band = first_band (image->color) + 1; + band <= last_band (image->color); band++) + { + unsigned y; /* row of block */ + word_t *mc1; /* pixel in MC block 1 */ + word_t *mc2; /* pixel in MC block 2 */ + word_t *orig; /* pixel in original image */ + + extract_mc_block (mcblock1, width, height, + past->pixels [band], past->width, + wfa->wfainfo->half_pixel, + wfa->x [state][label], + wfa->y [state][label], + (wfa->mv_tree[state][label].fx / 2) + * 2, + (wfa->mv_tree[state][label].fy / 2) + * 2); + extract_mc_block (mcblock2, width, height, + future->pixels [band], future->width, + wfa->wfainfo->half_pixel, + wfa->x [state][label], + wfa->y [state][label], + (wfa->mv_tree[state][label].bx / 2) + * 2, + (wfa->mv_tree[state][label].by / 2) + * 2); + mc1 = mcblock1; + mc2 = mcblock2; + orig = image->pixels [band] + wfa->x [state][label] + + wfa->y [state][label] * image->width; + + for (y = height; y; y--) + { + unsigned x; /* column of block */ + + for (x = width; x; x--) + *orig++ -= (*mc1++ + *mc2++) / 2; + + orig += offset; + } + } + break; + default: + break; + } + } Free (mcblock1); Free (mcblock2); @@ -286,7 +286,7 @@ subtract_mc (image_t *image, const image_t *past, const image_t *future, void find_P_frame_mc (word_t *mcpe, real_t price, range_t *range, - const wfa_info_t *wi, const motion_t *mt) + const wfa_info_t *wi, const motion_t *mt) /* * Determine best motion vector for P-frame. * @@ -301,7 +301,7 @@ find_P_frame_mc (word_t *mcpe, real_t price, range_t *range, unsigned width = width_of_level (range->level); unsigned height = height_of_level (range->level); word_t *mcblock = Calloc (width * height, sizeof (word_t)); - + range->mv_tree_bits = 1; range->mv.type = FORWARD; @@ -309,24 +309,24 @@ find_P_frame_mc (word_t *mcpe, real_t price, range_t *range, * Find best matching forward prediction */ find_best_mv (price, mt->original, mt->past, range->x, range->y, - width, height, &range->mv_coord_bits, &range->mv.fx, - &range->mv.fy, mt->mc_forward_norms [range->level], wi, mt); + width, height, &range->mv_coord_bits, &range->mv.fx, + &range->mv.fy, mt->mc_forward_norms [range->level], wi, mt); /* * Compute MCPE */ extract_mc_block (mcblock, width, height, mt->past->pixels [GRAY], - mt->past->width, wi->half_pixel, range->x, range->y, - range->mv.fx, range->mv.fy); + mt->past->width, wi->half_pixel, range->x, range->y, + range->mv.fx, range->mv.fy); get_mcpe (mcpe, mt->original, range->x, range->y, width, height, - mcblock, NULL); + mcblock, NULL); Free (mcblock); } void find_B_frame_mc (word_t *mcpe, real_t price, range_t *range, - const wfa_info_t *wi, const motion_t *mt) + const wfa_info_t *wi, const motion_t *mt) /* * Determines best motion compensation for B-frame. * Steps: @@ -338,104 +338,104 @@ find_B_frame_mc (word_t *mcpe, real_t price, range_t *range, * FORWARD 000 * BACKWARD 001 * INTERPOLATED 01 - * + * * Return values: * range->mvt_bits (# of mv-tree bits) * range->mvxybits (# of bits for vector components) * mt->mcpe (MCPE in scan-order) */ { - mc_type_e mctype; /* type of motion compensation */ - real_t forward_costs; /* costs of FORWARD mc */ - real_t backward_costs; /* costs of BACKWARD mc */ - real_t interp_costs; /* costs of INTERPOLATED mc */ - real_t forward_bits; /* bits for FORWARD mc */ - real_t backward_bits; /* bits for BACKWARD mc */ - real_t interp_bits; /* bits for INTERPOLATED mc */ - int fx, fy; /* coordinates FORWARD mc */ - int bx, by; /* coordinates BACKWARD mc */ - int ifx, ify; /* coordinates forw. INTERPOLATED mc */ - int ibx, iby; /* coordinates back. INTERPOLATED mc */ + mc_type_e mctype; /* type of motion compensation */ + real_t forward_costs; /* costs of FORWARD mc */ + real_t backward_costs; /* costs of BACKWARD mc */ + real_t interp_costs; /* costs of INTERPOLATED mc */ + real_t forward_bits; /* bits for FORWARD mc */ + real_t backward_bits; /* bits for BACKWARD mc */ + real_t interp_bits; /* bits for INTERPOLATED mc */ + int fx, fy; /* coordinates FORWARD mc */ + int bx, by; /* coordinates BACKWARD mc */ + int ifx, ify; /* coordinates forw. INTERPOLATED mc */ + int ibx, iby; /* coordinates back. INTERPOLATED mc */ unsigned width = width_of_level (range->level); unsigned height = height_of_level (range->level); word_t *mcblock1 = Calloc (width * height, sizeof (word_t)); word_t *mcblock2 = Calloc (width * height, sizeof (word_t)); - + /* * Forward interpolation: use past frame as reference */ forward_costs = find_best_mv (price, mt->original, mt->past, - range->x, range->y, width, height, - &forward_bits, &fx, &fy, - mt->mc_forward_norms [range->level], wi, mt) - + 3 * price; /* code 000 */ + range->x, range->y, width, height, + &forward_bits, &fx, &fy, + mt->mc_forward_norms [range->level], wi, mt) + + 3 * price; /* code 000 */ /* * Backward interpolation: use future frame as reference */ backward_costs = find_best_mv (price, mt->original, mt->future, - range->x, range->y, width, height, - &backward_bits, &bx, &by, - mt->mc_backward_norms [range->level], wi, mt) - + 3 * price; /* code 001 */ + range->x, range->y, width, height, + &backward_bits, &bx, &by, + mt->mc_backward_norms [range->level], wi, mt) + + 3 * price; /* code 001 */ /* * Bidirectional interpolation: use both past and future frame as reference */ - if (wi->cross_B_search) + if (wi->cross_B_search) { - real_t icosts1; /* costs interpolation alternative 1 */ - real_t icosts2; /* costs interpolation alternative 2 */ - real_t ibackward_bits; /* additional bits alternative 1 */ - real_t iforward_bits; /* additional bits alternative 1 */ - + real_t icosts1; /* costs interpolation alternative 1 */ + real_t icosts2; /* costs interpolation alternative 2 */ + real_t ibackward_bits; /* additional bits alternative 1 */ + real_t iforward_bits; /* additional bits alternative 1 */ + /* * Alternative 1: keep forward mv and vary backward mv locally */ extract_mc_block (mcblock1, width, height, mt->past->pixels [GRAY], - mt->past->width, wi->half_pixel, - range->x, range->y, fx, fy); + mt->past->width, wi->half_pixel, + range->x, range->y, fx, fy); - ibx = bx; /* start with backward coordinates */ + ibx = bx; /* start with backward coordinates */ iby = by; icosts1 = find_second_mv (price, mt->original, mt->future, - mcblock1, range->x, range->y, width, height, - &ibackward_bits, &ibx, &iby, wi, mt) - + (forward_bits + 2) * price; /* code 01 */ + mcblock1, range->x, range->y, width, height, + &ibackward_bits, &ibx, &iby, wi, mt) + + (forward_bits + 2) * price; /* code 01 */ /* * Alternative 2: Keep backward mv and vary forward mv locally */ extract_mc_block (mcblock1, width, height, mt->future->pixels [GRAY], - mt->future->width, wi->half_pixel, - range->x, range->y, bx, by); + mt->future->width, wi->half_pixel, + range->x, range->y, bx, by); ifx = fx; ify = fy; icosts2 = find_second_mv (price, mt->original, mt->past, - mcblock1, range->x, range->y, width, height, - &iforward_bits, &ifx, &ify, wi, mt) - + (backward_bits + 2) * price; /* code 01 */ - + mcblock1, range->x, range->y, width, height, + &iforward_bits, &ifx, &ify, wi, mt) + + (backward_bits + 2) * price; /* code 01 */ + /* * Choose best alternative */ if (icosts1 < icosts2) { - ifx = fx; - ify = fy; - interp_bits = forward_bits + ibackward_bits; - interp_costs = icosts1; + ifx = fx; + ify = fy; + interp_bits = forward_bits + ibackward_bits; + interp_costs = icosts1; } else { - ibx = bx; - iby = by; - interp_bits = iforward_bits + backward_bits; - interp_costs = icosts2; + ibx = bx; + iby = by; + interp_bits = iforward_bits + backward_bits; + interp_costs = icosts2; } } - else /* local exhaustive search */ + else /* local exhaustive search */ { /* * Keep forward and backward mv because of time constraints @@ -448,14 +448,14 @@ find_B_frame_mc (word_t *mcpe, real_t price, range_t *range, interp_bits = forward_bits + backward_bits; extract_mc_block (mcblock1, width, height, mt->past->pixels [GRAY], - mt->past->width, wi->half_pixel, - range->x, range->y, fx, fy); + mt->past->width, wi->half_pixel, + range->x, range->y, fx, fy); extract_mc_block (mcblock2, width, height, mt->future->pixels [GRAY], - mt->future->width, wi->half_pixel, - range->x, range->y, bx, by); + mt->future->width, wi->half_pixel, + range->x, range->y, bx, by); interp_costs = mcpe_norm (mt->original, range->x, range->y, - width, height, mcblock1, mcblock2) - + (interp_bits + 2) * price; /* code 01 */ + width, height, mcblock1, mcblock2) + + (interp_bits + 2) * price; /* code 01 */ } /* @@ -464,63 +464,63 @@ find_B_frame_mc (word_t *mcpe, real_t price, range_t *range, if (forward_costs <= interp_costs) { if (forward_costs <= backward_costs) - mctype = FORWARD; + mctype = FORWARD; else - mctype = BACKWARD; + mctype = BACKWARD; } else { if (backward_costs <= interp_costs) - mctype = BACKWARD; + mctype = BACKWARD; else - mctype = INTERPOLATED; + mctype = INTERPOLATED; } switch (mctype) { case FORWARD: - range->mv_tree_bits = 3; - range->mv_coord_bits = forward_bits; - range->mv.type = FORWARD; - range->mv.fx = fx; - range->mv.fy = fy; - extract_mc_block (mcblock1, width, height, mt->past->pixels [GRAY], - mt->past->width, wi->half_pixel, - range->x, range->y, range->mv.fx, range->mv.fy); - get_mcpe (mcpe, mt->original, range->x, range->y, width, height, - mcblock1, NULL); - break; + range->mv_tree_bits = 3; + range->mv_coord_bits = forward_bits; + range->mv.type = FORWARD; + range->mv.fx = fx; + range->mv.fy = fy; + extract_mc_block (mcblock1, width, height, mt->past->pixels [GRAY], + mt->past->width, wi->half_pixel, + range->x, range->y, range->mv.fx, range->mv.fy); + get_mcpe (mcpe, mt->original, range->x, range->y, width, height, + mcblock1, NULL); + break; case BACKWARD: - range->mv_tree_bits = 3; - range->mv_coord_bits = backward_bits; - range->mv.type = BACKWARD; - range->mv.bx = bx; - range->mv.by = by; - extract_mc_block (mcblock1, width, height, mt->future->pixels [GRAY], - mt->future->width, wi->half_pixel, - range->x, range->y, range->mv.bx, range->mv.by); - get_mcpe (mcpe, mt->original, range->x, range->y, width, height, - mcblock1, NULL); - break; + range->mv_tree_bits = 3; + range->mv_coord_bits = backward_bits; + range->mv.type = BACKWARD; + range->mv.bx = bx; + range->mv.by = by; + extract_mc_block (mcblock1, width, height, mt->future->pixels [GRAY], + mt->future->width, wi->half_pixel, + range->x, range->y, range->mv.bx, range->mv.by); + get_mcpe (mcpe, mt->original, range->x, range->y, width, height, + mcblock1, NULL); + break; case INTERPOLATED: - range->mv_tree_bits = 2; - range->mv_coord_bits = interp_bits; - range->mv.type = INTERPOLATED; - range->mv.fx = ifx; - range->mv.fy = ify; - range->mv.bx = ibx; - range->mv.by = iby; - extract_mc_block (mcblock1, width, height, mt->past->pixels [GRAY], - mt->past->width, wi->half_pixel, - range->x, range->y, range->mv.fx, range->mv.fy); - extract_mc_block (mcblock2, width, height, mt->future->pixels [GRAY], - mt->future->width, wi->half_pixel, - range->x, range->y, range->mv.bx, range->mv.by); - get_mcpe (mcpe, mt->original, range->x, range->y, width, height, - mcblock1, mcblock2); - break; + range->mv_tree_bits = 2; + range->mv_coord_bits = interp_bits; + range->mv.type = INTERPOLATED; + range->mv.fx = ifx; + range->mv.fy = ify; + range->mv.bx = ibx; + range->mv.by = iby; + extract_mc_block (mcblock1, width, height, mt->past->pixels [GRAY], + mt->past->width, wi->half_pixel, + range->x, range->y, range->mv.fx, range->mv.fy); + extract_mc_block (mcblock2, width, height, mt->future->pixels [GRAY], + mt->future->width, wi->half_pixel, + range->x, range->y, range->mv.bx, range->mv.by); + get_mcpe (mcpe, mt->original, range->x, range->y, width, height, + mcblock1, mcblock2); + break; default: - break; + break; } Free (mcblock1); @@ -529,7 +529,7 @@ find_B_frame_mc (word_t *mcpe, real_t price, range_t *range, void fill_norms_table (unsigned x0, unsigned y0, unsigned level, - const wfa_info_t *wi, motion_t *mt) + const wfa_info_t *wi, motion_t *mt) /* * Compute norms of difference images for all possible displacements * in 'mc_forward_norm' and 'mc_backward_norm'. @@ -537,50 +537,50 @@ fill_norms_table (unsigned x0, unsigned y0, unsigned level, * No return value. * * Side effects: - * 'mt->mc_backward_norms' are computed - * 'mt->mc_forward_norms' are computed + * 'mt->mc_backward_norms' are computed + * 'mt->mc_forward_norms' are computed */ { - int mx, my; /* coordinates of motion vector */ - unsigned sr; /* mv search range +-'sr' pixels */ - unsigned index = 0; /* index of motion vector */ + int mx, my; /* coordinates of motion vector */ + unsigned sr; /* mv search range +-'sr' pixels */ + unsigned index = 0; /* index of motion vector */ unsigned width = width_of_level (level); unsigned height = height_of_level (level); word_t *mcblock = Calloc (width * height, sizeof (word_t)); sr = wi->half_pixel ? wi->search_range / 2 : wi->search_range; - + for (my = -sr; my < (int) sr; my++) for (mx = -sr; mx < (int) sr; mx++, index++) { - if ((int) x0 + mx < 0 || /* block outside visible area */ - x0 + mx + width > mt->original->width || - (int) y0 + my < 0 || - y0 + my + height > mt->original->height) - { - mt->mc_forward_norms [level][index] = 0.0; - mt->mc_backward_norms [level][index] = 0.0; - } - else - { - extract_mc_block (mcblock, width, height, mt->past->pixels [GRAY], - mt->past->width, wi->half_pixel, - x0, y0, mx, my); - mt->mc_forward_norms [level][index] - = mcpe_norm (mt->original, x0, y0, width, height, - mcblock, NULL); - - if (mt->frame_type == B_FRAME) - { - extract_mc_block (mcblock, width, height, - mt->future->pixels [GRAY], - mt->future->width, wi->half_pixel, - x0, y0, mx, my); - mt->mc_backward_norms[level][index] - = mcpe_norm (mt->original, x0, y0, width, height, - mcblock, NULL); - } - } + if ((int) x0 + mx < 0 || /* block outside visible area */ + x0 + mx + width > mt->original->width || + (int) y0 + my < 0 || + y0 + my + height > mt->original->height) + { + mt->mc_forward_norms [level][index] = 0.0; + mt->mc_backward_norms [level][index] = 0.0; + } + else + { + extract_mc_block (mcblock, width, height, mt->past->pixels [GRAY], + mt->past->width, wi->half_pixel, + x0, y0, mx, my); + mt->mc_forward_norms [level][index] + = mcpe_norm (mt->original, x0, y0, width, height, + mcblock, NULL); + + if (mt->frame_type == B_FRAME) + { + extract_mc_block (mcblock, width, height, + mt->future->pixels [GRAY], + mt->future->width, wi->half_pixel, + x0, y0, mx, my); + mt->mc_backward_norms[level][index] + = mcpe_norm (mt->original, x0, y0, width, height, + mcblock, NULL); + } + } } Free (mcblock); @@ -588,14 +588,14 @@ fill_norms_table (unsigned x0, unsigned y0, unsigned level, /***************************************************************************** - private code - + private code + *****************************************************************************/ static void get_mcpe (word_t *mcpe, const image_t *original, unsigned x0, unsigned y0, - unsigned width, unsigned height, const word_t *mcblock1, - const word_t *mcblock2) + unsigned width, unsigned height, const word_t *mcblock1, + const word_t *mcblock2) /* * Compute MCPE image 'original' - reference. The reference is either * composed of 'mcblock1' or of ('mcblock1' + 'mcblock2') / 2 (if @@ -605,44 +605,44 @@ get_mcpe (word_t *mcpe, const image_t *original, unsigned x0, unsigned y0, * No return value. * * Side effects: - * 'mcpe []' is filled with the delta image + * 'mcpe []' is filled with the delta image */ { - const word_t *oblock; /* pointer to original image */ + const word_t *oblock; /* pointer to original image */ assert (mcpe); - + oblock = original->pixels [GRAY] + y0 * original->width + x0; - if (mcblock2 != NULL) /* interpolated prediction */ + if (mcblock2 != NULL) /* interpolated prediction */ { - unsigned x, y; /* current coordinates */ - - for (y = height; y; y--) + unsigned x, y; /* current coordinates */ + + for (y = height; y; y--) { - for (x = width; x; x--) - *mcpe++ = *oblock++ - (*mcblock1++ + *mcblock2++) / 2; + for (x = width; x; x--) + *mcpe++ = *oblock++ - (*mcblock1++ + *mcblock2++) / 2; - oblock += original->width - width; + oblock += original->width - width; } } - else /* forward or backward prediction */ + else /* forward or backward prediction */ { - unsigned x, y; /* current coordinates */ - - for (y = height; y; y--) + unsigned x, y; /* current coordinates */ + + for (y = height; y; y--) { - for (x = width; x; x--) - *mcpe++ = *oblock++ - *mcblock1++; - - oblock += original->width - width; + for (x = width; x; x--) + *mcpe++ = *oblock++ - *mcblock1++; + + oblock += original->width - width; } } } static real_t mcpe_norm (const image_t *original, unsigned x0, unsigned y0, unsigned width, - unsigned height, const word_t *mcblock1, const word_t *mcblock2) + unsigned height, const word_t *mcblock1, const word_t *mcblock2) /* * Compute norm of motion compensation prediction error. * Coordinates of 'original' block are given by ('x0', 'y0') @@ -650,79 +650,79 @@ mcpe_norm (const image_t *original, unsigned x0, unsigned y0, unsigned width, * Reference blocks are stored in 'mcimage1' and 'mcimage2'. * * Return value: - * square of norm of difference image + * square of norm of difference image */ { unsigned n; real_t norm = 0; word_t *mcpe = Calloc (width * height, sizeof (word_t)); word_t *ptr = mcpe; - + get_mcpe (mcpe, original, x0, y0, width, height, mcblock1, mcblock2); - for (n = height * width; n; n--, ptr++) + for (n = height * width; n; n--, ptr++) norm += square (*ptr / 16); - + Free (mcpe); - + return norm; } -static real_t +static real_t find_best_mv (real_t price, const image_t *original, const image_t *reference, - unsigned x0, unsigned y0, unsigned width, unsigned height, - real_t *bits, int *mx, int *my, const real_t *mc_norms, - const wfa_info_t *wi, const motion_t *mt) + unsigned x0, unsigned y0, unsigned width, unsigned height, + real_t *bits, int *mx, int *my, const real_t *mc_norms, + const wfa_info_t *wi, const motion_t *mt) /* * Find best matching motion vector in image 'reference' to predict * the block ('x0', 'y0') of size 'width'x'height in image 'original'. * * Return values: - * prediction costs + * prediction costs * * Side effects: - * 'mx', 'my' coordinates of motion vector - * 'bits' number of bits to encode mv + * 'mx', 'my' coordinates of motion vector + * 'bits' number of bits to encode mv */ { - unsigned sr; /* mv search range +/- 'sr' pixels */ - unsigned index; /* index of motion vector */ - int x, y; /* coordinates of motion vector */ - real_t costs; /* costs arising if mv is chosen */ - real_t mincosts = MAXCOSTS; /* best costs so far */ - unsigned bitshift; /* half_pixel coordinates multiplier */ - + unsigned sr; /* mv search range +/- 'sr' pixels */ + unsigned index; /* index of motion vector */ + int x, y; /* coordinates of motion vector */ + real_t costs; /* costs arising if mv is chosen */ + real_t mincosts = MAXCOSTS; /* best costs so far */ + unsigned bitshift; /* half_pixel coordinates multiplier */ + *mx = *my = 0; /* * Find best fitting motion vector: * Use exhaustive search in the interval x,y +- sr (no halfpixel accuracy) - * or x,y +- sr/2 (halfpixel accuracy) + * or x,y +- sr/2 (halfpixel accuracy) */ - sr = wi->half_pixel ? wi->search_range / 2 : wi->search_range; - bitshift = (wi->half_pixel ? 2 : 1); /* bit0 reserved for halfpixel pred. */ - + sr = wi->half_pixel ? wi->search_range / 2 : wi->search_range; + bitshift = (wi->half_pixel ? 2 : 1); /* bit0 reserved for halfpixel pred. */ + for (index = 0, y = -sr; y < (int) sr; y++) for (x = -sr; x < (int) sr; x++, index++) - if ((int) x0 + x >= 0 && (int) y0 + y >= 0 && - x0 + x + width <= original->width && - y0 + y + height <= original->height) - { - /* - * Block is inside visible area. - * Compare current costs with 'mincosts' - */ - costs = mc_norms [index] - + (mt->xbits [(x + sr) * bitshift] - + mt->ybits [(y + sr) * bitshift]) * price; - - if (costs < mincosts) - { - mincosts = costs; - *mx = x * bitshift; - *my = y * bitshift; - } - } + if ((int) x0 + x >= 0 && (int) y0 + y >= 0 && + x0 + x + width <= original->width && + y0 + y + height <= original->height) + { + /* + * Block is inside visible area. + * Compare current costs with 'mincosts' + */ + costs = mc_norms [index] + + (mt->xbits [(x + sr) * bitshift] + + mt->ybits [(y + sr) * bitshift]) * price; + + if (costs < mincosts) + { + mincosts = costs; + *mx = x * bitshift; + *my = y * bitshift; + } + } /* * Halfpixel prediction: @@ -730,53 +730,53 @@ find_best_mv (real_t price, const image_t *original, const image_t *reference, */ if (wi->half_pixel) { - int rx, ry; /* halfpixel refinement */ - unsigned bestrx, bestry; /* coordinates of best mv */ + int rx, ry; /* halfpixel refinement */ + unsigned bestrx, bestry; /* coordinates of best mv */ word_t *mcblock = Calloc (width * height, sizeof (word_t)); - + bestrx = bestry = 0; for (rx = -1; rx <= 1; rx++) - for (ry = -1; ry <= 1; ry++) - { - /* - * Check if the new motion vector is in allowed area - */ - if (rx == 0 && ry == 0) /* already tested */ - continue; - if ((int) x0 + (*mx / 2) + rx < 0 || /* outside visible area */ - x0 + (*mx / 2) + rx + width > original->width || - (int) y0 + (*my / 2) + ry < 0 || - y0 + (*my / 2) + ry + height > original->height) - continue; - if (*mx + rx < (int) -sr || *mx + rx >= (int) sr || - *my + ry < (int) -sr || *my + ry >= (int) sr) - continue; /* out of bounds */ - - /* - * Compute costs of new motion compensation - */ - extract_mc_block (mcblock, width, height, - reference->pixels [GRAY], - reference->width, wi->half_pixel, - x0, y0, *mx + rx, *my + ry); - costs = mcpe_norm (mt->original, x0, y0, width, height, mcblock, - NULL) - + (mt->xbits [*mx + rx + sr * bitshift] - + mt->ybits [*my + ry + sr * bitshift]) * price; - if (costs < mincosts) - { - bestrx = rx; - bestry = ry; - mincosts = costs; - } - } + for (ry = -1; ry <= 1; ry++) + { + /* + * Check if the new motion vector is in allowed area + */ + if (rx == 0 && ry == 0) /* already tested */ + continue; + if ((int) x0 + (*mx / 2) + rx < 0 || /* outside visible area */ + x0 + (*mx / 2) + rx + width > original->width || + (int) y0 + (*my / 2) + ry < 0 || + y0 + (*my / 2) + ry + height > original->height) + continue; + if (*mx + rx < (int) -sr || *mx + rx >= (int) sr || + *my + ry < (int) -sr || *my + ry >= (int) sr) + continue; /* out of bounds */ + + /* + * Compute costs of new motion compensation + */ + extract_mc_block (mcblock, width, height, + reference->pixels [GRAY], + reference->width, wi->half_pixel, + x0, y0, *mx + rx, *my + ry); + costs = mcpe_norm (mt->original, x0, y0, width, height, mcblock, + NULL) + + (mt->xbits [*mx + rx + sr * bitshift] + + mt->ybits [*my + ry + sr * bitshift]) * price; + if (costs < mincosts) + { + bestrx = rx; + bestry = ry; + mincosts = costs; + } + } *mx += bestrx; *my += bestry; Free (mcblock); } /* halfpixel */ - + *bits = mt->xbits [*mx + sr * bitshift] + mt->ybits [*my + sr * bitshift]; return mincosts; @@ -784,28 +784,28 @@ find_best_mv (real_t price, const image_t *original, const image_t *reference, static real_t find_second_mv (real_t price, const image_t *original, - const image_t *reference, const word_t *mcblock1, - unsigned xr, unsigned yr, unsigned width, unsigned height, - real_t *bits, int *mx, int *my, const wfa_info_t *wi, - const motion_t *mt) + const image_t *reference, const word_t *mcblock1, + unsigned xr, unsigned yr, unsigned width, unsigned height, + real_t *bits, int *mx, int *my, const wfa_info_t *wi, + const motion_t *mt) /* * Search local area (*mx,*my) for best additional mv. * Overwrite mt->tmpblock. * TODO check sr = search_range * * Return values: - * prediction costs + * prediction costs * * Side effects: - * 'mx','my' coordinates of mv - * 'bits' number of bits to encode mv + * 'mx','my' coordinates of mv + * 'bits' number of bits to encode mv */ { - real_t mincosts = MAXCOSTS; /* best costs so far */ - unsigned sr; /* MV search range +/- 'sr' pixels */ - int x, y; /* coordinates of motion vector */ - int y0, y1, x0, x1; /* start/end coord. of search range */ - unsigned bitshift; /* half_pixel coordinates multiplier */ + real_t mincosts = MAXCOSTS; /* best costs so far */ + unsigned sr; /* MV search range +/- 'sr' pixels */ + int x, y; /* coordinates of motion vector */ + int y0, y1, x0, x1; /* start/end coord. of search range */ + unsigned bitshift; /* half_pixel coordinates multiplier */ word_t *mcblock2 = Calloc (width * height, sizeof (word_t)); sr = wi->search_range; @@ -817,40 +817,40 @@ find_second_mv (real_t price, const image_t *original, *mx = *my = 0; - bitshift = (wi->half_pixel ? 2 : 1); /* bit0 reserved for halfpixel pred. */ + bitshift = (wi->half_pixel ? 2 : 1); /* bit0 reserved for halfpixel pred. */ + - for (y = y0; y < y1; y++) for (x = x0; x < x1; x++) { - real_t costs; /* costs arising if mv is chosen */ - - /* - * Test each mv ('x', 'y') in the given search range: - * Get the new motion compensation image from 'reference' and compute - * the norm of the motion compensation prediction error - * 'original' - 0.5 * ('firstmc' + 'reference') - */ - if ((int) (xr * bitshift) + x < 0 || /* outside visible area */ - xr * bitshift + x > (original->width - width) * bitshift || - (int) (yr * bitshift) + y < 0 || - yr * bitshift + y > (original->height - height) * bitshift) - continue; - - extract_mc_block (mcblock2, width, height, - reference->pixels [GRAY], reference->width, - wi->half_pixel, x0, y0, x, y); - - costs = mcpe_norm (mt->original, x0, y0, width, height, - mcblock1, mcblock2) - + (mt->xbits [x + sr] + mt->ybits [y + sr]) * price; - - if (costs < mincosts) - { - mincosts = costs; - *mx = x; - *my = y; - } + real_t costs; /* costs arising if mv is chosen */ + + /* + * Test each mv ('x', 'y') in the given search range: + * Get the new motion compensation image from 'reference' and compute + * the norm of the motion compensation prediction error + * 'original' - 0.5 * ('firstmc' + 'reference') + */ + if ((int) (xr * bitshift) + x < 0 || /* outside visible area */ + xr * bitshift + x > (original->width - width) * bitshift || + (int) (yr * bitshift) + y < 0 || + yr * bitshift + y > (original->height - height) * bitshift) + continue; + + extract_mc_block (mcblock2, width, height, + reference->pixels [GRAY], reference->width, + wi->half_pixel, x0, y0, x, y); + + costs = mcpe_norm (mt->original, x0, y0, width, height, + mcblock1, mcblock2) + + (mt->xbits [x + sr] + mt->ybits [y + sr]) * price; + + if (costs < mincosts) + { + mincosts = costs; + *mx = x; + *my = y; + } } *bits = mt->xbits [*mx + sr] + mt->ybits [*my + sr]; diff --git a/converter/other/fiasco/codec/mwfa.h b/converter/other/fiasco/codec/mwfa.h index 2c1e7c9f..1e35eef2 100644 --- a/converter/other/fiasco/codec/mwfa.h +++ b/converter/other/fiasco/codec/mwfa.h @@ -1,9 +1,9 @@ /* * mwfa.h * - * Written by: Michael Unger - * Ullrich Hafner - * + * Written by: Michael Unger + * Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -25,16 +25,16 @@ void fill_norms_table (unsigned x0, unsigned y0, unsigned level, - const wfa_info_t *wi, motion_t *mt); + const wfa_info_t *wi, motion_t *mt); void find_B_frame_mc (word_t *mcpe, real_t price, range_t *range, - const wfa_info_t *wi, const motion_t *mt); + const wfa_info_t *wi, const motion_t *mt); void find_P_frame_mc (word_t *mcpe, real_t price, range_t *range, - const wfa_info_t *wi, const motion_t *mt); + const wfa_info_t *wi, const motion_t *mt); void subtract_mc (image_t *image, const image_t *past, const image_t *future, - const wfa_t *wfa); + const wfa_t *wfa); void free_motion (motion_t *mt); motion_t * diff --git a/converter/other/fiasco/codec/options.c b/converter/other/fiasco/codec/options.c index b9c64efd..8029a48e 100644 --- a/converter/other/fiasco/codec/options.c +++ b/converter/other/fiasco/codec/options.c @@ -1,8 +1,8 @@ /* - * options.c: FIASCO options handling + * options.c: FIASCO options handling + * + * Written by: Ullrich Hafner * - * Written by: Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -44,10 +44,10 @@ fiasco_c_options_new (void) * fill in default values. * * Return value: - * pointer to the new option structure + * pointer to the new option structure */ { - c_options_t *options = calloc (1, sizeof (c_options_t)); + c_options_t *options = calloc (1, sizeof (c_options_t)); fiasco_c_options_t *public = calloc (1, sizeof (fiasco_c_options_t)); if (!options || !public) @@ -55,9 +55,9 @@ fiasco_c_options_new (void) set_error (_("Out of memory.")); return NULL; } - public->private = options; - public->delete = fiasco_c_options_delete; - public->set_tiling = fiasco_c_options_set_tiling; + public->private = options; + public->delete = fiasco_c_options_delete; + public->set_tiling = fiasco_c_options_set_tiling; public->set_frame_pattern = fiasco_c_options_set_frame_pattern; public->set_basisfile = fiasco_c_options_set_basisfile; public->set_chroma_quality = fiasco_c_options_set_chroma_quality; @@ -66,57 +66,57 @@ fiasco_c_options_new (void) public->set_quantization = fiasco_c_options_set_quantization; public->set_progress_meter = fiasco_c_options_set_progress_meter; public->set_smoothing = fiasco_c_options_set_smoothing; - public->set_title = fiasco_c_options_set_title; + public->set_title = fiasco_c_options_set_title; public->set_comment = fiasco_c_options_set_comment; - + strcpy (options->id, "COFIASCO"); /* * Set default value of fiasco options */ - options->basis_name = strdup ("small.fco"); - options->lc_min_level = 4; - options->lc_max_level = 12; - options->p_min_level = 8; - options->p_max_level = 10; - options->images_level = 5; - options->max_states = MAXSTATES; - options->chroma_max_states = 40; - options->max_elements = MAXEDGES; - options->tiling_exponent = 4; - options->tiling_method = FIASCO_TILING_VARIANCE_DSC; - options->id_domain_pool = strdup ("rle"); - options->id_d_domain_pool = strdup ("rle"); - options->id_rpf_model = strdup ("adaptive"); - options->id_d_rpf_model = strdup ("adaptive"); - options->rpf_mantissa = 3; - options->rpf_range = FIASCO_RPF_RANGE_1_50; - options->dc_rpf_mantissa = 5; - options->dc_rpf_range = FIASCO_RPF_RANGE_1_00; - options->d_rpf_mantissa = 3; - options->d_rpf_range = FIASCO_RPF_RANGE_1_50; - options->d_dc_rpf_mantissa = 5; - options->d_dc_rpf_range = FIASCO_RPF_RANGE_1_00; - options->chroma_decrease = 2.0; - options->prediction = NO; - options->delta_domains = YES; - options->normal_domains = YES; - options->search_range = 16; - options->fps = 25; - options->pattern = strdup ("IPPPPPPPPP"); - options->reference_filename = NULL; + options->basis_name = strdup ("small.fco"); + options->lc_min_level = 4; + options->lc_max_level = 12; + options->p_min_level = 8; + options->p_max_level = 10; + options->images_level = 5; + options->max_states = MAXSTATES; + options->chroma_max_states = 40; + options->max_elements = MAXEDGES; + options->tiling_exponent = 4; + options->tiling_method = FIASCO_TILING_VARIANCE_DSC; + options->id_domain_pool = strdup ("rle"); + options->id_d_domain_pool = strdup ("rle"); + options->id_rpf_model = strdup ("adaptive"); + options->id_d_rpf_model = strdup ("adaptive"); + options->rpf_mantissa = 3; + options->rpf_range = FIASCO_RPF_RANGE_1_50; + options->dc_rpf_mantissa = 5; + options->dc_rpf_range = FIASCO_RPF_RANGE_1_00; + options->d_rpf_mantissa = 3; + options->d_rpf_range = FIASCO_RPF_RANGE_1_50; + options->d_dc_rpf_mantissa = 5; + options->d_dc_rpf_range = FIASCO_RPF_RANGE_1_00; + options->chroma_decrease = 2.0; + options->prediction = NO; + options->delta_domains = YES; + options->normal_domains = YES; + options->search_range = 16; + options->fps = 25; + options->pattern = strdup ("IPPPPPPPPP"); + options->reference_filename = NULL; options->half_pixel_prediction = NO; - options->cross_B_search = YES; - options->B_as_past_ref = YES; + options->cross_B_search = YES; + options->B_as_past_ref = YES; options->check_for_underflow = NO; - options->check_for_overflow = NO; + options->check_for_overflow = NO; options->second_domain_block = NO; - options->full_search = NO; - options->progress_meter = FIASCO_PROGRESS_NONE; - options->smoothing = 70; - options->comment = strdup (""); - options->title = strdup (""); - + options->full_search = NO; + options->progress_meter = FIASCO_PROGRESS_NONE; + options->smoothing = 70; + options->comment = strdup (""); + options->title = strdup (""); + return public; } @@ -129,14 +129,14 @@ fiasco_c_options_delete (fiasco_c_options_t *options) * No return value. * * Side effects: - * structure 'options' is discarded. + * structure 'options' is discarded. */ { c_options_t *this = cast_c_options (options); if (!this) return; - + Free (this->id_domain_pool); Free (this->id_d_domain_pool); Free (this->id_rpf_model); @@ -144,7 +144,7 @@ fiasco_c_options_delete (fiasco_c_options_t *options) Free (this->pattern); Free (this->comment); Free (this->title); - + Free (this); return; @@ -152,15 +152,15 @@ fiasco_c_options_delete (fiasco_c_options_t *options) int fiasco_c_options_set_tiling (fiasco_c_options_t *options, - fiasco_tiling_e method, unsigned exponent) + fiasco_tiling_e method, unsigned exponent) /* * Set tiling `method' and `exponent'. * See type `fiasco_tiling_e' for a list of valid tiling `methods'. * The image is subdivied into 2^`exponent' tiles * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise */ { c_options_t *this = (c_options_t *) cast_c_options (options); @@ -175,21 +175,21 @@ fiasco_c_options_set_tiling (fiasco_c_options_t *options, case FIASCO_TILING_SPIRAL_DSC: case FIASCO_TILING_VARIANCE_ASC: case FIASCO_TILING_VARIANCE_DSC: - this->tiling_method = method; - break; + this->tiling_method = method; + break; default: - set_error (_("Invalid tiling method `%d' specified " - "(valid methods are 0, 1, 2, or 3)."), method); - return 0; + set_error (_("Invalid tiling method `%d' specified " + "(valid methods are 0, 1, 2, or 3)."), method); + return 0; } this->tiling_exponent = exponent; - + return 1; } int fiasco_c_options_set_frame_pattern (fiasco_c_options_t *options, - const char *pattern) + const char *pattern) /* * Set `pattern' of input frames. * `pattern' has to be a sequence of the following @@ -201,10 +201,10 @@ fiasco_c_options_set_frame_pattern (fiasco_c_options_t *options, * * When coding video frames the prediction type of input frame N is determined * by reading `pattern' [N] (`pattern' is periodically extended). - * + * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise */ { c_options_t *this = (c_options_t *) cast_c_options (options); @@ -226,49 +226,49 @@ fiasco_c_options_set_frame_pattern (fiasco_c_options_t *options, else { const char *str; - bool_t parse_error = NO; - int c = 0; - + bool_t parse_error = NO; + int c = 0; + for (str = pattern; *str && !parse_error; str++) - switch (*str) - { - case 'i': - case 'I': - case 'b': - case 'B': - case 'p': - case 'P': - break; - default: - c = *str; - parse_error = YES; - } + switch (*str) + { + case 'i': + case 'I': + case 'b': + case 'B': + case 'p': + case 'P': + break; + default: + c = *str; + parse_error = YES; + } if (parse_error) { - set_error (_("Frame type pattern contains invalid character `%c' " - "(choose I, B or P)."), c); - return 0; + set_error (_("Frame type pattern contains invalid character `%c' " + "(choose I, B or P)."), c); + return 0; } else { - Free (this->pattern); - this->pattern = strdup (pattern); + Free (this->pattern); + this->pattern = strdup (pattern); - return 1; + return 1; } } } int fiasco_c_options_set_basisfile (fiasco_c_options_t *options, - const char *filename) + const char *filename) /* * Set `filename' of FIASCO initial basis. - * + * * Return value: - * 1 on success (if the file is readable) - * 0 otherwise + * 1 on success (if the file is readable) + * 0 otherwise */ { c_options_t *this = (c_options_t *) cast_c_options (options); @@ -289,14 +289,14 @@ fiasco_c_options_set_basisfile (fiasco_c_options_t *options, FILE *file = open_file (filename, "FIASCO_DATA", READ_ACCESS); if (file) { - fclose (file); - return 1; + fclose (file); + return 1; } else { - set_error (_("Can't read basis file `%s'.\n%s."), filename, - get_system_error ()); - return 0; + set_error (_("Can't read basis file `%s'.\n%s."), filename, + get_system_error ()); + return 0; } */ return 1; } @@ -304,20 +304,20 @@ fiasco_c_options_set_basisfile (fiasco_c_options_t *options, int fiasco_c_options_set_chroma_quality (fiasco_c_options_t *options, - float quality_factor, - unsigned dictionary_size) + float quality_factor, + unsigned dictionary_size) /* * Set color compression parameters. * When coding chroma channels (Cb and Cr) * - approximation quality is given by `quality_factor' * `Y quality' and * - `dictionary_size' gives the number of dictionary elements. - * + * * If 'quality' <= 0 then the luminancy coding quality is also during * chroma channel coding. - * + * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise */ { c_options_t *this = (c_options_t *) cast_c_options (options); @@ -329,13 +329,13 @@ fiasco_c_options_set_chroma_quality (fiasco_c_options_t *options, else if (!dictionary_size) { set_error (_("Size of chroma compression dictionary has to be " - "a positive number.")); + "a positive number.")); return 0; } else if (quality_factor <= 0) { set_error (_("Quality of chroma channel compression has to be " - "positive value.")); + "positive value.")); return 0; } else @@ -349,32 +349,32 @@ fiasco_c_options_set_chroma_quality (fiasco_c_options_t *options, int fiasco_c_options_set_optimizations (fiasco_c_options_t *options, - unsigned min_block_level, - unsigned max_block_level, - unsigned max_elements, - unsigned dictionary_size, - unsigned optimization_level) + unsigned min_block_level, + unsigned max_block_level, + unsigned max_elements, + unsigned dictionary_size, + unsigned optimization_level) /* * Set various optimization parameters. * - During compression only image blocks of size * {`min_block_level', ... ,`max_block_level'} are considered. * The smaller this set of blocks is the faster the coder runs - * and the worse the image quality will be. + * and the worse the image quality will be. * - An individual approximation may use at most `max_elements' * elements of the dictionary which itself contains at most * `dictionary_size' elements. The smaller these values are - * the faster the coder runs and the worse the image quality will be. + * the faster the coder runs and the worse the image quality will be. * - `optimization_level' enables some additional low level optimizations. * 0: standard approximation method * 1: significantly increases the approximation quality, * running time is twice as high as with the standard method - * 2: hardly increases the approximation quality of method 1, + * 2: hardly increases the approximation quality of method 1, * running time is twice as high as with method 1 * (this method just remains for completeness) * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise */ { c_options_t *this = (c_options_t *) cast_c_options (options); @@ -391,7 +391,7 @@ fiasco_c_options_set_optimizations (fiasco_c_options_t *options, else if (!max_elements) { set_error (_("At least one dictionary element has to be used " - "in an approximation.")); + "in an approximation.")); return 0; } else if (max_block_level < 4) @@ -407,19 +407,19 @@ fiasco_c_options_set_optimizations (fiasco_c_options_t *options, else if (max_block_level < min_block_level) { set_error (_("Maximum block size has to be larger or " - "equal minimum block size.")); + "equal minimum block size.")); return 0; } else { - this->lc_min_level = min_block_level; - this->lc_max_level = max_block_level; - this->max_states = dictionary_size; - this->max_elements = max_elements; + this->lc_min_level = min_block_level; + this->lc_max_level = max_block_level; + this->max_states = dictionary_size; + this->max_elements = max_elements; this->second_domain_block = optimization_level > 0 ? YES : NO; this->check_for_overflow = optimization_level > 1 ? YES : NO; this->check_for_underflow = optimization_level > 1 ? YES : NO; - this->full_search = optimization_level > 1 ? YES : NO; + this->full_search = optimization_level > 1 ? YES : NO; return 1; } @@ -427,9 +427,9 @@ fiasco_c_options_set_optimizations (fiasco_c_options_t *options, int fiasco_c_options_set_prediction (fiasco_c_options_t *options, - int intra_prediction, - unsigned min_block_level, - unsigned max_block_level) + int intra_prediction, + unsigned min_block_level, + unsigned max_block_level) /* * Set minimum and maximum size of image block prediction to * `min_block_level' and `max_block_level'. @@ -438,8 +438,8 @@ fiasco_c_options_set_prediction (fiasco_c_options_t *options, * Prediction of intra frames is only used if `intra_prediction' != 0. * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise */ { c_options_t *this = (c_options_t *) cast_c_options (options); @@ -451,19 +451,19 @@ fiasco_c_options_set_prediction (fiasco_c_options_t *options, else if (max_block_level < 6) { set_error (_("Maximum prediction block size has to be " - "at least level 6")); + "at least level 6")); return 0; } else if (min_block_level < 6) { set_error (_("Minimum prediction block size has to be " - "at least level 6")); + "at least level 6")); return 0; } else if (max_block_level < min_block_level) { set_error (_("Maximum prediction block size has to be larger or " - "equal minimum block size.")); + "equal minimum block size.")); return 0; } else @@ -471,17 +471,17 @@ fiasco_c_options_set_prediction (fiasco_c_options_t *options, this->p_min_level = min_block_level; this->p_max_level = max_block_level; this->prediction = intra_prediction; - + return 1; } } int fiasco_c_options_set_video_param (fiasco_c_options_t *options, - unsigned frames_per_second, - int half_pixel_prediction, - int cross_B_search, - int B_as_past_ref) + unsigned frames_per_second, + int half_pixel_prediction, + int cross_B_search, + int B_as_past_ref) /* * Set various parameters used for video compensation. * 'frames_per_second' defines the frame rate which should be @@ -494,10 +494,10 @@ fiasco_c_options_set_video_param (fiasco_c_options_t *options, * exhaustive search (in the given search range) is used. * If 'B_as_past_ref' is not 0 then B frames are allowed to be used * for B frame predicion. - * + * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise */ { c_options_t *this = (c_options_t *) cast_c_options (options); @@ -508,10 +508,10 @@ fiasco_c_options_set_video_param (fiasco_c_options_t *options, } else { - this->fps = frames_per_second; + this->fps = frames_per_second; this->half_pixel_prediction = half_pixel_prediction; - this->cross_B_search = cross_B_search; - this->B_as_past_ref = B_as_past_ref; + this->cross_B_search = cross_B_search; + this->B_as_past_ref = B_as_past_ref; return 1; } @@ -519,20 +519,20 @@ fiasco_c_options_set_video_param (fiasco_c_options_t *options, int fiasco_c_options_set_quantization (fiasco_c_options_t *options, - unsigned mantissa, - fiasco_rpf_range_e range, - unsigned dc_mantissa, - fiasco_rpf_range_e dc_range) + unsigned mantissa, + fiasco_rpf_range_e range, + unsigned dc_mantissa, + fiasco_rpf_range_e dc_range) /* * Set accuracy of coefficients quantization. * DC coefficients (of the constant dictionary vector f(x,y) = 1) * are quantized to values of the interval [-`dc_range', `dc_range'] using * #`dc_mantissa' bits. All other quantized coefficients are quantized in * an analogous way using the parameters `range' and `mantissa'. - * + * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise */ { c_options_t *this = (c_options_t *) cast_c_options (options); @@ -544,46 +544,46 @@ fiasco_c_options_set_quantization (fiasco_c_options_t *options, else if (mantissa < 2 || mantissa > 8 || dc_mantissa < 2 || dc_mantissa > 8) { set_error (_("Number of RPF mantissa bits `%d', `%d' have to be in " - "the interval [2,8]."), mantissa, dc_mantissa); + "the interval [2,8]."), mantissa, dc_mantissa); return 0; } else { if ((range == FIASCO_RPF_RANGE_0_75 - || range == FIASCO_RPF_RANGE_1_00 - || range == FIASCO_RPF_RANGE_1_50 - || range == FIASCO_RPF_RANGE_2_00) - && - (dc_range == FIASCO_RPF_RANGE_0_75 - || dc_range == FIASCO_RPF_RANGE_1_00 - || dc_range == FIASCO_RPF_RANGE_1_50 - || dc_range == FIASCO_RPF_RANGE_2_00)) + || range == FIASCO_RPF_RANGE_1_00 + || range == FIASCO_RPF_RANGE_1_50 + || range == FIASCO_RPF_RANGE_2_00) + && + (dc_range == FIASCO_RPF_RANGE_0_75 + || dc_range == FIASCO_RPF_RANGE_1_00 + || dc_range == FIASCO_RPF_RANGE_1_50 + || dc_range == FIASCO_RPF_RANGE_2_00)) { - this->rpf_range = range; - this->dc_rpf_range = dc_range; - this->rpf_mantissa = mantissa; - this->dc_rpf_mantissa = dc_mantissa; + this->rpf_range = range; + this->dc_rpf_range = dc_range; + this->rpf_mantissa = mantissa; + this->dc_rpf_mantissa = dc_mantissa; - return 1; + return 1; } else { - set_error (_("Invalid RPF ranges `%d', `%d' specified."), - range, dc_range); - return 0; + set_error (_("Invalid RPF ranges `%d', `%d' specified."), + range, dc_range); + return 0; } } } int fiasco_c_options_set_progress_meter (fiasco_c_options_t *options, - fiasco_progress_e type) + fiasco_progress_e type) /* * Set type of progress meter. * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise */ { c_options_t *this = (c_options_t *) cast_c_options (options); @@ -597,12 +597,12 @@ fiasco_c_options_set_progress_meter (fiasco_c_options_t *options, case FIASCO_PROGRESS_BAR: case FIASCO_PROGRESS_PERCENT: case FIASCO_PROGRESS_NONE: - this->progress_meter = type; - break; + this->progress_meter = type; + break; default: - set_error (_("Invalid progress meter `%d' specified " - "(valid values are 0, 1, or 2)."), type); - return 0; + set_error (_("Invalid progress meter `%d' specified " + "(valid values are 0, 1, or 2)."), type); + return 0; } return 1; } @@ -611,10 +611,10 @@ int fiasco_c_options_set_smoothing (fiasco_c_options_t *options, int smoothing) /* * Define `smoothing'-percentage along partitioning borders. - * + * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise */ { c_options_t *this = (c_options_t *) cast_c_options (options); @@ -639,10 +639,10 @@ int fiasco_c_options_set_comment (fiasco_c_options_t *options, const char *comment) /* * Define `comment' of FIASCO stream. - * + * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise */ { c_options_t *this = (c_options_t *) cast_c_options (options); @@ -667,10 +667,10 @@ int fiasco_c_options_set_title (fiasco_c_options_t *options, const char *title) /* * Define `title' of FIASCO stream. - * + * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise */ { c_options_t *this = (c_options_t *) cast_c_options (options); @@ -698,7 +698,7 @@ cast_c_options (fiasco_c_options_t *options) * Check whether `options' is a valid object of type c_options_t. * * Return value: - * pointer to options struct on success + * pointer to options struct on success * NULL otherwise */ { @@ -707,8 +707,8 @@ cast_c_options (fiasco_c_options_t *options) { if (!streq (this->id, "COFIASCO")) { - set_error (_("Parameter `options' doesn't match required type.")); - return NULL; + set_error (_("Parameter `options' doesn't match required type.")); + return NULL; } } else @@ -721,7 +721,7 @@ cast_c_options (fiasco_c_options_t *options) /************************************************************************** *************************************************************************** - DECODER + DECODER *************************************************************************** **************************************************************************/ @@ -733,10 +733,10 @@ fiasco_d_options_new (void) * fill in default values. * * Return value: - * pointer to the new option structure + * pointer to the new option structure */ { - d_options_t *options = calloc (1, sizeof (d_options_t)); + d_options_t *options = calloc (1, sizeof (d_options_t)); fiasco_d_options_t *public = calloc (1, sizeof (fiasco_d_options_t)); if (!options || !public) @@ -744,21 +744,21 @@ fiasco_d_options_new (void) set_error (_("Out of memory.")); return NULL; } - public->private = options; - public->delete = fiasco_d_options_delete; + public->private = options; + public->delete = fiasco_d_options_delete; public->set_smoothing = fiasco_d_options_set_smoothing; public->set_magnification = fiasco_d_options_set_magnification; public->set_4_2_0_format = fiasco_d_options_set_4_2_0_format; - + strcpy (options->id, "DOFIASCO"); /* * Set default value of fiasco decoder options */ - options->smoothing = 70; + options->smoothing = 70; options->magnification = 0; options->image_format = FORMAT_4_4_4; - + return public; } @@ -771,14 +771,14 @@ fiasco_d_options_delete (fiasco_d_options_t *options) * No return value. * * Side effects: - * structure 'options' is discarded. + * structure 'options' is discarded. */ { d_options_t *this = cast_d_options (options); if (!this) return; - + Free (this); return; @@ -788,10 +788,10 @@ int fiasco_d_options_set_smoothing (fiasco_d_options_t *options, int smoothing) /* * Define `smoothing'-percentage along partitioning borders. - * + * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise */ { d_options_t *this = (d_options_t *) cast_d_options (options); @@ -822,8 +822,8 @@ fiasco_d_options_set_magnification (fiasco_d_options_t *options, int level) * etc. * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise */ { d_options_t *this = (d_options_t *) cast_d_options (options); @@ -843,10 +843,10 @@ int fiasco_d_options_set_4_2_0_format (fiasco_d_options_t *options, int format) /* * Set image format to 4:2:0 or 4:4:4. - * + * * Return value: - * 1 on success - * 0 otherwise + * 1 on success + * 0 otherwise */ { d_options_t *this = (d_options_t *) cast_d_options (options); @@ -869,18 +869,18 @@ cast_d_options (fiasco_d_options_t *options) * Check whether `options' is a valid object of type d_options_t. * * Return value: - * pointer to options struct on success + * pointer to options struct on success * NULL otherwise */ { d_options_t *this = (d_options_t *) options->private; - + if (this) { if (!streq (this->id, "DOFIASCO")) { - set_error (_("Parameter `options' doesn't match required type.")); - return NULL; + set_error (_("Parameter `options' doesn't match required type.")); + return NULL; } } else diff --git a/converter/other/fiasco/codec/options.h b/converter/other/fiasco/codec/options.h index 783c41ef..e39550f6 100644 --- a/converter/other/fiasco/codec/options.h +++ b/converter/other/fiasco/codec/options.h @@ -1,8 +1,8 @@ /* * options.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -19,49 +19,49 @@ typedef struct c_options { - char id [9]; - char *basis_name; - unsigned lc_min_level; - unsigned lc_max_level; - unsigned p_min_level; - unsigned p_max_level; - unsigned images_level; - unsigned max_states; - unsigned chroma_max_states; - unsigned max_elements; - unsigned tiling_exponent; + char id [9]; + char *basis_name; + unsigned lc_min_level; + unsigned lc_max_level; + unsigned p_min_level; + unsigned p_max_level; + unsigned images_level; + unsigned max_states; + unsigned chroma_max_states; + unsigned max_elements; + unsigned tiling_exponent; fiasco_tiling_e tiling_method; - char *id_domain_pool; - char *id_d_domain_pool; - char *id_rpf_model; - char *id_d_rpf_model; - unsigned rpf_mantissa; - real_t rpf_range; - unsigned dc_rpf_mantissa; + char *id_domain_pool; + char *id_d_domain_pool; + char *id_rpf_model; + char *id_d_rpf_model; + unsigned rpf_mantissa; + real_t rpf_range; + unsigned dc_rpf_mantissa; fiasco_rpf_range_e dc_rpf_range; - unsigned d_rpf_mantissa; + unsigned d_rpf_mantissa; fiasco_rpf_range_e d_rpf_range; - unsigned d_dc_rpf_mantissa; + unsigned d_dc_rpf_mantissa; fiasco_rpf_range_e d_dc_rpf_range; - real_t chroma_decrease; - bool_t prediction; - bool_t delta_domains; - bool_t normal_domains; - unsigned search_range; - unsigned fps; - char *pattern; - char *reference_filename; - bool_t half_pixel_prediction; - bool_t cross_B_search; - bool_t B_as_past_ref; - bool_t check_for_underflow; - bool_t check_for_overflow; - bool_t second_domain_block; - bool_t full_search; + real_t chroma_decrease; + bool_t prediction; + bool_t delta_domains; + bool_t normal_domains; + unsigned search_range; + unsigned fps; + char *pattern; + char *reference_filename; + bool_t half_pixel_prediction; + bool_t cross_B_search; + bool_t B_as_past_ref; + bool_t check_for_underflow; + bool_t check_for_overflow; + bool_t second_domain_block; + bool_t full_search; fiasco_progress_e progress_meter; - char *title; - char *comment; - unsigned smoothing; + char *title; + char *comment; + unsigned smoothing; } c_options_t; typedef struct d_options diff --git a/converter/other/fiasco/codec/prediction.c b/converter/other/fiasco/codec/prediction.c index c592baa5..c321391a 100644 --- a/converter/other/fiasco/codec/prediction.c +++ b/converter/other/fiasco/codec/prediction.c @@ -1,8 +1,8 @@ /* - * prediction.c: Range image prediction with MC or ND + * prediction.c: Range image prediction with MC or ND * - * Written by: Ullrich Hafner - * Michael Unger + * Written by: Ullrich Hafner + * Michael Unger * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -40,7 +40,7 @@ /***************************************************************************** - local variables + local variables *****************************************************************************/ @@ -55,7 +55,7 @@ typedef struct state_data real_t *ip_states_state [MAXLEVEL]; word_t tree [MAXLABELS]; - mv_t mv_tree [MAXLABELS]; + mv_t mv_tree [MAXLABELS]; word_t y_state [MAXLABELS]; byte_t y_column [MAXLABELS]; byte_t prediction [MAXLABELS]; @@ -70,49 +70,49 @@ typedef struct state_data /***************************************************************************** - prototypes + prototypes *****************************************************************************/ static real_t nd_prediction (real_t max_costs, real_t price, unsigned band, int y_state, - range_t *range, wfa_t *wfa, coding_t *c); + range_t *range, wfa_t *wfa, coding_t *c); static real_t mc_prediction (real_t max_costs, real_t price, unsigned band, int y_state, - range_t *range, wfa_t *wfa, coding_t *c); + range_t *range, wfa_t *wfa, coding_t *c); static state_data_t * store_state_data (unsigned from, unsigned to, unsigned max_level, - wfa_t *wfa, coding_t *c); + wfa_t *wfa, coding_t *c); static void restore_state_data (unsigned from, unsigned to, unsigned max_level, - state_data_t *data, wfa_t *wfa, coding_t *c); + state_data_t *data, wfa_t *wfa, coding_t *c); /***************************************************************************** - public code + public code *****************************************************************************/ real_t predict_range (real_t max_costs, real_t price, range_t *range, wfa_t *wfa, - coding_t *c, unsigned band, int y_state, unsigned states, - const tree_t *tree_model, const tree_t *p_tree_model, - const void *domain_model, const void *d_domain_model, - const void *coeff_model, const void *d_coeff_model) + coding_t *c, unsigned band, int y_state, unsigned states, + const tree_t *tree_model, const tree_t *p_tree_model, + const void *domain_model, const void *d_domain_model, + const void *coeff_model, const void *d_coeff_model) { - unsigned state; /* counter */ - void *rec_domain_model; /* domain model after recursion */ - void *rec_d_domain_model; /* p domain model after recursion */ - void *rec_coeff_model; /* coeff model after recursion */ - void *rec_d_coeff_model; /* d coeff model after recursion */ - tree_t rec_tree_model; /* tree_model after '' */ - tree_t rec_p_tree_model; /* p_tree_model after '' */ - unsigned rec_states; /* wfa->states after '' */ - real_t *rec_pixels; /* c->pixels after '' */ - state_data_t *rec_state_data; /* state_data struct after '' */ - real_t costs; /* current approximation costs */ - unsigned level; /* counter */ - state_data_t *sd; /* pointer to state_data field */ + unsigned state; /* counter */ + void *rec_domain_model; /* domain model after recursion */ + void *rec_d_domain_model; /* p domain model after recursion */ + void *rec_coeff_model; /* coeff model after recursion */ + void *rec_d_coeff_model; /* d coeff model after recursion */ + tree_t rec_tree_model; /* tree_model after '' */ + tree_t rec_p_tree_model; /* p_tree_model after '' */ + unsigned rec_states; /* wfa->states after '' */ + real_t *rec_pixels; /* c->pixels after '' */ + state_data_t *rec_state_data; /* state_data struct after '' */ + real_t costs; /* current approximation costs */ + unsigned level; /* counter */ + state_data_t *sd; /* pointer to state_data field */ /* * Store WFA data from state 'lc_states' to 'wfa->states' - 1 and @@ -127,7 +127,7 @@ predict_range (real_t max_costs, real_t price, range_t *range, wfa_t *wfa, rec_states = wfa->states; rec_pixels = c->pixels; rec_state_data = store_state_data (states, rec_states - 1, - c->options.lc_max_level, wfa, c); + c->options.lc_max_level, wfa, c); /* * Restore probability models to the state before the recursive subdivision @@ -138,9 +138,9 @@ predict_range (real_t max_costs, real_t price, range_t *range, wfa_t *wfa, c->p_tree = *p_tree_model; c->domain_pool->model = c->domain_pool->model_duplicate (domain_model); c->d_domain_pool->model = c->d_domain_pool->model_duplicate (d_domain_model); - c->coeff->model = c->coeff->model_duplicate (c->coeff, coeff_model); - c->d_coeff->model = c->d_coeff->model_duplicate (c->d_coeff, - d_coeff_model); + c->coeff->model = c->coeff->model_duplicate (c->coeff, coeff_model); + c->d_coeff->model = c->d_coeff->model_duplicate (c->d_coeff, + d_coeff_model); if (c->mt->frame_type == I_FRAME) costs = nd_prediction (max_costs, price, band, y_state, range, wfa, c); @@ -156,27 +156,27 @@ predict_range (real_t max_costs, real_t price, range_t *range, wfa_t *wfa, */ for (state = states; state < rec_states; state++) { - sd = &rec_state_data [state - states]; - for (level = c->options.images_level + 1; - level <= c->options.lc_max_level; level++) - if (sd->ip_states_state [level] != NULL) - Free (sd->ip_states_state [level]); - if (sd->images_of_state != NULL) - Free (sd->images_of_state); - if (sd->inner_products != NULL) - Free (sd->inner_products); + sd = &rec_state_data [state - states]; + for (level = c->options.images_level + 1; + level <= c->options.lc_max_level; level++) + if (sd->ip_states_state [level] != NULL) + Free (sd->ip_states_state [level]); + if (sd->images_of_state != NULL) + Free (sd->images_of_state); + if (sd->inner_products != NULL) + Free (sd->inner_products); } if (states < rec_states) - Free (rec_state_data); + Free (rec_state_data); c->domain_pool->model_free (rec_domain_model); c->d_domain_pool->model_free (rec_d_domain_model); c->coeff->model_free (rec_coeff_model); c->d_coeff->model_free (rec_d_coeff_model); costs = (range->tree_bits + range->matrix_bits + range->weights_bits - + range->mv_tree_bits + range->mv_coord_bits - + range->nd_tree_bits + range->nd_weights_bits) * price - + range->err; + + range->mv_tree_bits + range->mv_coord_bits + + range->nd_tree_bits + range->nd_weights_bits) * price + + range->err; } else { @@ -198,9 +198,9 @@ predict_range (real_t max_costs, real_t price, range_t *range, wfa_t *wfa, range->prediction = NO; if (wfa->states != states) - remove_states (states, wfa); + remove_states (states, wfa); restore_state_data (states, rec_states - 1, c->options.lc_max_level, - rec_state_data, wfa, c); + rec_state_data, wfa, c); costs = MAXCOSTS; } @@ -216,8 +216,8 @@ clear_norms_table (unsigned level, const wfa_info_t *wi, motion_t *mt) */ { unsigned range_size = wi->half_pixel - ? square (wi->search_range) - : square (2 * wi->search_range); + ? square (wi->search_range) + : square (2 * wi->search_range); if (level > wi->p_min_level) { @@ -236,34 +236,34 @@ update_norms_table (unsigned level, const wfa_info_t *wi, motion_t *mt) */ { unsigned range_size = wi->half_pixel - ? square (wi->search_range) - : square (2 * wi->search_range); + ? square (wi->search_range) + : square (2 * wi->search_range); if (level > wi->p_min_level) { - unsigned index; /* index of motion vector */ + unsigned index; /* index of motion vector */ for (index = 0; index < range_size; index++) - mt->mc_forward_norms [level][index] - += mt->mc_forward_norms [level - 1][index]; + mt->mc_forward_norms [level][index] + += mt->mc_forward_norms [level - 1][index]; if (mt->frame_type == B_FRAME) - for (index = 0; index < range_size; index++) - mt->mc_backward_norms [level][index] - += mt->mc_backward_norms [level - 1][index]; + for (index = 0; index < range_size; index++) + mt->mc_backward_norms [level][index] + += mt->mc_backward_norms [level - 1][index]; } } /***************************************************************************** - private code + private code *****************************************************************************/ static real_t mc_prediction (real_t max_costs, real_t price, unsigned band, int y_state, - range_t *range, wfa_t *wfa, coding_t *c) + range_t *range, wfa_t *wfa, coding_t *c) { - real_t costs; /* current approximation costs */ + real_t costs; /* current approximation costs */ range_t prange = *range; unsigned width = width_of_level (range->level); unsigned height = height_of_level (range->level); @@ -286,12 +286,12 @@ mc_prediction (real_t max_costs, real_t price, unsigned band, int y_state, costs = (prange.mv_tree_bits + prange.mv_coord_bits) * price; - if (costs < max_costs) /* motion vector not too expensive */ + if (costs < max_costs) /* motion vector not too expensive */ { - unsigned last_state; /* last WFA state before recursion */ - real_t *ipi [MAXSTATES]; /* inner products pointers */ + unsigned last_state; /* last WFA state before recursion */ + real_t *ipi [MAXSTATES]; /* inner products pointers */ unsigned state; - real_t mvt, mvc; + real_t mvt, mvc; c->pixels = Calloc (width * height, sizeof (real_t)); cut_to_bintree (c->pixels, mcpe, width, height, 0, 0, width, height); @@ -301,12 +301,12 @@ mc_prediction (real_t max_costs, real_t price, unsigned band, int y_state, */ last_state = wfa->states - 1; for (state = 0; state <= last_state; state++) - if (need_image (state, wfa)) - { - ipi [state] = c->ip_images_state[state]; - c->ip_images_state[state] - = Calloc (size_of_tree (c->products_level), sizeof (real_t)); - } + if (need_image (state, wfa)) + { + ipi [state] = c->ip_images_state[state]; + c->ip_images_state[state] + = Calloc (size_of_tree (c->products_level), sizeof (real_t)); + } mvc = prange.mv_coord_bits; mvt = prange.mv_tree_bits; @@ -322,42 +322,42 @@ mc_prediction (real_t max_costs, real_t price, unsigned band, int y_state, prange.nd_tree_bits = 0; compute_ip_images_state (prange.image, prange.address, prange.level, - 1, 0, wfa, c); + 1, 0, wfa, c); costs += subdivide (max_costs - costs, band, y_state, &prange, - wfa, c, NO, YES); + wfa, c, NO, YES); - if (costs < max_costs) /* use motion compensation */ + if (costs < max_costs) /* use motion compensation */ { - unsigned img, adr; /* temp. values */ - - img = range->image; - adr = range->address; - *range = prange; - range->image = img; - range->address = adr; - range->mv_coord_bits = mvc; - range->mv_tree_bits = mvt; - range->prediction = YES; - - for (state = last_state + 1; state < wfa->states; state++) - if (need_image (state, wfa)) - memset (c->ip_images_state [state], 0, - size_of_tree (c->products_level) * sizeof (real_t)); - - costs = (range->tree_bits + range->matrix_bits + range->weights_bits - + range->mv_tree_bits + range->mv_coord_bits - + range->nd_tree_bits + range->nd_weights_bits) * price - + range->err; + unsigned img, adr; /* temp. values */ + + img = range->image; + adr = range->address; + *range = prange; + range->image = img; + range->address = adr; + range->mv_coord_bits = mvc; + range->mv_tree_bits = mvt; + range->prediction = YES; + + for (state = last_state + 1; state < wfa->states; state++) + if (need_image (state, wfa)) + memset (c->ip_images_state [state], 0, + size_of_tree (c->products_level) * sizeof (real_t)); + + costs = (range->tree_bits + range->matrix_bits + range->weights_bits + + range->mv_tree_bits + range->mv_coord_bits + + range->nd_tree_bits + range->nd_weights_bits) * price + + range->err; } else - costs = MAXCOSTS; + costs = MAXCOSTS; for (state = 0; state <= last_state; state++) - if (need_image (state, wfa)) - { - Free (c->ip_images_state[state]); - c->ip_images_state[state] = ipi [state]; - } + if (need_image (state, wfa)) + { + Free (c->ip_images_state[state]); + c->ip_images_state[state] = ipi [state]; + } Free (c->pixels); } else @@ -370,9 +370,9 @@ mc_prediction (real_t max_costs, real_t price, unsigned band, int y_state, static real_t nd_prediction (real_t max_costs, real_t price, unsigned band, int y_state, - range_t *range, wfa_t *wfa, coding_t *c) + range_t *range, wfa_t *wfa, coding_t *c) { - real_t costs; /* current approximation costs */ + real_t costs; /* current approximation costs */ range_t lrange = *range; /* @@ -380,13 +380,13 @@ nd_prediction (real_t max_costs, real_t price, unsigned band, int y_state, */ { real_t x = get_ip_image_state (range->image, range->address, - range->level, 0, c); + range->level, 0, c); real_t y = get_ip_state_state (0, 0, range->level, c); real_t w = btor (rtob (x / y, c->coeff->dc_rpf), c->coeff->dc_rpf); word_t s [2] = {0, -1}; - lrange.into [0] = 0; - lrange.into [1] = NO_EDGE; + lrange.into [0] = 0; + lrange.into [1] = NO_EDGE; lrange.weight [0] = w; lrange.mv_coord_bits = 0; lrange.mv_tree_bits = 0; @@ -404,10 +404,10 @@ nd_prediction (real_t max_costs, real_t price, unsigned band, int y_state, if (costs < max_costs) { unsigned state; - range_t rrange; /* range: recursive subdivision */ - unsigned last_state; /* last WFA state before recursion */ - real_t *ipi [MAXSTATES]; /* inner products pointers */ - unsigned width = width_of_level (range->level); + range_t rrange; /* range: recursive subdivision */ + unsigned last_state; /* last WFA state before recursion */ + real_t *ipi [MAXSTATES]; /* inner products pointers */ + unsigned width = width_of_level (range->level); unsigned height = height_of_level (range->level); real_t *pixels; @@ -415,15 +415,15 @@ nd_prediction (real_t max_costs, real_t price, unsigned band, int y_state, * Generate difference image original - approximation */ { - unsigned n; - real_t *src, *dst; /* pointers to image data */ - real_t w = - lrange.weight [0] * c->images_of_state [0][0]; + unsigned n; + real_t *src, *dst; /* pointers to image data */ + real_t w = - lrange.weight [0] * c->images_of_state [0][0]; - src = c->pixels + range->address * size_of_level (range->level); - dst = c->pixels = pixels = Calloc (width * height, sizeof (real_t)); + src = c->pixels + range->address * size_of_level (range->level); + dst = c->pixels = pixels = Calloc (width * height, sizeof (real_t)); - for (n = width * height; n; n--) - *dst++ = *src++ + w; + for (n = width * height; n; n--) + *dst++ = *src++ + w; } /* @@ -442,56 +442,56 @@ nd_prediction (real_t max_costs, real_t price, unsigned band, int y_state, last_state = wfa->states - 1; for (state = 0; state <= last_state; state++) - if (need_image (state, wfa)) - { - ipi [state] = c->ip_images_state[state]; - c->ip_images_state[state] - = Calloc (size_of_tree (c->products_level), sizeof (real_t)); - } + if (need_image (state, wfa)) + { + ipi [state] = c->ip_images_state[state]; + c->ip_images_state[state] + = Calloc (size_of_tree (c->products_level), sizeof (real_t)); + } compute_ip_images_state (rrange.image, rrange.address, rrange.level, - 1, 0, wfa, c); + 1, 0, wfa, c); costs += subdivide (max_costs - costs, band, y_state, &rrange, wfa, c, - NO, YES); + NO, YES); Free (pixels); if (costs < max_costs && ischild (rrange.tree)) /* use prediction */ { - unsigned img, adr; - unsigned edge; - - img = range->image; - adr = range->address; - *range = rrange; - range->image = img; - range->address = adr; - range->nd_tree_bits += lrange.nd_tree_bits; - range->nd_weights_bits += lrange.weights_bits; - - for (edge = 0; isedge (lrange.into [edge]); edge++) - { - range->into [edge] = lrange.into [edge]; - range->weight [edge] = lrange.weight [edge]; - } - range->into [edge] = NO_EDGE; - range->prediction = edge; - - for (state = last_state + 1; state < wfa->states; state++) - if (need_image (state, wfa)) - memset (c->ip_images_state [state], 0, - size_of_tree (c->products_level) * sizeof (real_t)); + unsigned img, adr; + unsigned edge; + + img = range->image; + adr = range->address; + *range = rrange; + range->image = img; + range->address = adr; + range->nd_tree_bits += lrange.nd_tree_bits; + range->nd_weights_bits += lrange.weights_bits; + + for (edge = 0; isedge (lrange.into [edge]); edge++) + { + range->into [edge] = lrange.into [edge]; + range->weight [edge] = lrange.weight [edge]; + } + range->into [edge] = NO_EDGE; + range->prediction = edge; + + for (state = last_state + 1; state < wfa->states; state++) + if (need_image (state, wfa)) + memset (c->ip_images_state [state], 0, + size_of_tree (c->products_level) * sizeof (real_t)); } else - costs = MAXCOSTS; + costs = MAXCOSTS; for (state = 0; state <= last_state; state++) - if (need_image (state, wfa)) - { - Free (c->ip_images_state [state]); - c->ip_images_state [state] = ipi [state]; - } + if (need_image (state, wfa)) + { + Free (c->ip_images_state [state]); + c->ip_images_state [state] = ipi [state]; + } } else costs = MAXCOSTS; @@ -501,20 +501,20 @@ nd_prediction (real_t max_costs, real_t price, unsigned band, int y_state, static state_data_t * store_state_data (unsigned from, unsigned to, unsigned max_level, - wfa_t *wfa, coding_t *c) + wfa_t *wfa, coding_t *c) /* * Save and remove all states starting from state 'from'. * * Return value: - * pointer to array of state_data structs + * pointer to array of state_data structs */ { - state_data_t *data; /* array of savestates */ - state_data_t *sd; /* pointer to current savestates */ - unsigned state, label, level; + state_data_t *data; /* array of savestates */ + state_data_t *sd; /* pointer to current savestates */ + unsigned state, label, level; if (to < from) - return NULL; /* nothing to do */ + return NULL; /* nothing to do */ data = Calloc (to - from + 1, sizeof (state_data_t)); @@ -534,30 +534,30 @@ store_state_data (unsigned from, unsigned to, unsigned max_level, for (label = 0; label < MAXLABELS; label++) { - sd->tree [label] = wfa->tree [state][label]; - sd->y_state [label] = wfa->y_state [state][label]; - sd->y_column [label] = wfa->y_column [state][label]; - sd->mv_tree [label] = wfa->mv_tree [state][label]; - sd->x [label] = wfa->x [state][label]; - sd->y [label] = wfa->y [state][label]; - sd->prediction [label] = wfa->prediction [state][label]; - - memcpy (sd->weight [label], wfa->weight [state][label], - sizeof (real_t) * (MAXEDGES + 1)); - memcpy (sd->int_weight [label], wfa->int_weight [state][label], - sizeof (word_t) * (MAXEDGES + 1)); - memcpy (sd->into [label], wfa->into [state][label], - sizeof (word_t) * (MAXEDGES + 1)); - - wfa->into [state][label][0] = NO_EDGE; - wfa->tree [state][label] = RANGE; - wfa->y_state [state][label] = RANGE; + sd->tree [label] = wfa->tree [state][label]; + sd->y_state [label] = wfa->y_state [state][label]; + sd->y_column [label] = wfa->y_column [state][label]; + sd->mv_tree [label] = wfa->mv_tree [state][label]; + sd->x [label] = wfa->x [state][label]; + sd->y [label] = wfa->y [state][label]; + sd->prediction [label] = wfa->prediction [state][label]; + + memcpy (sd->weight [label], wfa->weight [state][label], + sizeof (real_t) * (MAXEDGES + 1)); + memcpy (sd->int_weight [label], wfa->int_weight [state][label], + sizeof (word_t) * (MAXEDGES + 1)); + memcpy (sd->into [label], wfa->into [state][label], + sizeof (word_t) * (MAXEDGES + 1)); + + wfa->into [state][label][0] = NO_EDGE; + wfa->tree [state][label] = RANGE; + wfa->y_state [state][label] = RANGE; } for (level = c->options.images_level + 1; level <= max_level; - level++) + level++) { - sd->ip_states_state [level] = c->ip_states_state [state][level]; - c->ip_states_state [state][level] = NULL; + sd->ip_states_state [level] = c->ip_states_state [state][level]; + c->ip_states_state [state][level] = NULL; } } @@ -566,18 +566,18 @@ store_state_data (unsigned from, unsigned to, unsigned max_level, static void restore_state_data (unsigned from, unsigned to, unsigned max_level, - state_data_t *data, wfa_t *wfa, coding_t *c) + state_data_t *data, wfa_t *wfa, coding_t *c) /* * Restore all state data starting from state 'from'. * * No return value. */ { - state_data_t *sd; /* pointer to state_data item */ - unsigned state, label, level; + state_data_t *sd; /* pointer to state_data item */ + unsigned state, label, level; if (to < from) - return; /* nothing to do */ + return; /* nothing to do */ for (state = from; state <= to; state++) { @@ -588,35 +588,35 @@ restore_state_data (unsigned from, unsigned to, unsigned max_level, wfa->domain_type [state] = sd->domain_type; if (c->images_of_state [state] != NULL) - Free (c->images_of_state [state]); + Free (c->images_of_state [state]); c->images_of_state [state] = sd->images_of_state; if (c->ip_images_state [state] != NULL) - Free (c->ip_images_state [state]); + Free (c->ip_images_state [state]); c->ip_images_state [state] = sd->inner_products; for (label = 0; label < MAXLABELS; label++) { - wfa->tree [state][label] = sd->tree [label]; - wfa->y_state [state][label] = sd->y_state [label]; - wfa->y_column [state][label] = sd->y_column [label]; - wfa->mv_tree [state][label] = sd->mv_tree [label]; - wfa->x [state][label] = sd->x [label]; - wfa->y [state][label] = sd->y [label]; - wfa->prediction [state][label] = sd->prediction [label]; - - memcpy (wfa->weight [state][label], sd->weight [label], - sizeof(real_t) * (MAXEDGES + 1)); - memcpy (wfa->int_weight [state][label], sd->int_weight [label], - sizeof(word_t) * (MAXEDGES + 1)); - memcpy (wfa->into [state][label], sd->into [label], - sizeof(word_t) * (MAXEDGES + 1)); + wfa->tree [state][label] = sd->tree [label]; + wfa->y_state [state][label] = sd->y_state [label]; + wfa->y_column [state][label] = sd->y_column [label]; + wfa->mv_tree [state][label] = sd->mv_tree [label]; + wfa->x [state][label] = sd->x [label]; + wfa->y [state][label] = sd->y [label]; + wfa->prediction [state][label] = sd->prediction [label]; + + memcpy (wfa->weight [state][label], sd->weight [label], + sizeof(real_t) * (MAXEDGES + 1)); + memcpy (wfa->int_weight [state][label], sd->int_weight [label], + sizeof(word_t) * (MAXEDGES + 1)); + memcpy (wfa->into [state][label], sd->into [label], + sizeof(word_t) * (MAXEDGES + 1)); } for (level = c->options.images_level + 1; level <= max_level; - level++) + level++) { - if (c->ip_states_state [state][level] != NULL) - Free (c->ip_states_state [state][level]); - c->ip_states_state [state][level] = sd->ip_states_state [level]; + if (c->ip_states_state [state][level] != NULL) + Free (c->ip_states_state [state][level]); + c->ip_states_state [state][level] = sd->ip_states_state [level]; } } diff --git a/converter/other/fiasco/codec/prediction.h b/converter/other/fiasco/codec/prediction.h index 0646dfd8..10b432b3 100644 --- a/converter/other/fiasco/codec/prediction.h +++ b/converter/other/fiasco/codec/prediction.h @@ -1,9 +1,9 @@ /* * prediction.h * - * Written by: Ullrich Hafner - * Michael Unger - * + * Written by: Ullrich Hafner + * Michael Unger + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -23,10 +23,10 @@ real_t predict_range (real_t max_costs, real_t price, range_t *range, wfa_t *wfa, - coding_t *c, unsigned band, int y_state, unsigned states, - const tree_t *tree_model, const tree_t *p_tree_model, - const void *domain_model, const void *d_domain_model, - const void *coeff_model, const void *d_coeff_model); + coding_t *c, unsigned band, int y_state, unsigned states, + const tree_t *tree_model, const tree_t *p_tree_model, + const void *domain_model, const void *d_domain_model, + const void *coeff_model, const void *d_coeff_model); void update_norms_table (unsigned level, const wfa_info_t *wi, motion_t *mt); void diff --git a/converter/other/fiasco/codec/subdivide.c b/converter/other/fiasco/codec/subdivide.c index 3ddf1ffc..7eb951c0 100644 --- a/converter/other/fiasco/codec/subdivide.c +++ b/converter/other/fiasco/codec/subdivide.c @@ -1,7 +1,7 @@ /* - * subdivide.c: Recursive subdivision of range images + * subdivide.c: Recursive subdivision of range images * - * Written by: Ullrich Hafner + * Written by: Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -41,27 +41,27 @@ /***************************************************************************** - prototypes + prototypes *****************************************************************************/ static void init_new_state (bool_t auxiliary_state, bool_t delta, range_t *range, - const range_t *child, const int *y_state, - wfa_t *wfa, coding_t *c); + const range_t *child, const int *y_state, + wfa_t *wfa, coding_t *c); static void init_range (range_t *range, const image_t *image, unsigned band, - const wfa_t *wfa, coding_t *c); + const wfa_t *wfa, coding_t *c); /***************************************************************************** - public code + public code *****************************************************************************/ real_t subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, - wfa_t *wfa, coding_t *c, bool_t prediction, bool_t delta) + wfa_t *wfa, coding_t *c, bool_t prediction, bool_t delta) /* * Subdivide the current 'range' recursively and decide whether * a linear combination, a recursive subdivision, or a prediction is @@ -73,46 +73,46 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, * If 'delta' is TRUE then current range is already predicted. * * Return value: - * costs of the best approximation or MAXCOSTS if costs exceed 'max_costs' + * costs of the best approximation or MAXCOSTS if costs exceed 'max_costs' * * Side effects: - * 'range' factors and costs of linear combination are modified - * 'wfa' new transitions and prediction coefficients are added - * 'c' pixels and inner products are updated + * 'range' factors and costs of linear combination are modified + * 'wfa' new transitions and prediction coefficients are added + * 'c' pixels and inner products are updated */ { real_t subdivide_costs; /* Costs arising from approx. the current - range with two children */ + range with two children */ real_t lincomb_costs; /* Costs arising from approx. the current - range with a linear combination */ - int new_y_state [MAXLABELS]; /* Corresponding state of Y */ - real_t price; /* Approximation costs multiplier */ - bool_t try_mc; /* YES: try MC prediction */ - bool_t try_nd; /* YES: try ND prediction */ - unsigned states; /* Number of states before the - recursive subdivision starts */ - void *domain_model; /* copy of domain pool model */ - void *d_domain_model; /* copy of delta domain pool model */ - void *lc_domain_model; /* copy of domain pool model */ - void *lc_d_domain_model; /* copy of delta domain pool model */ - void *coeff_model; /* copy of coefficients model */ - void *d_coeff_model; /* copy of delta coefficients model */ - void *lc_coeff_model; /* copy of coefficients model */ - void *lc_d_coeff_model; /* copy of delta coefficients model */ - tree_t tree_model; /* copy of tree model */ - tree_t p_tree_model; /* copy of pred. tree model */ - range_t lrange; /* range of lin. comb. approx. */ - range_t rrange; /* range of recursive approx. */ - range_t child [MAXLABELS]; /* new children of the current range */ - static unsigned percent = 0; /* status of progress meter */ + range with a linear combination */ + int new_y_state [MAXLABELS]; /* Corresponding state of Y */ + real_t price; /* Approximation costs multiplier */ + bool_t try_mc; /* YES: try MC prediction */ + bool_t try_nd; /* YES: try ND prediction */ + unsigned states; /* Number of states before the + recursive subdivision starts */ + void *domain_model; /* copy of domain pool model */ + void *d_domain_model; /* copy of delta domain pool model */ + void *lc_domain_model; /* copy of domain pool model */ + void *lc_d_domain_model; /* copy of delta domain pool model */ + void *coeff_model; /* copy of coefficients model */ + void *d_coeff_model; /* copy of delta coefficients model */ + void *lc_coeff_model; /* copy of coefficients model */ + void *lc_d_coeff_model; /* copy of delta coefficients model */ + tree_t tree_model; /* copy of tree model */ + tree_t p_tree_model; /* copy of pred. tree model */ + range_t lrange; /* range of lin. comb. approx. */ + range_t rrange; /* range of recursive approx. */ + range_t child [MAXLABELS]; /* new children of the current range */ + static unsigned percent = 0; /* status of progress meter */ if (wfa->wfainfo->level == range->level) percent = 0; - range->into [0] = NO_EDGE; /* default approximation: empty */ + range->into [0] = NO_EDGE; /* default approximation: empty */ range->tree = RANGE; - if (range->level < 3) /* Don't process small ranges */ + if (range->level < 3) /* Don't process small ranges */ return MAXCOSTS; /* @@ -122,35 +122,35 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, if (c->tiling->exponent && range->level == wfa->wfainfo->level - c->tiling->exponent) { - unsigned width, height; /* size of range (dummies)*/ + unsigned width, height; /* size of range (dummies)*/ if (c->tiling->vorder [range->global_address] < 0) - return 0; /* nothing to do */ + return 0; /* nothing to do */ else - locate_subimage (wfa->wfainfo->level, range->level, - c->tiling->vorder [range->global_address], - &range->x, &range->y, &width, &height); + locate_subimage (wfa->wfainfo->level, range->level, + c->tiling->vorder [range->global_address], + &range->x, &range->y, &width, &height); } if (range->x >= c->mt->original->width || range->y >= c->mt->original->height) - return 0; /* range is not visible */ + return 0; /* range is not visible */ /* * Check whether prediction is allowed or not * mc == motion compensation, nd == nondeterminism */ try_mc = (prediction && c->mt->frame_type != I_FRAME - && range->level >= wfa->wfainfo->p_min_level - && range->level <= wfa->wfainfo->p_max_level - && (range->x + width_of_level (range->level) - <= c->mt->original->width) - && (range->y + height_of_level (range->level) - <= c->mt->original->height)); + && range->level >= wfa->wfainfo->p_min_level + && range->level <= wfa->wfainfo->p_max_level + && (range->x + width_of_level (range->level) + <= c->mt->original->width) + && (range->y + height_of_level (range->level) + <= c->mt->original->height)); try_nd = (prediction && c->mt->frame_type == I_FRAME - && range->level >= wfa->wfainfo->p_min_level - && range->level <= wfa->wfainfo->p_max_level); + && range->level >= wfa->wfainfo->p_min_level + && range->level <= wfa->wfainfo->p_max_level); if (try_mc) clear_norms_table (range->level, wfa->wfainfo, c->mt); @@ -171,15 +171,15 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, /* * Compute children of corresponding state in Y band */ - if (band != Y) /* Cb and Cr bands only */ + if (band != Y) /* Cb and Cr bands only */ { unsigned label; for (label = 0; label < MAXLABELS; label++) - if (ischild (y_state)) - new_y_state [label] = wfa->tree [y_state][label]; - else - new_y_state [label] = RANGE; + if (ischild (y_state)) + new_y_state [label] = wfa->tree [y_state][label]; + else + new_y_state [label] = RANGE; } else new_y_state [0] = new_y_state [1] = RANGE; @@ -210,13 +210,13 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, lrange.mv_coord_bits = 0; lrange.nd_tree_bits = 0; lrange.nd_weights_bits = 0; - lrange.prediction = NO; + lrange.prediction = NO; lincomb_costs - = approximate_range (max_costs, price, c->options.max_elements, - y_state, &lrange, - (delta ? c->d_domain_pool : c->domain_pool), - (delta ? c->d_coeff : c->coeff), wfa, c); + = approximate_range (max_costs, price, c->options.max_elements, + y_state, &lrange, + (delta ? c->d_domain_pool : c->domain_pool), + (delta ? c->d_coeff : c->coeff), wfa, c); } else lincomb_costs = MAXCOSTS; @@ -236,7 +236,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, c->d_domain_pool->model = c->d_domain_pool->model_duplicate (d_domain_model); c->coeff->model = c->coeff->model_duplicate (c->coeff, coeff_model); c->d_coeff->model = c->d_coeff->model_duplicate (c->d_coeff, - d_coeff_model); + d_coeff_model); /* * Second alternative of range approximation: @@ -256,122 +256,122 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, rrange.matrix_bits = 0; rrange.weights_bits = 0; rrange.err = 0; - rrange.mv_tree_bits = try_mc ? 1 : 0; /* mc allowed but not used */ + rrange.mv_tree_bits = try_mc ? 1 : 0; /* mc allowed but not used */ rrange.mv_coord_bits = 0; rrange.nd_tree_bits = try_nd ? - tree_bits (CHILD, lrange.level, &c->p_tree): 0; + tree_bits (CHILD, lrange.level, &c->p_tree): 0; rrange.nd_weights_bits = 0; - rrange.prediction = NO; + rrange.prediction = NO; /* * Initialize the cost function and subdivide the current range. * Every child is approximated by a recursive call of subdivide() */ subdivide_costs = (rrange.tree_bits + rrange.weights_bits - + rrange.matrix_bits + rrange.mv_tree_bits - + rrange.mv_coord_bits + rrange.nd_tree_bits - + rrange.nd_weights_bits) * price; + + rrange.matrix_bits + rrange.mv_tree_bits + + rrange.mv_coord_bits + rrange.nd_tree_bits + + rrange.nd_weights_bits) * price; for (label = 0; label < MAXLABELS; label++) { - real_t remaining_costs; /* upper limit for next recursion */ - - child[label].image = rrange.image * MAXLABELS + label + 1; - child[label].address = rrange.address * MAXLABELS + label; - child[label].global_address = rrange.global_address * MAXLABELS - + label; - child[label].level = rrange.level - 1; - child[label].x = rrange.level & 1 - ? rrange.x - : (rrange.x - + label * width_of_level (rrange.level - 1)); - child[label].y = rrange.level & 1 - ? (rrange.y - + label * height_of_level (rrange.level - 1)) - : rrange.y; - - /* - * If necessary compute the inner products of the new states - * (generated during the recursive approximation of child [0]) - */ - if (label && rrange.level <= c->options.lc_max_level) - compute_ip_images_state (child[label].image, child[label].address, - child[label].level, 1, states, wfa, c); - /* - * Call subdivide() for both children. - * Abort the recursion if 'subdivide_costs' exceed 'lincomb_costs' - * or 'max_costs'. - */ - remaining_costs = MIN(lincomb_costs, max_costs) - subdivide_costs; - - if (remaining_costs > 0) /* still a way for improvement */ - { - subdivide_costs += subdivide (remaining_costs, band, - new_y_state [label], &child [label], - wfa, c, prediction, delta); - } - else if (try_mc && child[label].level >= wfa->wfainfo->p_min_level) - { - fill_norms_table (child[label].x, child[label].y, - child[label].level, wfa->wfainfo, c->mt); - } - - if (try_mc) - update_norms_table (rrange.level, wfa->wfainfo, c->mt); - - /* - * Update of progress meter - */ - if (c->options.progress_meter != FIASCO_PROGRESS_NONE) - { - if (c->options.progress_meter == FIASCO_PROGRESS_PERCENT) - { - unsigned new_percent; /* new status of progress meter */ - - new_percent = (child[label].global_address + 1) * 100.0 - / (1 << (wfa->wfainfo->level - child[label].level)); - if (new_percent > percent) - { - percent = new_percent; - info ("%3d%% \r", percent); - } - } - else if (c->options.progress_meter == FIASCO_PROGRESS_BAR) - { - unsigned new_percent; /* new status of progress meter */ - - new_percent = (child[label].global_address + 1) * 50.0 - / (1 << (wfa->wfainfo->level - - child[label].level)); - for (; new_percent > percent; percent++) - { - info ("#"); - } - } - } - - /* - * If costs of subdivision exceed costs of linear combination - * then abort recursion. - */ - if (subdivide_costs >= MIN(lincomb_costs, max_costs)) - { - subdivide_costs = MAXCOSTS; - break; - } - rrange.err += child [label].err; - rrange.tree_bits += child [label].tree_bits; - rrange.matrix_bits += child [label].matrix_bits; - rrange.weights_bits += child [label].weights_bits; - rrange.mv_tree_bits += child [label].mv_tree_bits; - rrange.mv_coord_bits += child [label].mv_coord_bits; - rrange.nd_weights_bits += child [label].nd_weights_bits; - rrange.nd_tree_bits += child [label].nd_tree_bits; - - tree_update (ischild (child [label].tree) ? CHILD : LEAF, - child [label].level, &c->tree); - tree_update (child [label].prediction ? LEAF : CHILD, - child [label].level, &c->p_tree); + real_t remaining_costs; /* upper limit for next recursion */ + + child[label].image = rrange.image * MAXLABELS + label + 1; + child[label].address = rrange.address * MAXLABELS + label; + child[label].global_address = rrange.global_address * MAXLABELS + + label; + child[label].level = rrange.level - 1; + child[label].x = rrange.level & 1 + ? rrange.x + : (rrange.x + + label * width_of_level (rrange.level - 1)); + child[label].y = rrange.level & 1 + ? (rrange.y + + label * height_of_level (rrange.level - 1)) + : rrange.y; + + /* + * If necessary compute the inner products of the new states + * (generated during the recursive approximation of child [0]) + */ + if (label && rrange.level <= c->options.lc_max_level) + compute_ip_images_state (child[label].image, child[label].address, + child[label].level, 1, states, wfa, c); + /* + * Call subdivide() for both children. + * Abort the recursion if 'subdivide_costs' exceed 'lincomb_costs' + * or 'max_costs'. + */ + remaining_costs = MIN(lincomb_costs, max_costs) - subdivide_costs; + + if (remaining_costs > 0) /* still a way for improvement */ + { + subdivide_costs += subdivide (remaining_costs, band, + new_y_state [label], &child [label], + wfa, c, prediction, delta); + } + else if (try_mc && child[label].level >= wfa->wfainfo->p_min_level) + { + fill_norms_table (child[label].x, child[label].y, + child[label].level, wfa->wfainfo, c->mt); + } + + if (try_mc) + update_norms_table (rrange.level, wfa->wfainfo, c->mt); + + /* + * Update of progress meter + */ + if (c->options.progress_meter != FIASCO_PROGRESS_NONE) + { + if (c->options.progress_meter == FIASCO_PROGRESS_PERCENT) + { + unsigned new_percent; /* new status of progress meter */ + + new_percent = (child[label].global_address + 1) * 100.0 + / (1 << (wfa->wfainfo->level - child[label].level)); + if (new_percent > percent) + { + percent = new_percent; + info ("%3d%% \r", percent); + } + } + else if (c->options.progress_meter == FIASCO_PROGRESS_BAR) + { + unsigned new_percent; /* new status of progress meter */ + + new_percent = (child[label].global_address + 1) * 50.0 + / (1 << (wfa->wfainfo->level + - child[label].level)); + for (; new_percent > percent; percent++) + { + info ("#"); + } + } + } + + /* + * If costs of subdivision exceed costs of linear combination + * then abort recursion. + */ + if (subdivide_costs >= MIN(lincomb_costs, max_costs)) + { + subdivide_costs = MAXCOSTS; + break; + } + rrange.err += child [label].err; + rrange.tree_bits += child [label].tree_bits; + rrange.matrix_bits += child [label].matrix_bits; + rrange.weights_bits += child [label].weights_bits; + rrange.mv_tree_bits += child [label].mv_tree_bits; + rrange.mv_coord_bits += child [label].mv_coord_bits; + rrange.nd_weights_bits += child [label].nd_weights_bits; + rrange.nd_tree_bits += child [label].nd_tree_bits; + + tree_update (ischild (child [label].tree) ? CHILD : LEAF, + child [label].level, &c->tree); + tree_update (child [label].prediction ? LEAF : CHILD, + child [label].level, &c->p_tree); } } else @@ -382,9 +382,9 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, * Predict range via motion compensation or nondeterminism and * approximate delta image. */ - if (try_mc || try_nd) /* try prediction */ + if (try_mc || try_nd) /* try prediction */ { - real_t prediction_costs; /* Costs arising from approx. the current + real_t prediction_costs; /* Costs arising from approx. the current range with prediction */ prediction_costs @@ -393,7 +393,7 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, 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 */ + if (prediction_costs < MAXCOSTS) /* prediction has smallest costs */ { c->domain_pool->model_free (domain_model); c->d_domain_pool->model_free (d_domain_model); @@ -426,13 +426,13 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, c->domain_pool->model = domain_model; c->d_domain_pool->model = d_domain_model; - c->coeff->model = coeff_model; - c->d_coeff->model = d_coeff_model; + c->coeff->model = coeff_model; + c->d_coeff->model = d_coeff_model; c->tree = tree_model; c->p_tree = p_tree_model; if (wfa->states != states) - remove_states (states, wfa); + remove_states (states, wfa); return MAXCOSTS; } @@ -455,15 +455,15 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, c->domain_pool->model = lc_domain_model; c->d_domain_pool->model = lc_d_domain_model; - c->coeff->model = lc_coeff_model; - c->d_coeff->model = lc_d_coeff_model; + c->coeff->model = lc_coeff_model; + c->d_coeff->model = lc_d_coeff_model; c->tree = tree_model; c->p_tree = p_tree_model; *range = lrange; if (wfa->states != states) - remove_states (states, wfa); + remove_states (states, wfa); return lincomb_costs; } @@ -478,15 +478,15 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, * - if state is (partially) outside image geometry */ if (band > Y - || (c->tiling->exponent - && rrange.level > wfa->wfainfo->level - c->tiling->exponent) - || (range->x + width_of_level (range->level) - > c->mt->original->width) - || (range->y + height_of_level (range->level) - > c->mt->original->height)) - init_new_state (YES, delta, &rrange, child, new_y_state, wfa, c); + || (c->tiling->exponent + && rrange.level > wfa->wfainfo->level - c->tiling->exponent) + || (range->x + width_of_level (range->level) + > c->mt->original->width) + || (range->y + height_of_level (range->level) + > c->mt->original->height)) + init_new_state (YES, delta, &rrange, child, new_y_state, wfa, c); else - init_new_state (NO, delta, &rrange, child, new_y_state, wfa, c); + init_new_state (NO, delta, &rrange, child, new_y_state, wfa, c); *range = rrange; @@ -505,8 +505,8 @@ subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, void cut_to_bintree (real_t *dst, const word_t *src, - unsigned src_width, unsigned src_height, - unsigned x0, unsigned y0, unsigned width, unsigned height) + unsigned src_width, unsigned src_height, + unsigned x0, unsigned y0, unsigned width, unsigned height) /* * Cut region ('x0', 'y0', 'width', 'height') of the pixel array 'src'. * Size of image is given by 'src_width' x 'src_height'. @@ -515,15 +515,15 @@ cut_to_bintree (real_t *dst, const word_t *src, * No return value. * * Side effects: - * 'dst []' is filled with corresponding region. + * 'dst []' is filled with corresponding region. */ { const unsigned mask01 = 0x555555; /* binary ...010101010101 */ const unsigned mask10 = 0xaaaaaa; /* binary ...101010101010 */ const unsigned mask01plus1 = mask01 + 1; /* binary ...010101010110 */ const unsigned mask10plus1 = mask10 + 1; /* binary ...101010101011 */ - unsigned x, y; /* pixel coordinates */ - unsigned xmask, ymask; /* address conversion */ + unsigned x, y; /* pixel coordinates */ + unsigned xmask, ymask; /* address conversion */ if (width != height && width != (height >> 1)) error ("Bintree cutting requires special type of images."); @@ -534,24 +534,24 @@ cut_to_bintree (real_t *dst, const word_t *src, xmask = 0; for (x = x0; x < x0 + width; x++, xmask = (xmask + mask01plus1) & mask10) { - if (y >= src_height || x >= src_width) - dst [xmask | ymask] = 0; - else - dst [xmask | ymask] = src [y * src_width + x] / 16; + if (y >= src_height || x >= src_width) + dst [xmask | ymask] = 0; + else + dst [xmask | ymask] = src [y * src_width + x] / 16; } } } /***************************************************************************** - private code + private code *****************************************************************************/ static void init_new_state (bool_t auxiliary_state, bool_t delta, range_t *range, - const range_t *child, const int *y_state, - wfa_t *wfa, coding_t *c) + const range_t *child, const int *y_state, + wfa_t *wfa, coding_t *c) /* * Initializes a new state with all parameters needed for the encoding step. * If flag 'auxiliary_state' is set then don't insert state into domain pools. @@ -563,7 +563,7 @@ init_new_state (bool_t auxiliary_state, bool_t delta, range_t *range, * No return value. * * Side effects: - * New state is appended to 'wfa' (and also its inner products and images + * New state is appended to 'wfa' (and also its inner products and images * are computed and stored in 'c') */ { @@ -573,13 +573,13 @@ init_new_state (bool_t auxiliary_state, bool_t delta, range_t *range, if (!auxiliary_state) { if (!delta || c->options.delta_domains) - state_is_domain = c->domain_pool->append (wfa->states, range->level, - wfa, c->domain_pool->model); + state_is_domain = c->domain_pool->append (wfa->states, range->level, + wfa, c->domain_pool->model); if (delta || c->options.normal_domains) - state_is_domain = c->d_domain_pool->append (wfa->states, range->level, - wfa, - c->d_domain_pool->model) - || state_is_domain; + state_is_domain = c->d_domain_pool->append (wfa->states, range->level, + wfa, + c->d_domain_pool->model) + || state_is_domain; } else state_is_domain = NO; @@ -597,7 +597,7 @@ init_new_state (bool_t auxiliary_state, bool_t delta, range_t *range, wfa->prediction [wfa->states][label] = child [label].prediction; append_transitions (wfa->states, label, child [label].weight, - child [label].into, wfa); + child [label].into, wfa); } wfa->delta_state [wfa->states] = delta; @@ -607,13 +607,13 @@ init_new_state (bool_t auxiliary_state, bool_t delta, range_t *range, /* state_is_domain = YES; */ append_state (!state_is_domain, - compute_final_distribution (wfa->states, wfa), - range->level, wfa, c); + compute_final_distribution (wfa->states, wfa), + range->level, wfa, c); } static void init_range (range_t *range, const image_t *image, unsigned band, - const wfa_t *wfa, coding_t *c) + const wfa_t *wfa, coding_t *c) /* * Read a new 'range' of the image 'image_name' (current color component * is 'band') and compute the new inner product arrays. @@ -621,9 +621,9 @@ init_range (range_t *range, const image_t *image, unsigned band, * No return value. * * Side effects: - * 'c->pixels' are filled with pixel values of image block - * 'c->ip_images_state' are computed with respect to new image block - * 'range->address' and 'range->image' are initialized with zero + * 'c->pixels' are filled with pixel values of image block + * 'c->ip_images_state' are computed with respect to new image block + * 'range->address' and 'range->image' are initialized with zero */ { unsigned state; @@ -633,13 +633,13 @@ init_range (range_t *range, const image_t *image, unsigned band, */ for (state = 0; state < wfa->states; state++) if (need_image (state, wfa)) - memset (c->ip_images_state[state], 0, - size_of_tree (c->products_level) * sizeof(real_t)); + memset (c->ip_images_state[state], 0, + size_of_tree (c->products_level) * sizeof(real_t)); cut_to_bintree (c->pixels, image->pixels [band], - image->width, image->height, - range->x, range->y, width_of_level (range->level), - height_of_level (range->level)); + image->width, image->height, + range->x, range->y, width_of_level (range->level), + height_of_level (range->level)); range->address = range->image = 0; compute_ip_images_state (0, 0, range->level, 1, 0, wfa, c); diff --git a/converter/other/fiasco/codec/subdivide.h b/converter/other/fiasco/codec/subdivide.h index bd9cd10e..dbd5620a 100644 --- a/converter/other/fiasco/codec/subdivide.h +++ b/converter/other/fiasco/codec/subdivide.h @@ -1,8 +1,8 @@ /* * subdivide.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -20,13 +20,13 @@ #include "types.h" #include "cwfa.h" -real_t +real_t subdivide (real_t max_costs, unsigned band, int y_state, range_t *range, - wfa_t *wfa, coding_t *c, bool_t prediction, bool_t delta); + wfa_t *wfa, coding_t *c, bool_t prediction, bool_t delta); void cut_to_bintree (real_t *dst, const word_t *src, - unsigned src_width, unsigned src_height, - unsigned x0, unsigned y0, unsigned width, unsigned height); + unsigned src_width, unsigned src_height, + unsigned x0, unsigned y0, unsigned width, unsigned height); #endif /* not _SUBDIVIDE_H */ diff --git a/converter/other/fiasco/codec/tiling.c b/converter/other/fiasco/codec/tiling.c index 9af43da0..08423b24 100644 --- a/converter/other/fiasco/codec/tiling.c +++ b/converter/other/fiasco/codec/tiling.c @@ -1,8 +1,8 @@ /* - * tiling.c: Subimage permutation + * tiling.c: Subimage permutation + * + * Written by: Ullrich Hafner * - * Written by: Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -33,8 +33,8 @@ typedef struct var_list { - int address; /* bintree address */ - real_t variance; /* variance of tile */ + int address; /* bintree address */ + real_t variance; /* variance of tile */ } var_list_t; #ifndef LITERAL_FN_DEF_MATCH @@ -71,17 +71,17 @@ cmpdecvar(const void * const value1, tiling_t * alloc_tiling (fiasco_tiling_e method, unsigned tiling_exponent, - unsigned image_level) + unsigned image_level) /* * Image tiling constructor. * Allocate memory for the tiling_t structure. * `method' defines the tiling method (spiral or variance, * ascending or descending). * In case of invalid parameters, a structure with tiling.exponent == 0 is - * returned. + * returned. * * Return value - * pointer to the new tiling structure on success + * pointer to the new tiling structure on success */ { tiling_t *tiling = Calloc (1, sizeof (tiling_t)); @@ -90,21 +90,21 @@ alloc_tiling (fiasco_tiling_e method, unsigned tiling_exponent, { tiling_exponent = 6; warning (_("Image tiles must be at least 8x8 pixels large.\n" - "Setting tiling size to 8x8 pixels.")); + "Setting tiling size to 8x8 pixels.")); } - + switch (method) { case FIASCO_TILING_SPIRAL_ASC: case FIASCO_TILING_SPIRAL_DSC: case FIASCO_TILING_VARIANCE_ASC: case FIASCO_TILING_VARIANCE_DSC: - tiling_exponent = tiling_exponent; - break; + tiling_exponent = tiling_exponent; + break; default: - warning (_("Invalid tiling method specified. Disabling tiling.")); - tiling_exponent = 0; - break; + warning (_("Invalid tiling method specified. Disabling tiling.")); + tiling_exponent = 0; + break; } return tiling; @@ -119,7 +119,7 @@ free_tiling (tiling_t *tiling) * No return value. * * Side effects: - * structure 'tiling' is discarded. + * structure 'tiling' is discarded. */ { if (tiling->vorder) @@ -145,88 +145,88 @@ perform_tiling (const image_t *image, tiling_t *tiling) * No return value. * * Side effects: - * The tiling permutation is stored in 'tiling->vorder'. + * The tiling permutation is stored in 'tiling->vorder'. */ { if (tiling->exponent) { - unsigned tiles = 1 << tiling->exponent; /* number of image tiles */ - bool_t *tile_valid; /* tile i is in valid range ? */ - + unsigned tiles = 1 << tiling->exponent; /* number of image tiles */ + bool_t *tile_valid; /* tile i is in valid range ? */ + tiling->vorder = Calloc (tiles, sizeof (int)); tile_valid = Calloc (tiles, sizeof (bool_t)); if (tiling->method == FIASCO_TILING_VARIANCE_ASC - || tiling->method == FIASCO_TILING_VARIANCE_DSC) + || tiling->method == FIASCO_TILING_VARIANCE_DSC) { - unsigned address; /* bintree address of tile */ - 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); - var_list_t *var_list = Calloc (tiles, sizeof (var_list_t)); - - /* - * Compute variances of image tiles - */ - for (number = 0, address = 0; address < tiles; address++) - { - unsigned width, height; /* size of image tile */ - unsigned x0, y0; /* NW corner of image tile */ - - locate_subimage (level, level - tiling->exponent, address, - &x0, &y0, &width, &height); - if (x0 < image->width && y0 < image->height) /* valid range */ - { - if (x0 + width > image->width) /* outside image area */ - width = image->width - x0; - if (y0 + height > image->height) /* outside image area */ - height = image->height - y0; - - var_list [number].variance - = variance (image->pixels [GRAY], x0, y0, - width, height, image->width); - var_list [number].address = address; - number++; - tile_valid [address] = YES; - } - else - tile_valid [address] = NO; - } - - /* - * Sort image tiles according to sign of 'tiling->exp' - */ - if (tiling->method == FIASCO_TILING_VARIANCE_DSC) - qsort (var_list, number, sizeof (var_list_t), cmpdecvar); - else - qsort (var_list, number, sizeof (var_list_t), cmpincvar); - - for (number = 0, address = 0; address < tiles; address++) - if (tile_valid [address]) - { - tiling->vorder [address] = var_list [number].address; - number++; - debug_message ("tile number %d has original address %d", - number, tiling->vorder [address]); - } - else - tiling->vorder [address] = -1; - - Free (var_list); + unsigned address; /* bintree address of tile */ + 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); + var_list_t *var_list = Calloc (tiles, sizeof (var_list_t)); + + /* + * Compute variances of image tiles + */ + for (number = 0, address = 0; address < tiles; address++) + { + unsigned width, height; /* size of image tile */ + unsigned x0, y0; /* NW corner of image tile */ + + locate_subimage (level, level - tiling->exponent, address, + &x0, &y0, &width, &height); + if (x0 < image->width && y0 < image->height) /* valid range */ + { + if (x0 + width > image->width) /* outside image area */ + width = image->width - x0; + if (y0 + height > image->height) /* outside image area */ + height = image->height - y0; + + var_list [number].variance + = variance (image->pixels [GRAY], x0, y0, + width, height, image->width); + var_list [number].address = address; + number++; + tile_valid [address] = YES; + } + else + tile_valid [address] = NO; + } + + /* + * Sort image tiles according to sign of 'tiling->exp' + */ + if (tiling->method == FIASCO_TILING_VARIANCE_DSC) + qsort (var_list, number, sizeof (var_list_t), cmpdecvar); + else + qsort (var_list, number, sizeof (var_list_t), cmpincvar); + + for (number = 0, address = 0; address < tiles; address++) + if (tile_valid [address]) + { + tiling->vorder [address] = var_list [number].address; + number++; + debug_message ("tile number %d has original address %d", + number, tiling->vorder [address]); + } + else + tiling->vorder [address] = -1; + + Free (var_list); } else if (tiling->method == FIASCO_TILING_SPIRAL_DSC - || tiling->method == FIASCO_TILING_SPIRAL_ASC) + || tiling->method == FIASCO_TILING_SPIRAL_ASC) { - compute_spiral (tiling->vorder, image->width, image->height, - tiling->exponent, - tiling->method == FIASCO_TILING_SPIRAL_ASC); + compute_spiral (tiling->vorder, image->width, image->height, + tiling->exponent, + tiling->method == FIASCO_TILING_SPIRAL_ASC); } else { - warning ("We do not know the tiling method.\n" - "Skipping image tiling step."); - tiling->exponent = 0; + warning ("We do not know the tiling method.\n" + "Skipping image tiling step."); + tiling->exponent = 0; } } } diff --git a/converter/other/fiasco/codec/tiling.h b/converter/other/fiasco/codec/tiling.h index 6668ad8b..ef6d426d 100644 --- a/converter/other/fiasco/codec/tiling.h +++ b/converter/other/fiasco/codec/tiling.h @@ -1,8 +1,8 @@ /* * tiling.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -22,17 +22,17 @@ typedef struct tiling { - unsigned exponent; /* Image is split in 2^exp tiles */ - fiasco_tiling_e method; /* Method of Image tiling */ - int *vorder; /* Block permutation (size = 2^exp) - -1 indicates empty block */ + unsigned exponent; /* Image is split in 2^exp tiles */ + fiasco_tiling_e method; /* Method of Image tiling */ + int *vorder; /* Block permutation (size = 2^exp) + -1 indicates empty block */ } tiling_t; void perform_tiling (const image_t *image, tiling_t *tiling); tiling_t * alloc_tiling (fiasco_tiling_e method, unsigned tiling_exponent, - unsigned image_level); + unsigned image_level); void free_tiling (tiling_t *tiling); diff --git a/converter/other/fiasco/codec/wfa.h b/converter/other/fiasco/codec/wfa.h index 4e66ccbd..ae86d216 100644 --- a/converter/other/fiasco/codec/wfa.h +++ b/converter/other/fiasco/codec/wfa.h @@ -1,7 +1,7 @@ /* * wfa.h * - * Written by: Ullrich Hafner + * Written by: Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -19,38 +19,38 @@ #define MAXEDGES 5 #define MAXSTATES 6000 -#define MAXLABELS 2 /* only bintree possible anymore */ +#define MAXLABELS 2 /* only bintree possible anymore */ #define MAXLEVEL 22 #define FIASCO_BINFILE_RELEASE 2 -#define FIASCO_MAGIC "FIASCO" /* FIASCO magic number */ +#define FIASCO_MAGIC "FIASCO" /* FIASCO magic number */ #define FIASCO_BASIS_MAGIC "Fiasco" /* FIASCO initial basis */ -#define NO_EDGE -1 -#define RANGE -1 -#define NO_RANGE 0 +#define NO_EDGE -1 +#define RANGE -1 +#define NO_RANGE 0 -#define CHILD 1 -#define LEAF 0 +#define CHILD 1 +#define LEAF 0 -#define MAX_PROB 9 -#define MIN_PROB 1 +#define MAX_PROB 9 +#define MIN_PROB 1 /* * WFA state types: - * 0: state is not allowed to be used in an - * approximation and it's image is not needed - * for ip computations. - * AUXILIARY_MASK: state is required for computation of ip's but is not - * allowed to be used in an approximation. - * USE_DOMAIN_MASK: state is allowed to be used in an approximation. + * 0: state is not allowed to be used in an + * approximation and it's image is not needed + * for ip computations. + * AUXILIARY_MASK: state is required for computation of ip's but is not + * allowed to be used in an approximation. + * USE_DOMAIN_MASK: state is allowed to be used in an approximation. */ enum state_types {AUXILIARY_MASK = 1 << 0, USE_DOMAIN_MASK = 1 << 1}; -#define isedge(x) ((x) != NO_EDGE) -#define isdomain(x) ((x) != NO_EDGE) -#define isrange(x) ((x) == RANGE) -#define ischild(x) ((x) != RANGE) +#define isedge(x) ((x) != NO_EDGE) +#define isdomain(x) ((x) != NO_EDGE) +#define isrange(x) ((x) == RANGE) +#define ischild(x) ((x) != RANGE) #define isauxiliary(d,wfa) ((wfa)->domain_type[d] & AUXILIARY_MASK) #define usedomain(d, wfa) ((wfa)->domain_type[d] & USE_DOMAIN_MASK) #define need_image(d,wfa) (isauxiliary ((d), (wfa)) || usedomain ((d), (wfa))) @@ -64,15 +64,15 @@ typedef struct mv * Motion vector components */ { - mc_type_e type; /* motion compensation type */ - int fx, fy; /* forward vector coordinates */ - int bx, by; /* backward vector coordinates */ + mc_type_e type; /* motion compensation type */ + int fx, fy; /* forward vector coordinates */ + int bx, by; /* backward vector coordinates */ } mv_t; typedef struct range_info { - unsigned x, y; /* coordinates of upper left corner */ - unsigned level; /* bintree level of range */ + unsigned x, y; /* coordinates of upper left corner */ + unsigned level; /* bintree level of range */ } range_info_t; #include "image.h" @@ -81,32 +81,32 @@ typedef struct range_info typedef struct wfa_info { - char *wfa_name; /* filename of the WFA */ - char *basis_name; /* filename of the initial basis */ - char *title; /* title of FIASCO stream */ - char *comment; /* comment for FIASCO stream */ - - unsigned max_states; /* max. cardinality of domain pool */ - unsigned chroma_max_states; /* max. cardinality of domain pool for - chroma band coding */ - bool_t color; /* color image */ - unsigned width; /* image width */ - unsigned height; /* image height */ - unsigned level; /* image level */ - rpf_t *rpf; /* Standard reduced precision format */ - rpf_t *dc_rpf; /* DC reduced precision format */ - rpf_t *d_rpf; /* Delta reduced precision format */ - rpf_t *d_dc_rpf; /* Delta DC reduced precision format */ - unsigned frames; /* number of frames in the video */ - unsigned fps; /* number of frames per second */ - unsigned p_min_level; /* min. level of prediction */ - unsigned p_max_level; /* max. level of prediction */ - unsigned search_range; /* motion vector interval */ - bool_t half_pixel; /* usage of half pixel precision */ - bool_t cross_B_search; /* usage of Cross-B-Search */ - bool_t B_as_past_ref; /* usage of B frames as ref's */ - unsigned smoothing; /* smoothing of image along borders */ - unsigned release; /* FIASCO file format release */ + char *wfa_name; /* filename of the WFA */ + char *basis_name; /* filename of the initial basis */ + char *title; /* title of FIASCO stream */ + char *comment; /* comment for FIASCO stream */ + + unsigned max_states; /* max. cardinality of domain pool */ + unsigned chroma_max_states; /* max. cardinality of domain pool for + chroma band coding */ + bool_t color; /* color image */ + unsigned width; /* image width */ + unsigned height; /* image height */ + unsigned level; /* image level */ + rpf_t *rpf; /* Standard reduced precision format */ + rpf_t *dc_rpf; /* DC reduced precision format */ + rpf_t *d_rpf; /* Delta reduced precision format */ + rpf_t *d_dc_rpf; /* Delta DC reduced precision format */ + unsigned frames; /* number of frames in the video */ + unsigned fps; /* number of frames per second */ + unsigned p_min_level; /* min. level of prediction */ + unsigned p_max_level; /* max. level of prediction */ + unsigned search_range; /* motion vector interval */ + bool_t half_pixel; /* usage of half pixel precision */ + bool_t cross_B_search; /* usage of Cross-B-Search */ + bool_t B_as_past_ref; /* usage of B frames as ref's */ + unsigned smoothing; /* smoothing of image along borders */ + unsigned release; /* FIASCO file format release */ } wfa_info_t; typedef struct wfa @@ -114,27 +114,27 @@ typedef struct wfa * Used to store all information and data structures of a WFA */ { - wfa_info_t *wfainfo; /* misc. information about the WFA */ - frame_type_e frame_type; /* intra, predicted, bi-directional */ - unsigned states; /* number of states */ - unsigned basis_states; /* number of states in the basis */ - unsigned root_state; /* root of the tree */ - 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: auxiliary state - Bit_1==1: used for Y compr */ - mv_t (*mv_tree)[MAXLABELS]; /* motion vectors */ - word_t (*tree)[MAXLABELS]; /* bintree partitioning */ - u_word_t (*x)[MAXLABELS]; /* range coordinate */ - u_word_t (*y)[MAXLABELS]; /* range coordinate */ - word_t (*into)[MAXLABELS][MAXEDGES + 1]; /* domain references */ - real_t (*weight)[MAXLABELS][MAXEDGES + 1]; /* lin.comb. coefficients */ - word_t (*int_weight)[MAXLABELS][MAXEDGES + 1]; /* bin. representation */ - word_t (*y_state)[MAXLABELS]; /* bintree of Y component */ - byte_t (*y_column)[MAXLABELS]; /* array for Y component references */ - byte_t (*prediction)[MAXLABELS]; /* DC prediction */ - bool_t (*delta_state); /* delta state */ + wfa_info_t *wfainfo; /* misc. information about the WFA */ + frame_type_e frame_type; /* intra, predicted, bi-directional */ + unsigned states; /* number of states */ + unsigned basis_states; /* number of states in the basis */ + unsigned root_state; /* root of the tree */ + 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: auxiliary state + Bit_1==1: used for Y compr */ + mv_t (*mv_tree)[MAXLABELS]; /* motion vectors */ + word_t (*tree)[MAXLABELS]; /* bintree partitioning */ + u_word_t (*x)[MAXLABELS]; /* range coordinate */ + u_word_t (*y)[MAXLABELS]; /* range coordinate */ + word_t (*into)[MAXLABELS][MAXEDGES + 1]; /* domain references */ + real_t (*weight)[MAXLABELS][MAXEDGES + 1]; /* lin.comb. coefficients */ + word_t (*int_weight)[MAXLABELS][MAXEDGES + 1]; /* bin. representation */ + word_t (*y_state)[MAXLABELS]; /* bintree of Y component */ + byte_t (*y_column)[MAXLABELS]; /* array for Y component references */ + byte_t (*prediction)[MAXLABELS]; /* DC prediction */ + bool_t (*delta_state); /* delta state */ } wfa_t; #endif /* not _WFA_H */ diff --git a/converter/other/fiasco/codec/wfalib.c b/converter/other/fiasco/codec/wfalib.c index 90420d6f..fd73092f 100644 --- a/converter/other/fiasco/codec/wfalib.c +++ b/converter/other/fiasco/codec/wfalib.c @@ -1,8 +1,8 @@ /* - * wfalib.c: Library functions both for encoding and decoding + * wfalib.c: Library functions both for encoding and decoding + * + * Written by: Ullrich Hafner * - * Written by: Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -35,8 +35,8 @@ /***************************************************************************** - prototypes - + prototypes + *****************************************************************************/ static unsigned @@ -44,8 +44,8 @@ xy_to_address (unsigned x, unsigned y, unsigned level, unsigned n); /***************************************************************************** - public code - + public code + *****************************************************************************/ wfa_t * @@ -56,11 +56,11 @@ alloc_wfa (bool_t coding) * Flag 'coding' indicates whether WFA is used for coding or decoding. * * Return value: - * pointer to the new WFA structure + * pointer to the new WFA structure */ { wfa_t *wfa = Calloc (1, sizeof (wfa_t)); - + /* * Allocate memory */ @@ -74,17 +74,17 @@ alloc_wfa (bool_t coding) wfa->mv_tree = Calloc (MAXSTATES * MAXLABELS, sizeof (mv_t)); wfa->y_state = Calloc (MAXSTATES * MAXLABELS, sizeof (word_t)); wfa->into = Calloc (MAXSTATES * MAXLABELS * (MAXEDGES + 1), - sizeof (word_t)); + sizeof (word_t)); wfa->weight = Calloc (MAXSTATES * MAXLABELS * (MAXEDGES + 1), - sizeof (real_t)); + sizeof (real_t)); wfa->int_weight = Calloc (MAXSTATES * MAXLABELS * (MAXEDGES + 1), - sizeof (word_t)); + sizeof (word_t)); wfa->wfainfo = Calloc (1, sizeof (wfa_info_t));; wfa->prediction = Calloc (MAXSTATES * MAXLABELS, sizeof (byte_t)); wfa->wfainfo->wfa_name = NULL; wfa->wfainfo->basis_name = NULL; - wfa->wfainfo->title = strdup (""); + wfa->wfainfo->title = strdup (""); wfa->wfainfo->comment = strdup (""); /* @@ -96,24 +96,24 @@ alloc_wfa (bool_t coding) wfa->states = 0; wfa->basis_states = 0; wfa->root_state = 0; - for (state = 0; state < MAXSTATES; state++) + for (state = 0; state < MAXSTATES; state++) { - wfa->final_distribution [state] = 0; - wfa->domain_type [state] = 0; - for (label = 0; label < MAXLABELS; label++) - { - wfa->into [state][label][0] = NO_EDGE; - wfa->tree [state][label] = RANGE; - wfa->y_state [state][label] = RANGE; - } + wfa->final_distribution [state] = 0; + wfa->domain_type [state] = 0; + for (label = 0; label < MAXLABELS; label++) + { + wfa->into [state][label][0] = NO_EDGE; + wfa->tree [state][label] = RANGE; + wfa->y_state [state][label] = RANGE; + } } } - if (coding) /* initialize additional variables */ + if (coding) /* initialize additional variables */ wfa->y_column = Calloc (MAXSTATES * MAXLABELS, sizeof (byte_t)); else wfa->y_column = NULL; - + return wfa; } @@ -126,7 +126,7 @@ free_wfa (wfa_t *wfa) * No return value. * * Side effects: - * 'wfa' struct is discarded. + * 'wfa' struct is discarded. */ { if (wfa->wfainfo->wfa_name) @@ -157,14 +157,14 @@ free_wfa (wfa_t *wfa) Free (wfa); } -real_t +real_t compute_final_distribution (unsigned state, const wfa_t *wfa) /* * Compute the final distribution of the given 'state'. * Uses the fact that the generated 'wfa' is average preserving. * * Return value: - * final distribution + * final distribution */ { unsigned label; @@ -174,14 +174,14 @@ compute_final_distribution (unsigned state, const wfa_t *wfa) { unsigned edge; int domain; - + if (ischild (domain = wfa->tree [state][label])) - final += wfa->final_distribution [domain]; + final += wfa->final_distribution [domain]; for (edge = 0; isedge (domain = wfa->into [state][label][edge]); edge++) - final += wfa->weight [state][label][edge] - * wfa->final_distribution [domain]; + final += wfa->weight [state][label][edge] + * wfa->final_distribution [domain]; } - + return final / MAXLABELS; } @@ -193,10 +193,10 @@ compute_hits (unsigned from, unsigned to, unsigned n, const wfa_t *wfa) * {i | 'from' <= i <= 'to'}. I.e. domains are in {i | from <= i < 'to'} * Always ensure that state 0 is among selected states even though from * may be > 0. - * + * * Return value: - * pointer to array of the most popular state images - * sorted by increasing state numbers and terminated by -1 + * pointer to array of the most popular state images + * sorted by increasing state numbers and terminated by -1 */ { word_t *domains; @@ -209,12 +209,12 @@ compute_hits (unsigned from, unsigned to, unsigned n, const wfa_t *wfa) hits [domain].value = domain; hits [domain].key = 0; } - + for (state = from; state <= to; state++) for (label = 0; label < MAXLABELS; label++) - for (edge = 0; isedge (domain = wfa->into [state][label][edge]); - edge++) - hits [domain].key++; + for (edge = 0; isedge (domain = wfa->into [state][label][edge]); + edge++) + hits [domain].key++; qsort (hits + 1, to - 1, sizeof (pair_t), sort_desc_pair); @@ -222,23 +222,23 @@ compute_hits (unsigned from, unsigned to, unsigned n, const wfa_t *wfa) domains = Calloc (n + 1, sizeof (word_t)); for (domain = 0; domain < (int) n && (!domain || hits [domain].key); - domain++) + domain++) domains [domain] = hits [domain].value; if (n != domain) debug_message ("Only %d domains have been used in the luminance.", - domain); + domain); n = domain; qsort (domains, n, sizeof (word_t), sort_asc_word); domains [n] = -1; - + Free (hits); - + return domains; } void append_edge (unsigned from, unsigned into, real_t weight, - unsigned label, wfa_t *wfa) + unsigned label, wfa_t *wfa) /* * Append an edge from state 'from' to state 'into' with * the given 'label' and 'weight' to the 'wfa'. @@ -246,10 +246,10 @@ append_edge (unsigned from, unsigned into, real_t weight, * No return value. * * Side effects: - * 'wfa' structure is changed. + * 'wfa' structure is changed. */ { - unsigned new; /* position of the new edge */ + unsigned new; /* position of the new edge */ unsigned edge; /* @@ -257,7 +257,7 @@ append_edge (unsigned from, unsigned into, real_t weight, * edges are sorted by increasing 'into' values */ for (new = 0; (isedge (wfa->into [from][label][new]) - && wfa->into [from][label][new] < (int) into); new++) + && wfa->into [from][label][new] < (int) into); new++) ; /* * Move the edges 'n' to position 'n+1', for n = max, ..., 'new' @@ -269,7 +269,7 @@ append_edge (unsigned from, unsigned into, real_t weight, wfa->into [from][label][edge] = wfa->into [from][label][edge - 1]; wfa->weight [from][label][edge] = wfa->weight [from][label][edge - 1]; wfa->int_weight [from][label][edge] - = wfa->int_weight [from][label][edge - 1]; + = wfa->int_weight [from][label][edge - 1]; } /* * Insert the new edge @@ -279,15 +279,15 @@ append_edge (unsigned from, unsigned into, real_t weight, wfa->int_weight [from][label][edge] = weight * 512 + 0.5; } -void +void remove_states (unsigned from, wfa_t *wfa) -/* +/* * Remove 'wfa' states 'wfa->basis_states',...,'wfa->states' - 1. * * No return value. * * Side effects: - * 'wfa' structure is cleared for the given states. + * 'wfa' structure is cleared for the given states. */ { unsigned state; @@ -295,18 +295,18 @@ remove_states (unsigned from, wfa_t *wfa) for (state = from; state < wfa->states; state++) { unsigned label; - - for (label = 0; label < MAXLABELS; label++) + + for (label = 0; label < MAXLABELS; label++) { - wfa->into [state][label][0] = NO_EDGE; - wfa->tree [state][label] = RANGE; - wfa->prediction [state][label] = FALSE; - wfa->y_state [state][label] = RANGE; - wfa->mv_tree [state][label].type = NONE; - wfa->mv_tree [state][label].fx = 0; - wfa->mv_tree [state][label].fy = 0; - wfa->mv_tree [state][label].bx = 0; - wfa->mv_tree [state][label].by = 0; + wfa->into [state][label][0] = NO_EDGE; + wfa->tree [state][label] = RANGE; + wfa->prediction [state][label] = FALSE; + wfa->y_state [state][label] = RANGE; + wfa->mv_tree [state][label].type = NONE; + wfa->mv_tree [state][label].fx = 0; + wfa->mv_tree [state][label].fy = 0; + wfa->mv_tree [state][label].bx = 0; + wfa->mv_tree [state][label].by = 0; } wfa->domain_type [state] = 0; wfa->delta_state [state] = FALSE; @@ -323,7 +323,7 @@ copy_wfa (wfa_t *dst, const wfa_t *src) * No return value. * * Side effects: - * 'dst' is filled with same data as 'src' + * 'dst' is filled with same data as 'src' * * NOTE: size of WFA 'dst' must be at least size of WFA 'src' */ @@ -339,11 +339,11 @@ copy_wfa (wfa_t *dst, const wfa_t *src) memset (dst->y, 0, MAXSTATES * MAXLABELS * sizeof (word_t)); memset (dst->y_state, 0, MAXSTATES * MAXLABELS * sizeof (word_t)); memset (dst->into, NO_EDGE, - MAXSTATES * MAXLABELS * (MAXEDGES + 1) * sizeof (word_t)); + MAXSTATES * MAXLABELS * (MAXEDGES + 1) * sizeof (word_t)); memset (dst->weight, 0, - MAXSTATES * MAXLABELS * (MAXEDGES + 1) * sizeof (real_t)); + MAXSTATES * MAXLABELS * (MAXEDGES + 1) * sizeof (real_t)); memset (dst->int_weight, 0, - MAXSTATES * MAXLABELS * (MAXEDGES + 1) * sizeof (word_t)); + MAXSTATES * MAXLABELS * (MAXEDGES + 1) * sizeof (word_t)); memset (dst->prediction, 0, MAXSTATES * MAXLABELS * sizeof (byte_t)); memset (dst->delta_state, 0, MAXSTATES * sizeof (bool_t)); if (dst->y_column) @@ -352,62 +352,62 @@ copy_wfa (wfa_t *dst, const wfa_t *src) for (state = 0; state < MAXSTATES; state++) /* clear WFA struct */ { unsigned label; - + for (label = 0; label < MAXLABELS; label++) { - dst->into [state][label][0] = NO_EDGE; - dst->tree [state][label] = RANGE; - dst->mv_tree [state][label].type = NONE; - dst->y_state[state][label] = RANGE; + dst->into [state][label][0] = NO_EDGE; + dst->tree [state][label] = RANGE; + dst->mv_tree [state][label].type = NONE; + dst->y_state[state][label] = RANGE; } dst->delta_state [state] = NO; dst->domain_type [state] = 0; } - + dst->frame_type = src->frame_type; - dst->states = src->states; + dst->states = src->states; dst->basis_states = src->basis_states; dst->root_state = src->root_state; memcpy (dst->wfainfo, src->wfainfo, sizeof (wfa_info_t)); - if (dst->states == 0) /* nothing to do */ + if (dst->states == 0) /* nothing to do */ return; memcpy (dst->final_distribution, src->final_distribution, - src->states * sizeof (real_t)); + src->states * sizeof (real_t)); memcpy (dst->level_of_state, src->level_of_state, - src->states * sizeof (byte_t)); + src->states * sizeof (byte_t)); memcpy (dst->domain_type, src->domain_type, - src->states * sizeof (byte_t)); + src->states * sizeof (byte_t)); memcpy (dst->delta_state, src->delta_state, - src->states * sizeof (bool_t)); + src->states * sizeof (bool_t)); memcpy (dst->mv_tree, src->mv_tree, - src->states * MAXLABELS * sizeof (mv_t)); + src->states * MAXLABELS * sizeof (mv_t)); memcpy (dst->tree, src->tree, - src->states * MAXLABELS * sizeof (word_t)); + src->states * MAXLABELS * sizeof (word_t)); memcpy (dst->x, src->x, - src->states * MAXLABELS * sizeof (word_t)); + src->states * MAXLABELS * sizeof (word_t)); memcpy (dst->y, src->y, - src->states * MAXLABELS * sizeof (word_t)); + src->states * MAXLABELS * sizeof (word_t)); memcpy (dst->y_state, src->y_state, - src->states * MAXLABELS * sizeof (word_t)); + src->states * MAXLABELS * sizeof (word_t)); memcpy (dst->into, src->into, - src->states * MAXLABELS * (MAXEDGES + 1) * sizeof (word_t)); + src->states * MAXLABELS * (MAXEDGES + 1) * sizeof (word_t)); memcpy (dst->weight, src->weight, - src->states * MAXLABELS * (MAXEDGES + 1) * sizeof (real_t)); + src->states * MAXLABELS * (MAXEDGES + 1) * sizeof (real_t)); memcpy (dst->int_weight, src->int_weight, - src->states * MAXLABELS * (MAXEDGES + 1) * sizeof (word_t)); + src->states * MAXLABELS * (MAXEDGES + 1) * sizeof (word_t)); memcpy (dst->prediction, src->prediction, - src->states * MAXLABELS * sizeof (byte_t)); + src->states * MAXLABELS * sizeof (byte_t)); if (dst->y_column) memcpy (dst->y_column, src->y_column, - src->states * MAXLABELS * sizeof (byte_t)); + src->states * MAXLABELS * sizeof (byte_t)); } void locate_subimage (unsigned orig_level, unsigned level, unsigned bintree, - unsigned *x, unsigned *y, unsigned *width, unsigned *height) + unsigned *x, unsigned *y, unsigned *width, unsigned *height) /* * Compute pixel coordinates of the subimage which 'bintree' address is given. * The level of the original image is 'orig_level' and the level of the @@ -416,14 +416,14 @@ locate_subimage (unsigned orig_level, unsigned level, unsigned bintree, * No return value. * * Side effects: - * '*x', '*y' coordinates of the upper left corner - * '*width', '*height' size of image + * '*x', '*y' coordinates of the upper left corner + * '*width', '*height' size of image */ { /* * Compute coordinates of the subimage */ - *x = *y = 0; /* start at NW corner */ + *x = *y = 0; /* start at NW corner */ *width = width_of_level (level); *height = height_of_level (level); @@ -439,31 +439,31 @@ locate_subimage (unsigned orig_level, unsigned level, unsigned bintree, } else if (level < orig_level) { - unsigned mask; /* mask for bintree -> xy conversion */ - bool_t hor; /* 1 next subdivision is horizontal - 0 next subdivision is vertical */ - unsigned l = orig_level - 1; /* current level */ - - hor = orig_level % 2; /* start with vertival subdivision - for square image and vice versa */ - + unsigned mask; /* mask for bintree -> xy conversion */ + bool_t hor; /* 1 next subdivision is horizontal + 0 next subdivision is vertical */ + unsigned l = orig_level - 1; /* current level */ + + hor = orig_level % 2; /* start with vertival subdivision + for square image and vice versa */ + for (mask = 1 << (orig_level - level - 1); mask; mask >>= 1, hor = !hor) { - if (bintree & mask) /* change coordinates */ - { - if (hor) /* horizontal subdivision */ - *y += height_of_level (l); - else /* vertical subdivision */ - *x += width_of_level (l); - } - l--; + if (bintree & mask) /* change coordinates */ + { + if (hor) /* horizontal subdivision */ + *y += height_of_level (l); + else /* vertical subdivision */ + *x += width_of_level (l); + } + l--; } } } void compute_spiral (int *vorder, unsigned image_width, unsigned image_height, - unsigned tiling_exp, bool_t inc_spiral) + unsigned tiling_exp, bool_t inc_spiral) /* * Compute image tiling with spiral order. * 'inc_spiral' specifies whether the spiral starts in the middle @@ -474,28 +474,28 @@ compute_spiral (int *vorder, unsigned image_width, unsigned image_height, * No return value. * * Side effects: - * vorder[] is filled with tiling permutation + * vorder[] is filled with tiling permutation */ { - unsigned x, y; /* current position */ - unsigned xmin, xmax, ymin, ymax; /* boundaries for current line */ - unsigned width, height; /* offset for each tile */ - unsigned lx, ly, level; /* level x and y */ - unsigned tiles; /* total number of tiles */ - unsigned address; /* bintree address */ - + unsigned x, y; /* current position */ + unsigned xmin, xmax, ymin, ymax; /* boundaries for current line */ + unsigned width, height; /* offset for each tile */ + unsigned lx, ly, level; /* level x and y */ + unsigned tiles; /* total number of tiles */ + unsigned address; /* bintree address */ + lx = log2 (image_width - 1) + 1; ly = log2 (image_height - 1) + 1; level = MAX(lx, ly) * 2 - ((ly == lx + 1) ? 1 : 0); - tiles = 1 << tiling_exp; /* Number of image tiles */ + tiles = 1 << tiling_exp; /* Number of image tiles */ width = width_of_level (level - tiling_exp); height = height_of_level (level - tiling_exp); for (address = 0; address < tiles; address++) { unsigned x0, y0, width, height; - + locate_subimage (level, level - tiling_exp, address, - &x0, &y0, &width, &height); + &x0, &y0, &width, &height); vorder [address] = (x0 < image_width && y0 < image_height) ? 0 : -1; } @@ -507,7 +507,7 @@ compute_spiral (int *vorder, unsigned image_width, unsigned image_height, /* * 1234 - * CDE5 Traverse image in spiral order + * CDE5 Traverse image in spiral order * BGF6 starting at the top left corner * A987 */ @@ -515,59 +515,59 @@ compute_spiral (int *vorder, unsigned image_width, unsigned image_height, { for (x = xmin, y = ymin; x < xmax; x += width) /* W>E */ { - while (vorder [address] == -1) - address++; - if (x < image_width && y < image_height) /* valid range */ - vorder [address++] = xy_to_address (x, y, level, tiling_exp); - while (address < tiles && vorder [address] == -1) - address++; + while (vorder [address] == -1) + address++; + if (x < image_width && y < image_height) /* valid range */ + vorder [address++] = xy_to_address (x, y, level, tiling_exp); + while (address < tiles && vorder [address] == -1) + address++; } ymin += height; if (address >= tiles) - break; - + break; + for (x = xmax - width, y = ymin; y < ymax; y += height) /* N>S */ { - while (vorder [address] == -1) - address++; - if (x <= image_width && y <= image_height) /* valid range */ - vorder [address++] = xy_to_address (x, y, level, tiling_exp); - while (address < tiles && vorder [address] == -1) - address++; + while (vorder [address] == -1) + address++; + if (x <= image_width && y <= image_height) /* valid range */ + vorder [address++] = xy_to_address (x, y, level, tiling_exp); + while (address < tiles && vorder [address] == -1) + address++; } xmax -= width; if (address >= tiles) - break; + break; for (x = xmax - width, y = ymax - width; x >= xmin; x -= width) /* E<W */ { - while (vorder [address] == -1) - address++; - if (x <= image_width && y <= image_height) /* valid range */ - vorder [address++] = xy_to_address (x, y, level, tiling_exp); - while (address < tiles && vorder [address] == -1) - address++; + while (vorder [address] == -1) + address++; + if (x <= image_width && y <= image_height) /* valid range */ + vorder [address++] = xy_to_address (x, y, level, tiling_exp); + while (address < tiles && vorder [address] == -1) + address++; } ymax -= height; if (address >= tiles) - break; + break; - for (x = xmin, y = ymax - height; y >= ymin; y -= height) /* S>N */ + for (x = xmin, y = ymax - height; y >= ymin; y -= height) /* S>N */ { - while (vorder [address] == -1) - address++; - if (x <= image_width && y <= image_height) /* valid range */ - vorder [address++] = xy_to_address (x, y, level, tiling_exp); - while (address < tiles && vorder [address] == -1) - address++; + while (vorder [address] == -1) + address++; + if (x <= image_width && y <= image_height) /* valid range */ + vorder [address++] = xy_to_address (x, y, level, tiling_exp); + while (address < tiles && vorder [address] == -1) + address++; } xmin += width; - + if (address >= tiles) - break; + break; } if (inc_spiral) @@ -576,18 +576,18 @@ compute_spiral (int *vorder, unsigned image_width, unsigned image_height, while (i < j) { - int tmp; - - while (vorder [i] == -1) - i++; - while (vorder [j] == -1) - j--; - - tmp = vorder [i]; - vorder [i] = vorder [j]; - vorder [j] = tmp; - i++; - j--; + int tmp; + + while (vorder [i] == -1) + i++; + while (vorder [j] == -1) + j--; + + tmp = vorder [i]; + vorder [i] = vorder [j]; + vorder [j] = tmp; + i++; + j--; } } /* @@ -595,109 +595,109 @@ compute_spiral (int *vorder, unsigned image_width, unsigned image_height, */ { unsigned number; - + for (number = 0, address = 0; address < tiles; address++) - if (vorder [address] != -1) - debug_message ("number %d: address %d", - number++, vorder [address]); + if (vorder [address] != -1) + debug_message ("number %d: address %d", + number++, vorder [address]); } } bool_t find_range (unsigned x, unsigned y, unsigned band, - const wfa_t *wfa, unsigned *range_state, unsigned *range_label) + const wfa_t *wfa, unsigned *range_state, unsigned *range_label) /* * Find a range ('*range_state', '*range_label') that contains * pixel ('x', 'y') in the iven color 'band'. * * Return value: - * TRUE on success, or FALSE if there is no such range + * TRUE on success, or FALSE if there is no such range * * Side effects: - * '*range_state' and '*range_label' are modified on success. + * '*range_state' and '*range_label' are modified on success. */ { unsigned state, label; unsigned first_state, last_state; bool_t success = NO; - + first_state = wfa->basis_states; last_state = wfa->states; if (wfa->wfainfo->color) switch (band) { - case Y: - first_state = wfa->basis_states; - last_state = wfa->tree [wfa->tree [wfa->root_state][0]][0]; - break; - case Cb: - first_state = wfa->tree [wfa->tree [wfa->root_state][0]][0] + 1; - last_state = wfa->tree [wfa->tree [wfa->root_state][0]][1]; - break; - case Cr: - first_state = wfa->tree [wfa->tree [wfa->root_state][0]][1] + 1; - last_state = wfa->states; - break; - default: - error ("unknown color component."); + case Y: + first_state = wfa->basis_states; + last_state = wfa->tree [wfa->tree [wfa->root_state][0]][0]; + break; + case Cb: + first_state = wfa->tree [wfa->tree [wfa->root_state][0]][0] + 1; + last_state = wfa->tree [wfa->tree [wfa->root_state][0]][1]; + break; + case Cr: + first_state = wfa->tree [wfa->tree [wfa->root_state][0]][1] + 1; + last_state = wfa->states; + break; + default: + error ("unknown color component."); } for (state = first_state; state < last_state; state++) for (label = 0; label < MAXLABELS; label++) - if (isrange (wfa->tree [state][label])) - if (x >= wfa->x [state][label] && y >= wfa->y [state][label] - && x < (unsigned) (wfa->x [state][label] - + width_of_level (wfa->level_of_state [state] - 1)) - && y < (unsigned) (wfa->y [state][label] - + height_of_level (wfa->level_of_state [state] - 1))) - { - success = YES; - *range_state = state; - *range_label = label; - - return success; - } + if (isrange (wfa->tree [state][label])) + if (x >= wfa->x [state][label] && y >= wfa->y [state][label] + && x < (unsigned) (wfa->x [state][label] + + width_of_level (wfa->level_of_state [state] - 1)) + && y < (unsigned) (wfa->y [state][label] + + height_of_level (wfa->level_of_state [state] - 1))) + { + success = YES; + *range_state = state; + *range_label = label; + + return success; + } return success; } void sort_ranges (unsigned state, unsigned *domain, - range_sort_t *rs, const wfa_t *wfa) + range_sort_t *rs, const wfa_t *wfa) /* * Generate list of ranges in coder order. * 'state' is the current state of the call tree while 'domain' is the * index of the last added WFA state. * * Side effects: - * 'domain' is incremented after recursion returns - * 'rs' is filled accordingly + * 'domain' is incremented after recursion returns + * 'rs' is filled accordingly * * No return value. */ { unsigned label; - + for (label = 0; label < MAXLABELS; label++) { if (isrange (wfa->tree [state][label])) - rs->range_subdivided [rs->range_no] = NO; + rs->range_subdivided [rs->range_no] = NO; else { - sort_ranges (wfa->tree [state][label], domain, rs, wfa); - rs->range_subdivided [rs->range_no] = YES; + sort_ranges (wfa->tree [state][label], domain, rs, wfa); + rs->range_subdivided [rs->range_no] = YES; } rs->range_state [rs->range_no] = state; rs->range_label [rs->range_no] = label; rs->range_max_domain [rs->range_no] = *domain; while (!usedomain (rs->range_max_domain [rs->range_no], wfa)) - rs->range_max_domain [rs->range_no]--; + rs->range_max_domain [rs->range_no]--; if (label == 1 || !rs->range_subdivided [rs->range_no]) - rs->range_no++; + rs->range_no++; } - + (*domain)++; } @@ -709,11 +709,11 @@ locate_delta_images (wfa_t *wfa) * via MC or ND. * * Return value: - * TRUE at least one state is part of a delta approximation - * FALSE no delta approximations in this WFA + * TRUE at least one state is part of a delta approximation + * FALSE no delta approximations in this WFA * * Side effects: - * 'wfa->delta [state][label]' is set accordingly. + * 'wfa->delta [state][label]' is set accordingly. */ { unsigned state, label; @@ -724,22 +724,22 @@ locate_delta_images (wfa_t *wfa) for (state = wfa->root_state; state >= wfa->basis_states; state--) for (label = 0; label < MAXLABELS; label++) - if (ischild (wfa->tree [state][label])) - if (wfa->mv_tree [state][label].type != NONE - || isedge (wfa->into [state][label][0]) - || wfa->delta_state [state]) - { - delta = YES; - wfa->delta_state [wfa->tree [state][label]] = YES; - } + if (ischild (wfa->tree [state][label])) + if (wfa->mv_tree [state][label].type != NONE + || isedge (wfa->into [state][label][0]) + || wfa->delta_state [state]) + { + delta = YES; + wfa->delta_state [wfa->tree [state][label]] = YES; + } return delta; } /***************************************************************************** - private code - + private code + ******************************************************************************/ static unsigned @@ -750,25 +750,25 @@ xy_to_address (unsigned x, unsigned y, unsigned level, unsigned n) * 'n' specifies number of iterations. * * Return value: - * address of subimage - */ -{ + * address of subimage + */ +{ unsigned address = 0; while (n--) { address <<= 1; - if (--level % 2) + if (--level % 2) { - if (x & width_of_level (level)) - address++; + if (x & width_of_level (level)) + address++; } else { - if (y & height_of_level (level)) - address++; + if (y & height_of_level (level)) + address++; } } - + return address; } diff --git a/converter/other/fiasco/codec/wfalib.h b/converter/other/fiasco/codec/wfalib.h index 5c1e0907..63723f30 100644 --- a/converter/other/fiasco/codec/wfalib.h +++ b/converter/other/fiasco/codec/wfalib.h @@ -1,8 +1,8 @@ /* * wfalib.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -34,26 +34,26 @@ bool_t locate_delta_images (wfa_t *wfa); void sort_ranges (unsigned state, unsigned *domain, - range_sort_t *rs, const wfa_t *wfa); + range_sort_t *rs, const wfa_t *wfa); bool_t find_range (unsigned x, unsigned y, unsigned band, - const wfa_t *wfa, unsigned *range_state, unsigned *range_label); + const wfa_t *wfa, unsigned *range_state, unsigned *range_label); void compute_spiral (int *vorder, unsigned image_width, unsigned image_height, - unsigned tiling_exp, bool_t inc_spiral); + unsigned tiling_exp, bool_t inc_spiral); void locate_subimage (unsigned orig_level, unsigned level, unsigned bintree, - unsigned *x, unsigned *y, unsigned *width, unsigned *height); + unsigned *x, unsigned *y, unsigned *width, unsigned *height); void copy_wfa (wfa_t *dst, const wfa_t *src); -void +void remove_states (unsigned from, wfa_t *wfa); void append_edge (unsigned from, unsigned into, real_t weight, - unsigned label, wfa_t *wfa); + unsigned label, wfa_t *wfa); word_t * compute_hits (unsigned from, unsigned to, unsigned n, const wfa_t *wfa); -real_t +real_t compute_final_distribution (unsigned state, const wfa_t *wfa); wfa_t * alloc_wfa (bool_t coding); diff --git a/converter/other/fiasco/display.c b/converter/other/fiasco/display.c index d8d32fa6..5eed6aeb 100644 --- a/converter/other/fiasco/display.c +++ b/converter/other/fiasco/display.c @@ -1,11 +1,11 @@ /* - * display.c: X11 display of frames + * display.c: X11 display of frames + * + * Written by: Ullrich Hafner * - * Written by: Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner - * + * * Based on mpeg2decode, (C) 1994, MPEG Software Simulation Group * and mpeg2play, (C) 1994 Stefan Eckart * <stefan@lis.e-technik.tu-muenchen.de> @@ -37,8 +37,8 @@ /***************************************************************************** - shared memory functions (if USE_SHM is defined) - + shared memory functions (if USE_SHM is defined) + *****************************************************************************/ #ifdef USE_SHM @@ -64,16 +64,16 @@ InstallXErrorHandler (x11_info_t *xinfo); static void DeInstallXErrorHandler (x11_info_t *xinfo); -static int shmem_flag; -static XShmSegmentInfo shminfo1, shminfo2; -static int gXErrorFlag; -static int CompletionType = -1; +static int shmem_flag; +static XShmSegmentInfo shminfo1, shminfo2; +static int gXErrorFlag; +static int CompletionType = -1; static int HandleXError (Display *dpy, XErrorEvent *event) { gXErrorFlag = 1; - + return 0; } @@ -95,21 +95,21 @@ DeInstallXErrorHandler (x11_info_t *xinfo) /***************************************************************************** - public code - + public code + *****************************************************************************/ void display_image (unsigned x0, unsigned y0, x11_info_t *xinfo) /* * Display 'image' at pos ('x0', 'y0') in the current window - * (given by 'xinfo->window'). + * (given by 'xinfo->window'). * * No return value. */ { int byte_order_check = 1; - + /* * Always work in native bit and byte order. This tells Xlib to * reverse bit and byte order if necessary when crossing a @@ -125,28 +125,28 @@ display_image (unsigned x0, unsigned y0, x11_info_t *xinfo) { xinfo->ximage->byte_order = MSBFirst; xinfo->ximage->bitmap_bit_order = MSBFirst; - } + } /* Display dithered image */ #ifdef USE_SHM if (shmem_flag) { XEvent xev; - + XShmPutImage (xinfo->display, xinfo->window, xinfo->gc, xinfo->ximage, - 0, 0, x0, y0, xinfo->ximage->width, xinfo->ximage->height, - True); + 0, 0, x0, y0, xinfo->ximage->width, xinfo->ximage->height, + True); XFlush (xinfo->display); - + while (!XCheckTypedEvent (xinfo->display, CompletionType, &xev)) - ; + ; } - else + else #endif /* USE_SHM */ { - xinfo->ximage->data = (char *) xinfo->pixels; + xinfo->ximage->data = (char *) xinfo->pixels; XPutImage (xinfo->display, xinfo->window, xinfo->gc, xinfo->ximage, 0, 0, - x0, y0, xinfo->ximage->width, xinfo->ximage->height); + x0, y0, xinfo->ximage->width, xinfo->ximage->height); } } @@ -177,7 +177,7 @@ close_window (x11_info_t *xinfo) x11_info_t * open_window (const char *titlename, const char *iconname, - unsigned width, unsigned height) + unsigned width, unsigned height) /* * Open a X11 window of size 'width'x'height'. * If 'color' is false then allocate a colormap with grayscales. @@ -185,20 +185,20 @@ open_window (const char *titlename, const char *iconname, * respectively. * * Return value: - * X11 info struct containing display, gc, window ID and colormap. + * X11 info struct containing display, gc, window ID and colormap. */ { - XVisualInfo visual_template; /* template for XGetVisualInfo() */ - XVisualInfo visual_info; /* return value of XGetVisualInfo() */ - int visual_n; /* # of matches of XGetVisualInfo */ - XEvent xev; - XSizeHints hint; - XSetWindowAttributes xswa; - unsigned int fg, bg; /* foreground and background color */ - unsigned int mask; /* event mask */ - x11_info_t *xinfo = calloc (1, sizeof (x11_info_t)); + XVisualInfo visual_template; /* template for XGetVisualInfo() */ + XVisualInfo visual_info; /* return value of XGetVisualInfo() */ + int visual_n; /* # of matches of XGetVisualInfo */ + XEvent xev; + XSizeHints hint; + XSetWindowAttributes xswa; + unsigned int fg, bg; /* foreground and background color */ + unsigned int mask; /* event mask */ + x11_info_t *xinfo = calloc (1, sizeof (x11_info_t)); long visual_mask; - + if (!xinfo) error ("Out of memory"); /* @@ -207,32 +207,32 @@ open_window (const char *titlename, const char *iconname, xinfo->display = XOpenDisplay (NULL); if (xinfo->display == NULL) error ("Can't open display.\n" - "Make sure that your environment variable DISPLAY " - "is set correctly."); + "Make sure that your environment variable DISPLAY " + "is set correctly."); xinfo->screen = DefaultScreen (xinfo->display); xinfo->gc = DefaultGC (xinfo->display, xinfo->screen); { - unsigned depth [] = {32, 24, 16}; - int class [] = {TrueColor, PseudoColor}; + unsigned depth [] = {32, 24, 16}; + int class [] = {TrueColor, PseudoColor}; const char *class_text [] = {"TrueColor", "PseudoColor"}; - Status found = 0; + Status found = 0; unsigned d, c; for (d = 0; !found && d < sizeof (depth) / sizeof (unsigned); d++) - for (c = 0; !found && c < sizeof (class) / sizeof (int); c++) - { - found = XMatchVisualInfo (xinfo->display, xinfo->screen, - depth [d], class [c], &visual_info); - if (found) - fprintf (stderr, "%s : %d bit colordepth.\n", - class_text [c], depth [d]); - } + for (c = 0; !found && c < sizeof (class) / sizeof (int); c++) + { + found = XMatchVisualInfo (xinfo->display, xinfo->screen, + depth [d], class [c], &visual_info); + if (found) + fprintf (stderr, "%s : %d bit colordepth.\n", + class_text [c], depth [d]); + } if (!found && fiasco_get_verbosity ()) - error ("Can't find a 16/24/32 bit TrueColor/DirectColor display"); + error ("Can't find a 16/24/32 bit TrueColor/DirectColor display"); } - + /* Width and height of the display window */ hint.x = hint.y = 0; hint.min_width = hint.max_width = hint.width = width; @@ -249,22 +249,22 @@ open_window (const char *titlename, const char *iconname, { mask |= CWColormap; xswa.colormap = XCreateColormap (xinfo->display, - DefaultRootWindow (xinfo->display), - visual_info.visual, AllocNone); + DefaultRootWindow (xinfo->display), + visual_info.visual, AllocNone); } xswa.background_pixel = bg; xswa.border_pixel = fg; xinfo->window = XCreateWindow (xinfo->display, - DefaultRootWindow (xinfo->display), 0, 0, - width, height, 1, visual_info.depth, - InputOutput, visual_info.visual, - mask, &xswa); + DefaultRootWindow (xinfo->display), 0, 0, + width, height, 1, visual_info.depth, + InputOutput, visual_info.visual, + mask, &xswa); XSelectInput (xinfo->display, xinfo->window, StructureNotifyMask); /* Tell other applications about this window */ XSetStandardProperties (xinfo->display, xinfo->window, titlename, iconname, - None, NULL, 0, &hint); + None, NULL, 0, &hint); /* Map window. */ XMapWindow (xinfo->display, xinfo->window); @@ -290,23 +290,23 @@ alloc_ximage (x11_info_t *xinfo, unsigned width, unsigned height) * No return value. * * Side effects: - * 'ximage->ximage' and 'ximage->pixels' are set to useful values. + * 'ximage->ximage' and 'ximage->pixels' are set to useful values. */ { char dummy; - + #ifdef USE_SHM if (XShmQueryExtension(xinfo->display)) { if (fiasco_get_verbosity ()) - fprintf (stderr, "Trying shared memory.\n"); + fprintf (stderr, "Trying shared memory.\n"); shmem_flag = 1; } else { shmem_flag = 0; if (fiasco_get_verbosity ()) - fprintf (stderr, + fprintf (stderr, "Shared memory does not work on this system\n" "Reverting to normal Xlib.\n"); } @@ -319,34 +319,34 @@ alloc_ximage (x11_info_t *xinfo, unsigned width, unsigned height) if (shmem_flag) { xinfo->ximage = XShmCreateImage (xinfo->display, - DefaultVisual (xinfo->display, - xinfo->screen), - DefaultDepth (xinfo->display, - xinfo->screen), ZPixmap, - NULL, &shminfo1, width, height); + DefaultVisual (xinfo->display, + xinfo->screen), + DefaultDepth (xinfo->display, + xinfo->screen), ZPixmap, + NULL, &shminfo1, width, height); /* If no go, then revert to normal Xlib calls. */ if (xinfo->ximage == NULL) { - if (fiasco_get_verbosity ()) - fprintf (stderr, - "Shared memory error, disabling (Ximage error).\n"); - goto shmemerror; + if (fiasco_get_verbosity ()) + fprintf (stderr, + "Shared memory error, disabling (Ximage error).\n"); + goto shmemerror; } /* Success here, continue. */ shminfo1.shmid = shmget (IPC_PRIVATE, xinfo->ximage->bytes_per_line - * xinfo->ximage->height, IPC_CREAT | 0777); + * xinfo->ximage->height, IPC_CREAT | 0777); if (shminfo1.shmid < 0) { - XDestroyImage (xinfo->ximage); - if (fiasco_get_verbosity ()) - fprintf (stderr, - "Shared memory error, disabling (seg id error).\n"); - goto shmemerror; + XDestroyImage (xinfo->ximage); + if (fiasco_get_verbosity ()) + fprintf (stderr, + "Shared memory error, disabling (seg id error).\n"); + goto shmemerror; } shminfo1.shmaddr = (char *) shmat (shminfo1.shmid, 0, 0); @@ -354,13 +354,13 @@ alloc_ximage (x11_info_t *xinfo, unsigned width, unsigned height) if (shminfo1.shmaddr == ((char *) -1)) { - XDestroyImage (xinfo->ximage); - if (shminfo1.shmaddr != ((char *) -1)) - shmdt (shminfo1.shmaddr); - if (fiasco_get_verbosity ()) - fprintf (stderr, - "Shared memory error, disabling (address error).\n"); - goto shmemerror; + XDestroyImage (xinfo->ximage); + if (shminfo1.shmaddr != ((char *) -1)) + shmdt (shminfo1.shmaddr); + if (fiasco_get_verbosity ()) + fprintf (stderr, + "Shared memory error, disabling (address error).\n"); + goto shmemerror; } xinfo->ximage->data = shminfo1.shmaddr; @@ -372,18 +372,18 @@ alloc_ximage (x11_info_t *xinfo, unsigned width, unsigned height) if (gXErrorFlag) { - /* Ultimate failure here. */ - XDestroyImage (xinfo->ximage); - shmdt (shminfo1.shmaddr); - if (fiasco_get_verbosity ()) - fprintf (stderr, "Shared memory error, disabling.\n"); - gXErrorFlag = 0; - goto shmemerror; + /* Ultimate failure here. */ + XDestroyImage (xinfo->ximage); + shmdt (shminfo1.shmaddr); + if (fiasco_get_verbosity ()) + fprintf (stderr, "Shared memory error, disabling.\n"); + gXErrorFlag = 0; + goto shmemerror; } else - shmctl (shminfo1.shmid, IPC_RMID, 0); + shmctl (shminfo1.shmid, IPC_RMID, 0); if (fiasco_get_verbosity ()) - fprintf (stderr, "Sharing memory.\n"); + fprintf (stderr, "Sharing memory.\n"); } else { @@ -392,19 +392,19 @@ alloc_ximage (x11_info_t *xinfo, unsigned width, unsigned height) #endif /* USE_SHM */ xinfo->ximage = XCreateImage (xinfo->display, - DefaultVisual (xinfo->display, - xinfo->screen), - DefaultDepth (xinfo->display, - xinfo->screen), - ZPixmap, 0, &dummy, width, height, 8, 0); + DefaultVisual (xinfo->display, + xinfo->screen), + DefaultDepth (xinfo->display, + xinfo->screen), + ZPixmap, 0, &dummy, width, height, 8, 0); xinfo->pixels = calloc (width * height, - xinfo->ximage->depth <= 8 - ? sizeof (byte_t) - : (xinfo->ximage->depth <= 16 - ? sizeof (u_word_t) : sizeof (unsigned int))); + xinfo->ximage->depth <= 8 + ? sizeof (byte_t) + : (xinfo->ximage->depth <= 16 + ? sizeof (u_word_t) : sizeof (unsigned int))); if (!xinfo->pixels) - error ("Out of memory."); - + error ("Out of memory."); + #ifdef USE_SHM } diff --git a/converter/other/fiasco/display.h b/converter/other/fiasco/display.h index 8049456a..0f9c53dc 100644 --- a/converter/other/fiasco/display.h +++ b/converter/other/fiasco/display.h @@ -1,8 +1,8 @@ /* * display.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -27,10 +27,10 @@ typedef struct x11_info { Display *display; - int screen; /* default screen number */ - Window window; + int screen; /* default screen number */ + Window window; XImage *ximage; - GC gc; + GC gc; byte_t *pixels; } x11_info_t; @@ -40,7 +40,7 @@ void close_window (x11_info_t *xinfo); x11_info_t * open_window (const char *titlename, const char *iconname, - unsigned width, unsigned height); + unsigned width, unsigned height); void alloc_ximage (x11_info_t *xinfo, unsigned width, unsigned height); diff --git a/converter/other/fiasco/fiasco.h b/converter/other/fiasco/fiasco.h index 88f999fc..48226c47 100644 --- a/converter/other/fiasco/fiasco.h +++ b/converter/other/fiasco/fiasco.h @@ -1,8 +1,8 @@ /* - * fiasco.h + * fiasco.h + * + * Written by: Ullrich Hafner * - * Written by: Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner * @@ -46,7 +46,7 @@ __BEGIN_DECLS /**************************************************************************** - FIASCO data types + FIASCO data types ****************************************************************************/ /* @@ -56,9 +56,9 @@ __BEGIN_DECLS * FIASCO_ULTIMATE_VERBOSITY: Show debugging output */ typedef enum {FIASCO_NO_VERBOSITY, - FIASCO_SOME_VERBOSITY, - FIASCO_ULTIMATE_VERBOSITY} fiasco_verbosity_e; - + FIASCO_SOME_VERBOSITY, + FIASCO_ULTIMATE_VERBOSITY} fiasco_verbosity_e; + /* * Image tiling methods: * VARIANCE_ASC: Tiles are sorted by variance. @@ -71,9 +71,9 @@ typedef enum {FIASCO_NO_VERBOSITY, * in the upper left corner. */ typedef enum {FIASCO_TILING_SPIRAL_ASC, - FIASCO_TILING_SPIRAL_DSC, - FIASCO_TILING_VARIANCE_ASC, - FIASCO_TILING_VARIANCE_DSC} fiasco_tiling_e; + FIASCO_TILING_SPIRAL_DSC, + FIASCO_TILING_VARIANCE_ASC, + FIASCO_TILING_VARIANCE_DSC} fiasco_tiling_e; /* * Range of reduced precision format: @@ -83,29 +83,29 @@ typedef enum {FIASCO_TILING_SPIRAL_ASC, * FIASCO_RPF_RANGE_2_00: use interval [-2.00,2.00] */ typedef enum {FIASCO_RPF_RANGE_0_75, - FIASCO_RPF_RANGE_1_00, - FIASCO_RPF_RANGE_1_50, - FIASCO_RPF_RANGE_2_00} fiasco_rpf_range_e; + FIASCO_RPF_RANGE_1_00, + FIASCO_RPF_RANGE_1_50, + FIASCO_RPF_RANGE_2_00} fiasco_rpf_range_e; /* * Type of progress meter to be used during coding * FIASCO_PROGRESS_NONE: no output at all - * FIASCO_PROGRESS_BAR: RPM style progress bar using 50 hash marks ###### - * FIASCO_PROGRESS_PERCENT: percentage meter 50% + * FIASCO_PROGRESS_BAR: RPM style progress bar using 50 hash marks ###### + * FIASCO_PROGRESS_PERCENT: percentage meter 50% */ typedef enum {FIASCO_PROGRESS_NONE, - FIASCO_PROGRESS_BAR, - FIASCO_PROGRESS_PERCENT} fiasco_progress_e; + FIASCO_PROGRESS_BAR, + FIASCO_PROGRESS_PERCENT} fiasco_progress_e; /* * Class to encapsulate FIASCO images. */ typedef struct fiasco_image { - void (*delete) (struct fiasco_image *image); - unsigned (*get_width) (struct fiasco_image *image); - unsigned (*get_height) (struct fiasco_image *image); - int (*is_color) (struct fiasco_image *image); + void (*delete) (struct fiasco_image *image); + unsigned (*get_width) (struct fiasco_image *image); + unsigned (*get_height) (struct fiasco_image *image); + int (*is_color) (struct fiasco_image *image); void *private; } fiasco_image_t; @@ -114,17 +114,17 @@ typedef struct fiasco_image */ typedef struct fiasco_decoder { - int (*delete) (struct fiasco_decoder *decoder); - int (*write_frame) (struct fiasco_decoder *decoder, - const char *filename); - fiasco_image_t * (*get_frame) (struct fiasco_decoder *decoder); - unsigned (*get_length) (struct fiasco_decoder *decoder); - unsigned (*get_rate) (struct fiasco_decoder *decoder); - unsigned (*get_width) (struct fiasco_decoder *decoder); - unsigned (*get_height) (struct fiasco_decoder *decoder); - const char * (*get_title) (struct fiasco_decoder *decoder); - const char * (*get_comment) (struct fiasco_decoder *decoder); - int (*is_color) (struct fiasco_decoder *decoder); + int (*delete) (struct fiasco_decoder *decoder); + int (*write_frame) (struct fiasco_decoder *decoder, + const char *filename); + fiasco_image_t * (*get_frame) (struct fiasco_decoder *decoder); + unsigned (*get_length) (struct fiasco_decoder *decoder); + unsigned (*get_rate) (struct fiasco_decoder *decoder); + unsigned (*get_width) (struct fiasco_decoder *decoder); + unsigned (*get_height) (struct fiasco_decoder *decoder); + const char * (*get_title) (struct fiasco_decoder *decoder); + const char * (*get_comment) (struct fiasco_decoder *decoder); + int (*is_color) (struct fiasco_decoder *decoder); void *private; } fiasco_decoder_t; @@ -135,43 +135,43 @@ typedef struct fiasco_c_options { void (*delete) (struct fiasco_c_options *options); int (*set_tiling) (struct fiasco_c_options *options, - fiasco_tiling_e method, - unsigned exponent); + fiasco_tiling_e method, + unsigned exponent); int (*set_frame_pattern) (struct fiasco_c_options *options, - const char *pattern); + const char *pattern); int (*set_basisfile) (struct fiasco_c_options *options, - const char *filename); + const char *filename); int (*set_chroma_quality) (struct fiasco_c_options *options, - float quality_factor, - unsigned dictionary_size); + float quality_factor, + unsigned dictionary_size); int (*set_optimizations) (struct fiasco_c_options *options, - unsigned min_block_level, - unsigned max_block_level, - unsigned max_elements, - unsigned dictionary_size, - unsigned optimization_level); + unsigned min_block_level, + unsigned max_block_level, + unsigned max_elements, + unsigned dictionary_size, + unsigned optimization_level); int (*set_prediction) (struct fiasco_c_options *options, - int intra_prediction, - unsigned min_block_level, - unsigned max_block_level); + int intra_prediction, + unsigned min_block_level, + unsigned max_block_level); int (*set_video_param) (struct fiasco_c_options *options, - unsigned frames_per_second, - int half_pixel_prediction, - int cross_B_search, - int B_as_past_ref); + unsigned frames_per_second, + int half_pixel_prediction, + int cross_B_search, + int B_as_past_ref); int (*set_quantization) (struct fiasco_c_options *options, - unsigned mantissa, - fiasco_rpf_range_e range, - unsigned dc_mantissa, - fiasco_rpf_range_e dc_range); + unsigned mantissa, + fiasco_rpf_range_e range, + unsigned dc_mantissa, + fiasco_rpf_range_e dc_range); int (*set_progress_meter) (struct fiasco_c_options *options, - fiasco_progress_e type); + fiasco_progress_e type); int (*set_smoothing) (struct fiasco_c_options *options, - int smoothing); + int smoothing); int (*set_comment) (struct fiasco_c_options *options, - const char *comment); + const char *comment); int (*set_title) (struct fiasco_c_options *options, - const char *title); + const char *title); void *private; } fiasco_c_options_t; @@ -182,32 +182,32 @@ typedef struct fiasco_d_options { void (*delete) (struct fiasco_d_options *options); int (*set_smoothing) (struct fiasco_d_options *options, - int smoothing); + int smoothing); int (*set_magnification) (struct fiasco_d_options *options, - int level); + int level); int (*set_4_2_0_format) (struct fiasco_d_options *options, - int format); + int format); void *private; } fiasco_d_options_t; /* * Class to convert internal FIASCO image structure to a XImage structure. - * Method `renderer()' is used to convert internal image to XImage. - * Method `delete()' is used to delete and free internal image. + * Method `renderer()' is used to convert internal image to XImage. + * Method `delete()' is used to delete and free internal image. */ typedef struct fiasco_renderer { int (*render) (const struct fiasco_renderer *this, - unsigned char *data, - const fiasco_image_t *fiasco_image); + unsigned char *data, + const fiasco_image_t *fiasco_image); void (*delete) (struct fiasco_renderer *this); void *private; } fiasco_renderer_t; /**************************************************************************** - miscellaneous functions + miscellaneous functions ****************************************************************************/ - + /* Get last error message of FIASCO library */ const char *fiasco_get_error_message (void); @@ -218,19 +218,19 @@ void fiasco_set_verbosity (fiasco_verbosity_e level); fiasco_verbosity_e fiasco_get_verbosity (void); /**************************************************************************** - decoder functions + decoder functions ****************************************************************************/ /* Decode FIASCO image or sequence */ fiasco_decoder_t *fiasco_decoder_new (const char *filename, - const fiasco_d_options_t *options); + const fiasco_d_options_t *options); /* Flush and discard FIASCO decoder */ int fiasco_decoder_delete (fiasco_decoder_t *decoder); /* Decode next FIASCO frame and write to PNM image 'filename' */ int fiasco_decoder_write_frame (fiasco_decoder_t *decoder, - const char *filename); + const char *filename); /* Decode next FIASCO frame to FIASCO image structure */ fiasco_image_t *fiasco_decoder_get_frame (fiasco_decoder_t *decoder); @@ -259,7 +259,7 @@ const char * fiasco_decoder_get_comment (fiasco_decoder_t *decoder); /**************************************************************************** - image functions + image functions ****************************************************************************/ /* Create FIASCO image (from PNM image file) */ @@ -275,7 +275,7 @@ fiasco_image_new_stream(FILE * const ifP, int const format); /* Discard FIASCO image */ -void fiasco_image_delete (fiasco_image_t *image); +void fiasco_image_delete (fiasco_image_t *image); /* Get width of FIASCO image or sequence */ unsigned fiasco_image_get_width (fiasco_image_t *image); @@ -287,14 +287,14 @@ unsigned fiasco_image_get_height (fiasco_image_t *image); int fiasco_image_is_color (fiasco_image_t *image); /**************************************************************************** - renderer functions + renderer functions ****************************************************************************/ /* Constructor of FIASCO image structure to a XImage renderer */ fiasco_renderer_t * fiasco_renderer_new (unsigned long red_mask, unsigned long green_mask, - unsigned long blue_mask, unsigned bpp, - int double_resolution); + unsigned long blue_mask, unsigned bpp, + int double_resolution); /* Destructor of FIASCO image structure to a XImage renderer */ void @@ -303,21 +303,21 @@ fiasco_renderer_delete (fiasco_renderer_t *renderer); /* FIASCO image structure to a XImage renderer */ int fiasco_renderer_render (const fiasco_renderer_t *renderer, - unsigned char *ximage, - const fiasco_image_t *fiasco_image); + unsigned char *ximage, + const fiasco_image_t *fiasco_image); /**************************************************************************** - coder functions + coder functions ****************************************************************************/ /* Encode image or sequence by FIASCO */ int fiasco_coder (char const * const *inputname, - const char *outputname, - float quality, - const fiasco_c_options_t *options); + const char *outputname, + float quality, + const fiasco_c_options_t *options); /**************************************************************************** - coder options functions + coder options functions ****************************************************************************/ /* FIASCO additional options constructor */ @@ -328,25 +328,25 @@ void fiasco_c_options_delete (fiasco_c_options_t *options); /* Define `smoothing'-percentage along partitioning borders.*/ int fiasco_c_options_set_smoothing (fiasco_c_options_t *options, - int smoothing); + int smoothing); /* Set type of frame prediction for sequence of frames */ int fiasco_c_options_set_frame_pattern (fiasco_c_options_t *options, - const char *pattern); + const char *pattern); /* Set method and number of tiles for image tiling */ int fiasco_c_options_set_tiling (fiasco_c_options_t *options, - fiasco_tiling_e method, - unsigned exponent); + fiasco_tiling_e method, + unsigned exponent); /* Set FIASCO initial basis file */ int fiasco_c_options_set_basisfile (fiasco_c_options_t *options, - const char *filename); + const char *filename); /* Set quality and dictionary size of chroma compression */ int fiasco_c_options_set_chroma_quality (fiasco_c_options_t *options, - float quality_factor, - unsigned dictionary_size); + float quality_factor, + unsigned dictionary_size); /* * Since FIASCO internally works with binary trees, all functions @@ -354,62 +354,62 @@ int fiasco_c_options_set_chroma_quality (fiasco_c_options_t *options, * the corresponding binary tree than the traditional `width' and * `height' arguments. Refer to following table to convert these * values: - * + * * level | width | height * ------+-------+-------- - * 0 | 1 | 1 - * 1 | 1 | 2 - * 2 | 2 | 2 - * 3 | 2 | 4 - * 4 | 4 | 4 - * 5 | 4 | 8 - * 6 | 8 | 8 + * 0 | 1 | 1 + * 1 | 1 | 2 + * 2 | 2 | 2 + * 3 | 2 | 4 + * 4 | 4 | 4 + * 5 | 4 | 8 + * 6 | 8 | 8 * 7 | 8 | 16 * */ - + /* Set various optimization parameters. */ int fiasco_c_options_set_optimizations (fiasco_c_options_t *options, - unsigned min_block_level, - unsigned max_block_level, - unsigned max_elements, - unsigned dictionary_size, - unsigned optimization_level); + unsigned min_block_level, + unsigned max_block_level, + unsigned max_elements, + unsigned dictionary_size, + unsigned optimization_level); /* Set minimum and maximum size of image block prediction */ int fiasco_c_options_set_prediction (fiasco_c_options_t *options, - int intra_prediction, - unsigned min_block_level, - unsigned max_block_level); + int intra_prediction, + unsigned min_block_level, + unsigned max_block_level); /* Set various parameters used for video compensation */ int fiasco_c_options_set_video_param (fiasco_c_options_t *options, - unsigned frames_per_second, - int half_pixel_prediction, - int cross_B_search, - int B_as_past_ref); + unsigned frames_per_second, + int half_pixel_prediction, + int cross_B_search, + int B_as_past_ref); /* Set accuracy of coefficients quantization */ int fiasco_c_options_set_quantization (fiasco_c_options_t *options, - unsigned mantissa, - fiasco_rpf_range_e range, - unsigned dc_mantissa, - fiasco_rpf_range_e dc_range); + unsigned mantissa, + fiasco_rpf_range_e range, + unsigned dc_mantissa, + fiasco_rpf_range_e dc_range); /* Set type of progress meter */ int fiasco_c_options_set_progress_meter (fiasco_c_options_t *options, - fiasco_progress_e type); + fiasco_progress_e type); /* Set comment of FIASCO stream */ int fiasco_c_options_set_comment (fiasco_c_options_t *options, - const char *comment); + const char *comment); /* Set title of FIASCO stream */ int fiasco_c_options_set_title (fiasco_c_options_t *options, - const char *title); + const char *title); /**************************************************************************** - decoder options functions + decoder options functions ****************************************************************************/ /* FIASCO additional options constructor */ @@ -421,15 +421,15 @@ void fiasco_d_options_delete (fiasco_d_options_t *options); /* Define `smoothing'-percentage along partitioning borders.*/ int fiasco_d_options_set_smoothing (fiasco_d_options_t *options, - int smoothing); + int smoothing); /* Set magnification-'level' of decoded image */ int fiasco_d_options_set_magnification (fiasco_d_options_t *options, - int level); + int level); /* Set image format to 4:2:0 or 4:4:4 */ int fiasco_d_options_set_4_2_0_format (fiasco_d_options_t *options, - int format); + int format); __END_DECLS diff --git a/converter/other/fiasco/fiascotopnm.c b/converter/other/fiasco/fiascotopnm.c index e95e27fc..c97e201b 100644 --- a/converter/other/fiasco/fiascotopnm.c +++ b/converter/other/fiasco/fiascotopnm.c @@ -3,11 +3,11 @@ * * Written by: Ullrich Hafner * Michael Unger - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ - + /* * $Date: 2000/10/28 17:39:29 $ * $Author: hafner $ @@ -50,10 +50,10 @@ static x11_info_t *xinfo = NULL; /***************************************************************************** prototypes - + *****************************************************************************/ -static int +static int checkargs (int argc, char **argv, bool_t *double_resolution, bool_t *panel, int *fps, char **image_name, fiasco_d_options_t **options); static void @@ -75,10 +75,10 @@ show_stored_frames (unsigned char * const *frame_buffer, int last_frame, /***************************************************************************** public code - + *****************************************************************************/ -int +int main (int argc, char **argv) { char *image_name = NULL; /* output filename */ @@ -92,7 +92,7 @@ main (int argc, char **argv) last_arg = checkargs (argc, argv, &double_resolution, &panel, &fps, &image_name, &options); - + if (last_arg >= argc) video_decoder ("-", image_name, panel, double_resolution, fps, options); else @@ -106,7 +106,7 @@ main (int argc, char **argv) /***************************************************************************** private code - + *****************************************************************************/ static param_t params [] = @@ -133,7 +133,7 @@ static param_t params [] = {NULL, NULL, 0, 0, {0}, NULL, NULL } }; -static int +static int checkargs (int argc, char **argv, bool_t *double_resolution, bool_t *panel, int *fps, char **image_name, fiasco_d_options_t **options) /* @@ -180,21 +180,21 @@ checkargs (int argc, char **argv, bool_t *double_resolution, bool_t *panel, { int const n = *((int *) parameter_value (params, "smoothing")); - + if (!fiasco_d_options_set_smoothing (*options, MAX(-1, n))) error (fiasco_get_error_message ()); } { int const n = *((int *) parameter_value (params, "magnify")); - + if (!fiasco_d_options_set_magnification (*options, n)) error (fiasco_get_error_message ()); } - + { 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 ()); } @@ -211,7 +211,7 @@ video_decoder (const char *wfa_name, const char *image_name, bool_t panel, unsigned char **frame_buffer = NULL; binfo_t *binfo = NULL; /* buttons info */ #endif /* not X_DISPLAY_MISSING */ - + do { unsigned width, height, frames, n; @@ -220,23 +220,23 @@ video_decoder (const char *wfa_name, const char *image_name, bool_t panel, char *basename; /* basename of decoded frame */ char *suffix; /* suffix of decoded frame */ unsigned frame_time; - + if (!(decoder_state = fiasco_decoder_new (wfa_name, options))) error (fiasco_get_error_message ()); - - if (fps <= 0) /* then use value of FIASCO file */ + + if (fps <= 0) /* then use value of FIASCO file */ fps = fiasco_decoder_get_rate (decoder_state); frame_time = fps ? (1000 / fps) : (1000 / 25); if (!(width = fiasco_decoder_get_width (decoder_state))) error (fiasco_get_error_message ()); - + if (!(height = fiasco_decoder_get_height (decoder_state))) error (fiasco_get_error_message ()); if (!(frames = fiasco_decoder_get_length (decoder_state))) error (fiasco_get_error_message ()); - + get_output_template (image_name, wfa_name, fiasco_decoder_is_color (decoder_state), &basename, &suffix); @@ -249,9 +249,9 @@ video_decoder (const char *wfa_name, const char *image_name, bool_t panel, for (n = 0; n < frames; n++) { clock_t fps_timer; /* frames per second timer struct */ - + prg_timer (&fps_timer, START); - + if (image_name) /* just write frame to disk */ { if (frames == 1) /* just one image */ @@ -277,23 +277,23 @@ video_decoder (const char *wfa_name, const char *image_name, bool_t panel, else { fiasco_image_t *frame; - + if (!(frame = fiasco_decoder_get_frame (decoder_state))) error (fiasco_get_error_message ()); - + if (frames == 1) panel = NO; if (xinfo == NULL) /* initialize X11 window */ { - const char * const title = + const char * const title = fiasco_decoder_get_title (decoder_state); char titlename [MAXSTRLEN]; - + sprintf (titlename, "dfiasco " VERSION ": %s", strlen (title) > 0 ? title : wfa_name); - xinfo = + xinfo = open_window (titlename, "dfiasco", (width << (double_resolution ? 1 : 0)), (height << (double_resolution ? 1 : 0)) @@ -302,7 +302,7 @@ video_decoder (const char *wfa_name, const char *image_name, bool_t panel, height << (double_resolution ? 1 : 0)); if (panel) /* initialize button panel */ binfo = init_buttons (xinfo, n, frames, 30, 10); - renderer = + renderer = fiasco_renderer_new (xinfo->ximage->red_mask, xinfo->ximage->green_mask, xinfo->ximage->blue_mask, @@ -313,7 +313,7 @@ video_decoder (const char *wfa_name, const char *image_name, bool_t panel, } renderer->render (renderer, xinfo->pixels, frame); frame->delete (frame); - + if (frame_buffer != NULL) /* store next frame */ { size_t size = (width << (double_resolution ? 1 : 0)) @@ -343,17 +343,17 @@ video_decoder (const char *wfa_name, const char *image_name, bool_t panel, else if (panel) { check_events (xinfo, binfo, n, frames); - if (binfo->pressed [QUIT_BUTTON]) + if (binfo->pressed [QUIT_BUTTON]) /* start from beginning */ break; - if (binfo->pressed [STOP_BUTTON]) + if (binfo->pressed [STOP_BUTTON]) /* start from beginning */ n = frames; - + if (binfo->pressed [RECORD_BUTTON] && frame_buffer == NULL) { n = frames; - frame_buffer = + frame_buffer = calloc (frames, sizeof (unsigned char *)); if (!frame_buffer) error ("Out of memory."); @@ -364,17 +364,17 @@ video_decoder (const char *wfa_name, const char *image_name, bool_t panel, } #else if (frame_time) {/* defeat compiler warning */} -#endif /* not X_DISPLAY_MISSING */ +#endif /* not X_DISPLAY_MISSING */ } free (filename); - + fiasco_decoder_delete (decoder_state); } while (panel #ifndef X_DISPLAY_MISSING && !binfo->pressed [QUIT_BUTTON] #endif /* not X_DISPLAY_MISSING */ - + ); #ifndef X_DISPLAY_MISSING @@ -408,7 +408,7 @@ get_output_template (const char *image_name, const char *wfa_name, */ { if (!wfa_name || streq (wfa_name, "-")) - wfa_name = "stdin"; + wfa_name = "stdin"; /* * Generate filename template */ @@ -422,7 +422,7 @@ get_output_template (const char *image_name, const char *wfa_name, *basename = strdup (image_name); *suffix = strrchr (*basename, '.'); } - + if (*suffix) /* found name 'basename.suffix' */ { **suffix = 0; /* remove dot */ @@ -450,13 +450,13 @@ show_stored_frames (unsigned char * const *frame_buffer, int last_frame, */ { int n = last_frame; /* frame number */ - + while (1) { clock_t fps_timer; /* frames per second timer struct */ - + prg_timer (&fps_timer, START); - + display_image (0, 0, xinfo); check_events (xinfo, binfo, n, last_frame + 1); diff --git a/converter/other/fiasco/getopt.c b/converter/other/fiasco/getopt.c index 2f45c7cc..44fd03e6 100644 --- a/converter/other/fiasco/getopt.c +++ b/converter/other/fiasco/getopt.c @@ -66,12 +66,12 @@ /* This needs to come after some library #include to get __GNU_LIBRARY__ defined. */ -#ifdef __GNU_LIBRARY__ +#ifdef __GNU_LIBRARY__ /* Don't include stdlib.h for non-GNU C libraries because some of them contain conflicting prototypes for getopt. */ #include <stdlib.h> #include <unistd.h> -#endif /* GNU C library. */ +#endif /* GNU C library. */ #if MSVCRT #include <windows.h> @@ -83,9 +83,9 @@ When compiling libc, the _ macro is predefined. */ #ifdef HAVE_LIBINTL_H # include <libintl.h> -# define _(msgid) gettext (msgid) +# define _(msgid) gettext (msgid) #else -# define _(msgid) (msgid) +# define _(msgid) (msgid) #endif #endif @@ -191,13 +191,13 @@ static enum /* Value of POSIXLY_CORRECT environment variable. */ static char *posixly_correct; -#ifdef __GNU_LIBRARY__ +#ifdef __GNU_LIBRARY__ /* We want to avoid inclusion of string.h with non-GNU libraries because there are many ways it can cause trouble. On some systems, it contains special magic macros that don't work in GCC. */ #include <string.h> -#define my_index strchr +#define my_index strchr #else /* Avoid depending on library functions or files @@ -213,7 +213,7 @@ my_index (str, chr) while (*str) { if (*str == chr) - return (char *) str; + return (char *) str; str++; } return 0; @@ -297,37 +297,37 @@ exchange (argv) while (top > middle && middle > bottom) { if (top - middle > middle - bottom) - { - /* Bottom segment is the short one. */ - int len = middle - bottom; - register int i; - - /* Swap it with the top part of the top segment. */ - for (i = 0; i < len; i++) - { - tem = argv[bottom + i]; - argv[bottom + i] = argv[top - (middle - bottom) + i]; - argv[top - (middle - bottom) + i] = tem; - } - /* Exclude the moved bottom segment from further swapping. */ - top -= len; - } + { + /* Bottom segment is the short one. */ + int len = middle - bottom; + register int i; + + /* Swap it with the top part of the top segment. */ + for (i = 0; i < len; i++) + { + tem = argv[bottom + i]; + argv[bottom + i] = argv[top - (middle - bottom) + i]; + argv[top - (middle - bottom) + i] = tem; + } + /* Exclude the moved bottom segment from further swapping. */ + top -= len; + } else - { - /* Top segment is the short one. */ - int len = top - middle; - register int i; - - /* Swap it with the bottom part of the bottom segment. */ - for (i = 0; i < len; i++) - { - tem = argv[bottom + i]; - argv[bottom + i] = argv[middle + i]; - argv[middle + i] = tem; - } - /* Exclude the moved top segment from further swapping. */ - bottom += len; - } + { + /* Top segment is the short one. */ + int len = top - middle; + register int i; + + /* Swap it with the bottom part of the bottom segment. */ + for (i = 0; i < len; i++) + { + tem = argv[bottom + i]; + argv[bottom + i] = argv[middle + i]; + argv[middle + i] = tem; + } + /* Exclude the moved top segment from further swapping. */ + bottom += len; + } } /* Update records for the slots the non-options now occupy. */ @@ -379,16 +379,16 @@ _getopt_initialize (argc, argv, optstring) && argc == original_argc && argv == original_argv) { /* Bash 2.0 puts a special variable in the environment for each - command it runs, specifying which ARGV elements are the results of - file name wildcard expansion and therefore should not be - considered as options. */ + command it runs, specifying which ARGV elements are the results of + file name wildcard expansion and therefore should not be + considered as options. */ char var[100]; sprintf (var, "_%d_GNU_nonoption_argv_flags_", getpid ()); nonoption_flags = getenv (var); if (nonoption_flags == NULL) - nonoption_flags_len = 0; + nonoption_flags_len = 0; else - nonoption_flags_len = strlen (nonoption_flags); + nonoption_flags_len = strlen (nonoption_flags); } else nonoption_flags_len = 0; @@ -467,7 +467,7 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only) if (!__getopt_initialized || optind == 0) { optstring = _getopt_initialize (argc, argv, optstring); - optind = 1; /* Don't scan ARGV[0], the program name. */ + optind = 1; /* Don't scan ARGV[0], the program name. */ __getopt_initialized = 1; } @@ -476,9 +476,9 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only) from the shell indicating it is not an option. The later information is only used when the used in the GNU libc. */ #ifdef _LIBC -#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \ - || (optind < nonoption_flags_len \ - && nonoption_flags[optind] == '1')) +#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \ + || (optind < nonoption_flags_len \ + && nonoption_flags[optind] == '1')) #else #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0') #endif @@ -488,76 +488,76 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only) /* Advance to the next ARGV-element. */ /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been - moved back by the user (who may also have changed the arguments). */ + moved back by the user (who may also have changed the arguments). */ if (last_nonopt > optind) - last_nonopt = optind; + last_nonopt = optind; if (first_nonopt > optind) - first_nonopt = optind; + first_nonopt = optind; if (ordering == PERMUTE) - { - /* If we have just processed some options following some non-options, - exchange them so that the options come first. */ + { + /* If we have just processed some options following some non-options, + exchange them so that the options come first. */ - if (first_nonopt != last_nonopt && last_nonopt != optind) - exchange ((char **) argv); - else if (last_nonopt != optind) - first_nonopt = optind; + if (first_nonopt != last_nonopt && last_nonopt != optind) + exchange ((char **) argv); + else if (last_nonopt != optind) + first_nonopt = optind; - /* Skip any additional non-options - and extend the range of non-options previously skipped. */ + /* Skip any additional non-options + and extend the range of non-options previously skipped. */ - while (optind < argc && NONOPTION_P) - optind++; - last_nonopt = optind; - } + while (optind < argc && NONOPTION_P) + optind++; + last_nonopt = optind; + } /* The special ARGV-element `--' means premature end of options. - Skip it like a null option, - then exchange with previous non-options as if it were an option, - then skip everything else like a non-option. */ + Skip it like a null option, + then exchange with previous non-options as if it were an option, + then skip everything else like a non-option. */ if (optind != argc && !strcmp (argv[optind], "--")) - { - optind++; + { + optind++; - if (first_nonopt != last_nonopt && last_nonopt != optind) - exchange ((char **) argv); - else if (first_nonopt == last_nonopt) - first_nonopt = optind; - last_nonopt = argc; + if (first_nonopt != last_nonopt && last_nonopt != optind) + exchange ((char **) argv); + else if (first_nonopt == last_nonopt) + first_nonopt = optind; + last_nonopt = argc; - optind = argc; - } + optind = argc; + } /* If we have done all the ARGV-elements, stop the scan - and back over any non-options that we skipped and permuted. */ + and back over any non-options that we skipped and permuted. */ if (optind == argc) - { - /* Set the next-arg-index to point at the non-options - that we previously skipped, so the caller will digest them. */ - if (first_nonopt != last_nonopt) - optind = first_nonopt; - return -1; - } + { + /* Set the next-arg-index to point at the non-options + that we previously skipped, so the caller will digest them. */ + if (first_nonopt != last_nonopt) + optind = first_nonopt; + return -1; + } /* If we have come to a non-option and did not permute it, - either stop the scan or describe it to the caller and pass it by. */ + either stop the scan or describe it to the caller and pass it by. */ if (NONOPTION_P) - { - if (ordering == REQUIRE_ORDER) - return -1; - optarg = argv[optind++]; - return 1; - } + { + if (ordering == REQUIRE_ORDER) + return -1; + optarg = argv[optind++]; + return 1; + } /* We have found another option-ARGV-element. - Skip the initial punctuation. */ + Skip the initial punctuation. */ nextchar = (argv[optind] + 1 - + (longopts != NULL && argv[optind][1] == '-')); + + (longopts != NULL && argv[optind][1] == '-')); } /* Decode the current option-ARGV-element. */ @@ -577,7 +577,7 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only) if (longopts != NULL && (argv[optind][1] == '-' - || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1]))))) + || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1]))))) { char *nameend; const struct option *p; @@ -588,124 +588,124 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only) int option_index; for (nameend = nextchar; *nameend && *nameend != '='; nameend++) - /* Do nothing. */ ; + /* Do nothing. */ ; /* Test all long options for either exact match - or abbreviated matches. */ + or abbreviated matches. */ for (p = longopts, option_index = 0; p->name; p++, option_index++) - if (!strncmp (p->name, nextchar, nameend - nextchar)) - { - if ((unsigned int) (nameend - nextchar) - == (unsigned int) strlen (p->name)) - { - /* Exact match found. */ - pfound = p; - indfound = option_index; - exact = 1; - break; - } - else if (pfound == NULL) - { - /* First nonexact match found. */ - pfound = p; - indfound = option_index; - } - else - /* Second or later nonexact match found. */ - ambig = 1; - } + if (!strncmp (p->name, nextchar, nameend - nextchar)) + { + if ((unsigned int) (nameend - nextchar) + == (unsigned int) strlen (p->name)) + { + /* Exact match found. */ + pfound = p; + indfound = option_index; + exact = 1; + break; + } + else if (pfound == NULL) + { + /* First nonexact match found. */ + pfound = p; + indfound = option_index; + } + else + /* Second or later nonexact match found. */ + ambig = 1; + } if (ambig && !exact) - { - if (opterr) - fprintf (stderr, _("%s: option `%s' is ambiguous\n"), - argv[0], argv[optind]); - nextchar += strlen (nextchar); - optind++; - optopt = 0; - return '?'; - } + { + if (opterr) + fprintf (stderr, _("%s: option `%s' is ambiguous\n"), + argv[0], argv[optind]); + nextchar += strlen (nextchar); + optind++; + optopt = 0; + return '?'; + } if (pfound != NULL) - { - option_index = indfound; - optind++; - if (*nameend) - { - /* Don't test has_arg with >, because some C compilers don't - allow it to be used on enums. */ - if (pfound->has_arg) - optarg = nameend + 1; - else - { + { + option_index = indfound; + optind++; + if (*nameend) + { + /* Don't test has_arg with >, because some C compilers don't + allow it to be used on enums. */ + if (pfound->has_arg) + optarg = nameend + 1; + else + { if (opterr) { - if (argv[optind - 1][1] == '-') - /* --option */ - fprintf (stderr, - _("%s: option `--%s' doesn't allow an argument\n"), - argv[0], pfound->name); - else - /* +option or -option */ - fprintf (stderr, - _("%s: option `%c%s' doesn't allow an argument\n"), - argv[0], argv[optind - 1][0], pfound->name); + if (argv[optind - 1][1] == '-') + /* --option */ + fprintf (stderr, + _("%s: option `--%s' doesn't allow an argument\n"), + argv[0], pfound->name); + else + /* +option or -option */ + fprintf (stderr, + _("%s: option `%c%s' doesn't allow an argument\n"), + argv[0], argv[optind - 1][0], pfound->name); } - nextchar += strlen (nextchar); - - optopt = pfound->val; - return '?'; - } - } - else if (pfound->has_arg == 1) - { - if (optind < argc) - optarg = argv[optind++]; - else - { - if (opterr) - fprintf (stderr, - _("%s: option `%s' requires an argument\n"), - argv[0], argv[optind - 1]); - nextchar += strlen (nextchar); - optopt = pfound->val; - return optstring[0] == ':' ? ':' : '?'; - } - } - nextchar += strlen (nextchar); - if (longind != NULL) - *longind = option_index; - if (pfound->flag) - { - *(pfound->flag) = pfound->val; - return 0; - } - return pfound->val; - } + nextchar += strlen (nextchar); + + optopt = pfound->val; + return '?'; + } + } + else if (pfound->has_arg == 1) + { + if (optind < argc) + optarg = argv[optind++]; + else + { + if (opterr) + fprintf (stderr, + _("%s: option `%s' requires an argument\n"), + argv[0], argv[optind - 1]); + nextchar += strlen (nextchar); + optopt = pfound->val; + return optstring[0] == ':' ? ':' : '?'; + } + } + nextchar += strlen (nextchar); + if (longind != NULL) + *longind = option_index; + if (pfound->flag) + { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } /* Can't find it as a long option. If this is not getopt_long_only, - or the option starts with '--' or is not a valid short - option, then it's an error. - Otherwise interpret it as a short option. */ + or the option starts with '--' or is not a valid short + option, then it's an error. + Otherwise interpret it as a short option. */ if (!long_only || argv[optind][1] == '-' - || my_index (optstring, *nextchar) == NULL) - { - if (opterr) - { - if (argv[optind][1] == '-') - /* --option */ - fprintf (stderr, _("%s: unrecognized option `--%s'\n"), - argv[0], nextchar); - else - /* +option or -option */ - fprintf (stderr, _("%s: unrecognized option `%c%s'\n"), - argv[0], argv[optind][0], nextchar); - } - nextchar = (char *) ""; - optind++; - optopt = 0; - return '?'; - } + || my_index (optstring, *nextchar) == NULL) + { + if (opterr) + { + if (argv[optind][1] == '-') + /* --option */ + fprintf (stderr, _("%s: unrecognized option `--%s'\n"), + argv[0], nextchar); + else + /* +option or -option */ + fprintf (stderr, _("%s: unrecognized option `%c%s'\n"), + argv[0], argv[optind][0], nextchar); + } + nextchar = (char *) ""; + optind++; + optopt = 0; + return '?'; + } } /* Look at and handle the next short option-character. */ @@ -720,188 +720,188 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only) if (temp == NULL || c == ':') { - if (opterr) - { - if (posixly_correct) - /* 1003.2 specifies the format of this message. */ - fprintf (stderr, _("%s: illegal option -- %c\n"), - argv[0], c); - else - fprintf (stderr, _("%s: invalid option -- %c\n"), - argv[0], c); - } - optopt = c; - return '?'; + if (opterr) + { + if (posixly_correct) + /* 1003.2 specifies the format of this message. */ + fprintf (stderr, _("%s: illegal option -- %c\n"), + argv[0], c); + else + fprintf (stderr, _("%s: invalid option -- %c\n"), + argv[0], c); + } + optopt = c; + return '?'; } /* Convenience. Treat POSIX -W foo same as long option --foo */ if (temp[0] == 'W' && temp[1] == ';') { - char *nameend; - const struct option *p; - const struct option *pfound = NULL; - int exact = 0; - int ambig = 0; - int indfound = 0; - int option_index; - - /* This is an option that requires an argument. */ - if (*nextchar != '\0') - { - optarg = nextchar; - /* If we end this ARGV-element by taking the rest as an arg, - we must advance to the next element now. */ - optind++; - } - else if (optind == argc) - { - if (opterr) - { - /* 1003.2 specifies the format of this message. */ - fprintf (stderr, _("%s: option requires an argument -- %c\n"), - argv[0], c); - } - optopt = c; - if (optstring[0] == ':') - c = ':'; - else - c = '?'; - return c; - } - else - /* We already incremented `optind' once; - increment it again when taking next ARGV-elt as argument. */ - optarg = argv[optind++]; - - /* optarg is now the argument, see if it's in the - table of longopts. */ - - for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++) - /* Do nothing. */ ; - - /* Test all long options for either exact match - or abbreviated matches. */ - for (p = longopts, option_index = 0; p->name; p++, option_index++) - if (!strncmp (p->name, nextchar, nameend - nextchar)) - { - if ((unsigned int) (nameend - nextchar) == strlen (p->name)) - { - /* Exact match found. */ - pfound = p; - indfound = option_index; - exact = 1; - break; - } - else if (pfound == NULL) - { - /* First nonexact match found. */ - pfound = p; - indfound = option_index; - } - else - /* Second or later nonexact match found. */ - ambig = 1; - } - if (ambig && !exact) - { - if (opterr) - fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"), - argv[0], argv[optind]); - nextchar += strlen (nextchar); - optind++; - return '?'; - } - if (pfound != NULL) - { - option_index = indfound; - if (*nameend) - { - /* Don't test has_arg with >, because some C compilers don't - allow it to be used on enums. */ - if (pfound->has_arg) - optarg = nameend + 1; - else - { - if (opterr) - fprintf (stderr, _("\ + char *nameend; + const struct option *p; + const struct option *pfound = NULL; + int exact = 0; + int ambig = 0; + int indfound = 0; + int option_index; + + /* This is an option that requires an argument. */ + if (*nextchar != '\0') + { + optarg = nextchar; + /* If we end this ARGV-element by taking the rest as an arg, + we must advance to the next element now. */ + optind++; + } + else if (optind == argc) + { + if (opterr) + { + /* 1003.2 specifies the format of this message. */ + fprintf (stderr, _("%s: option requires an argument -- %c\n"), + argv[0], c); + } + optopt = c; + if (optstring[0] == ':') + c = ':'; + else + c = '?'; + return c; + } + else + /* We already incremented `optind' once; + increment it again when taking next ARGV-elt as argument. */ + optarg = argv[optind++]; + + /* optarg is now the argument, see if it's in the + table of longopts. */ + + for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++) + /* Do nothing. */ ; + + /* Test all long options for either exact match + or abbreviated matches. */ + for (p = longopts, option_index = 0; p->name; p++, option_index++) + if (!strncmp (p->name, nextchar, nameend - nextchar)) + { + if ((unsigned int) (nameend - nextchar) == strlen (p->name)) + { + /* Exact match found. */ + pfound = p; + indfound = option_index; + exact = 1; + break; + } + else if (pfound == NULL) + { + /* First nonexact match found. */ + pfound = p; + indfound = option_index; + } + else + /* Second or later nonexact match found. */ + ambig = 1; + } + if (ambig && !exact) + { + if (opterr) + fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"), + argv[0], argv[optind]); + nextchar += strlen (nextchar); + optind++; + return '?'; + } + if (pfound != NULL) + { + option_index = indfound; + if (*nameend) + { + /* Don't test has_arg with >, because some C compilers don't + allow it to be used on enums. */ + if (pfound->has_arg) + optarg = nameend + 1; + else + { + if (opterr) + fprintf (stderr, _("\ %s: option `-W %s' doesn't allow an argument\n"), - argv[0], pfound->name); - - nextchar += strlen (nextchar); - return '?'; - } - } - else if (pfound->has_arg == 1) - { - if (optind < argc) - optarg = argv[optind++]; - else - { - if (opterr) - fprintf (stderr, - _("%s: option `%s' requires an argument\n"), - argv[0], argv[optind - 1]); - nextchar += strlen (nextchar); - return optstring[0] == ':' ? ':' : '?'; - } - } - nextchar += strlen (nextchar); - if (longind != NULL) - *longind = option_index; - if (pfound->flag) - { - *(pfound->flag) = pfound->val; - return 0; - } - return pfound->val; - } - nextchar = NULL; - return 'W'; /* Let the application handle it. */ + argv[0], pfound->name); + + nextchar += strlen (nextchar); + return '?'; + } + } + else if (pfound->has_arg == 1) + { + if (optind < argc) + optarg = argv[optind++]; + else + { + if (opterr) + fprintf (stderr, + _("%s: option `%s' requires an argument\n"), + argv[0], argv[optind - 1]); + nextchar += strlen (nextchar); + return optstring[0] == ':' ? ':' : '?'; + } + } + nextchar += strlen (nextchar); + if (longind != NULL) + *longind = option_index; + if (pfound->flag) + { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } + nextchar = NULL; + return 'W'; /* Let the application handle it. */ } if (temp[1] == ':') { - if (temp[2] == ':') - { - /* This is an option that accepts an argument optionally. */ - if (*nextchar != '\0') - { - optarg = nextchar; - optind++; - } - else - optarg = NULL; - nextchar = NULL; - } - else - { - /* This is an option that requires an argument. */ - if (*nextchar != '\0') - { - optarg = nextchar; - /* If we end this ARGV-element by taking the rest as an arg, - we must advance to the next element now. */ - optind++; - } - else if (optind == argc) - { - if (opterr) - { - /* 1003.2 specifies the format of this message. */ - fprintf (stderr, - _("%s: option requires an argument -- %c\n"), - argv[0], c); - } - optopt = c; - if (optstring[0] == ':') - c = ':'; - else - c = '?'; - } - else - /* We already incremented `optind' once; - increment it again when taking next ARGV-elt as argument. */ - optarg = argv[optind++]; - nextchar = NULL; - } + if (temp[2] == ':') + { + /* This is an option that accepts an argument optionally. */ + if (*nextchar != '\0') + { + optarg = nextchar; + optind++; + } + else + optarg = NULL; + nextchar = NULL; + } + else + { + /* This is an option that requires an argument. */ + if (*nextchar != '\0') + { + optarg = nextchar; + /* If we end this ARGV-element by taking the rest as an arg, + we must advance to the next element now. */ + optind++; + } + else if (optind == argc) + { + if (opterr) + { + /* 1003.2 specifies the format of this message. */ + fprintf (stderr, + _("%s: option requires an argument -- %c\n"), + argv[0], c); + } + optopt = c; + if (optstring[0] == ':') + c = ':'; + else + c = '?'; + } + else + /* We already incremented `optind' once; + increment it again when taking next ARGV-elt as argument. */ + optarg = argv[optind++]; + nextchar = NULL; + } } return c; } @@ -914,12 +914,12 @@ getopt (argc, argv, optstring) const char *optstring; { return _getopt_internal (argc, argv, optstring, - (const struct option *) 0, - (int *) 0, - 0); + (const struct option *) 0, + (int *) 0, + 0); } -#endif /* Not ELIDE_CODE. */ +#endif /* Not ELIDE_CODE. */ #ifdef TEST @@ -940,51 +940,51 @@ main (argc, argv) c = getopt (argc, argv, "abc:d:0123456789"); if (c == -1) - break; + break; switch (c) - { - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - if (digit_optind != 0 && digit_optind != this_option_optind) - printf ("digits occur in two different argv-elements.\n"); - digit_optind = this_option_optind; - printf ("option %c\n", c); - break; - - case 'a': - printf ("option a\n"); - break; - - case 'b': - printf ("option b\n"); - break; - - case 'c': - printf ("option c with value `%s'\n", optarg); - break; - - case '?': - break; - - default: - printf ("?? getopt returned character code 0%o ??\n", c); - } + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (digit_optind != 0 && digit_optind != this_option_optind) + printf ("digits occur in two different argv-elements.\n"); + digit_optind = this_option_optind; + printf ("option %c\n", c); + break; + + case 'a': + printf ("option a\n"); + break; + + case 'b': + printf ("option b\n"); + break; + + case 'c': + printf ("option c with value `%s'\n", optarg); + break; + + case '?': + break; + + default: + printf ("?? getopt returned character code 0%o ??\n", c); + } } if (optind < argc) { printf ("non-option ARGV-elements: "); while (optind < argc) - printf ("%s ", argv[optind++]); + printf ("%s ", argv[optind++]); printf ("\n"); } diff --git a/converter/other/fiasco/getopt.h b/converter/other/fiasco/getopt.h index 9acca708..3c735e3d 100644 --- a/converter/other/fiasco/getopt.h +++ b/converter/other/fiasco/getopt.h @@ -22,7 +22,7 @@ #ifndef _GETOPT_H #define _GETOPT_H 1 -#ifdef __cplusplus +#ifdef __cplusplus extern "C" { #endif @@ -63,9 +63,9 @@ extern int optopt; zero. The field `has_arg' is: - no_argument (or 0) if the option does not take an argument, - required_argument (or 1) if the option requires an argument, - optional_argument (or 2) if the option takes an optional argument. + no_argument (or 0) if the option does not take an argument, + required_argument (or 1) if the option requires an argument, + optional_argument (or 2) if the option takes an optional argument. If the field `flag' is not NULL, it points to a variable that is set to the value given in the field `val' when the option is found, but @@ -90,9 +90,9 @@ struct option /* Names for the values of the `has_arg' field of `struct option'. */ -#define no_argument 0 -#define required_argument 1 -#define optional_argument 2 +#define no_argument 0 +#define required_argument 1 +#define optional_argument 2 #if defined (__STDC__) && __STDC__ #ifdef __GNU_LIBRARY__ @@ -104,16 +104,16 @@ extern int getopt (int argc, char *const *argv, const char *shortopts); extern int getopt (); #endif /* __GNU_LIBRARY__ */ extern int getopt_long (int argc, char *const *argv, const char *shortopts, - const struct option *longopts, int *longind); + const struct option *longopts, int *longind); extern int getopt_long_only (int argc, char *const *argv, - const char *shortopts, - const struct option *longopts, int *longind); + const char *shortopts, + const struct option *longopts, int *longind); /* Internal only. Users should not call this directly. */ extern int _getopt_internal (int argc, char *const *argv, - const char *shortopts, - const struct option *longopts, int *longind, - int long_only); + const char *shortopts, + const struct option *longopts, int *longind, + int long_only); #else /* not __STDC__ */ extern int getopt (); extern int getopt_long (); @@ -122,7 +122,7 @@ extern int getopt_long_only (); extern int _getopt_internal (); #endif /* __STDC__ */ -#ifdef __cplusplus +#ifdef __cplusplus } #endif diff --git a/converter/other/fiasco/getopt1.c b/converter/other/fiasco/getopt1.c index 8347bb13..4ed64b8b 100644 --- a/converter/other/fiasco/getopt1.c +++ b/converter/other/fiasco/getopt1.c @@ -60,7 +60,7 @@ #include <stdlib.h> #endif -#ifndef NULL +#ifndef NULL #define NULL 0 #endif @@ -92,7 +92,7 @@ getopt_long_only (argc, argv, options, long_options, opt_index) } -#endif /* Not ELIDE_CODE. */ +#endif /* Not ELIDE_CODE. */ #ifdef TEST @@ -112,74 +112,74 @@ main (argc, argv) int option_index = 0; static struct option long_options[] = { - {"add", 1, 0, 0}, - {"append", 0, 0, 0}, - {"delete", 1, 0, 0}, - {"verbose", 0, 0, 0}, - {"create", 0, 0, 0}, - {"file", 1, 0, 0}, - {0, 0, 0, 0} + {"add", 1, 0, 0}, + {"append", 0, 0, 0}, + {"delete", 1, 0, 0}, + {"verbose", 0, 0, 0}, + {"create", 0, 0, 0}, + {"file", 1, 0, 0}, + {0, 0, 0, 0} }; c = getopt_long (argc, argv, "abc:d:0123456789", - long_options, &option_index); + long_options, &option_index); if (c == -1) - break; + break; switch (c) - { - case 0: - printf ("option %s", long_options[option_index].name); - if (optarg) - printf (" with arg %s", optarg); - printf ("\n"); - break; - - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - if (digit_optind != 0 && digit_optind != this_option_optind) - printf ("digits occur in two different argv-elements.\n"); - digit_optind = this_option_optind; - printf ("option %c\n", c); - break; - - case 'a': - printf ("option a\n"); - break; - - case 'b': - printf ("option b\n"); - break; - - case 'c': - printf ("option c with value `%s'\n", optarg); - break; - - case 'd': - printf ("option d with value `%s'\n", optarg); - break; - - case '?': - break; - - default: - printf ("?? getopt returned character code 0%o ??\n", c); - } + { + case 0: + printf ("option %s", long_options[option_index].name); + if (optarg) + printf (" with arg %s", optarg); + printf ("\n"); + break; + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (digit_optind != 0 && digit_optind != this_option_optind) + printf ("digits occur in two different argv-elements.\n"); + digit_optind = this_option_optind; + printf ("option %c\n", c); + break; + + case 'a': + printf ("option a\n"); + break; + + case 'b': + printf ("option b\n"); + break; + + case 'c': + printf ("option c with value `%s'\n", optarg); + break; + + case 'd': + printf ("option d with value `%s'\n", optarg); + break; + + case '?': + break; + + default: + printf ("?? getopt returned character code 0%o ??\n", c); + } } if (optind < argc) { printf ("non-option ARGV-elements: "); while (optind < argc) - printf ("%s ", argv[optind++]); + printf ("%s ", argv[optind++]); printf ("\n"); } diff --git a/converter/other/fiasco/input/basis.c b/converter/other/fiasco/input/basis.c index e5ced0d0..4be7f4ed 100644 --- a/converter/other/fiasco/input/basis.c +++ b/converter/other/fiasco/input/basis.c @@ -1,7 +1,7 @@ /* - * basis.c: WFA initial basis files + * basis.c: WFA initial basis files * - * Written by: Ullrich Hafner + * Written by: Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -43,7 +43,7 @@ typedef struct /***************************************************************************** - prototypes + prototypes *****************************************************************************/ @@ -58,7 +58,7 @@ static basis_file_t const basis_files[] = { /***************************************************************************** - public code + public code *****************************************************************************/ @@ -70,69 +70,69 @@ get_linked_basis (const char *basis_name, wfa_t *wfa) * according to the stored data, otherwise print a warning message. * * Return value: - * true on success, false if basis is not available yet. + * true on success, false if basis is not available yet. * * Side effects: - * 'wfa' struct is filled on success. + * 'wfa' struct is filled on success. */ { - bool_t success = NO; /* indicates if basis is found */ - unsigned n; /* counter */ - basis_values_t bv; /* basis values */ + bool_t success = NO; /* indicates if basis is found */ + unsigned n; /* counter */ + basis_values_t bv; /* basis values */ for (n = 0; basis_files [n].filename != NULL; n++) - if (streq (basis_files [n].filename, basis_name)) /* basis is stored */ + if (streq (basis_files [n].filename, basis_name)) /* basis is stored */ { - unsigned state, edge; - - (*basis_files [n].function) (&bv); /* initialize local variables */ - /* - * Generate WFA - */ - wfa->basis_states = wfa->states = bv.states + 1; - wfa->domain_type[0] = USE_DOMAIN_MASK; - wfa->final_distribution[0] = 128; - append_edge (0, 0, 1.0, 0, wfa); - append_edge (0, 0, 1.0, 1, wfa); - for (state = 1; state < wfa->basis_states; state++) - { - wfa->final_distribution [state] = bv.final [state - 1]; - wfa->domain_type [state] = bv.use_domain [state - 1] - ? USE_DOMAIN_MASK - : AUXILIARY_MASK; - } - for (edge = 0; isedge (bv.transitions [edge][0]); edge++) - append_edge (bv.transitions [edge][0], bv.transitions [edge][1], - bv.transitions [edge][2], bv.transitions [edge][3], - wfa); - - success = YES; - break; + unsigned state, edge; + + (*basis_files [n].function) (&bv); /* initialize local variables */ + /* + * Generate WFA + */ + wfa->basis_states = wfa->states = bv.states + 1; + wfa->domain_type[0] = USE_DOMAIN_MASK; + wfa->final_distribution[0] = 128; + append_edge (0, 0, 1.0, 0, wfa); + append_edge (0, 0, 1.0, 1, wfa); + for (state = 1; state < wfa->basis_states; state++) + { + wfa->final_distribution [state] = bv.final [state - 1]; + wfa->domain_type [state] = bv.use_domain [state - 1] + ? USE_DOMAIN_MASK + : AUXILIARY_MASK; + } + for (edge = 0; isedge (bv.transitions [edge][0]); edge++) + append_edge (bv.transitions [edge][0], bv.transitions [edge][1], + bv.transitions [edge][2], bv.transitions [edge][3], + wfa); + + success = YES; + break; } if (!success) warning ("WFA initial basis '%s' isn't linked with the executable yet." - "\nLoading basis from disk instead.", basis_name); + "\nLoading basis from disk instead.", basis_name); return success; } /***************************************************************************** - private code + private code *****************************************************************************/ /***************************************************************************** - basis "small.wfa" + basis "small.wfa" *****************************************************************************/ -static unsigned states_small = 2; -static bool_t use_domain_small[] = {YES, YES}; -static real_t final_small[] = {64, 64}; -static real_t transitions_small[][4] = {{1, 2, 0.5, 0}, {1, 2, 0.5, 1}, - {1, 0, 0.5, 1}, {2, 1, 1.0, 0}, - {2, 1, 1.0, 1}, {-1, 0, 0, 0}}; +static unsigned states_small = 2; +static bool_t use_domain_small[] = {YES, YES}; +static real_t final_small[] = {64, 64}; +static real_t transitions_small[][4] = {{1, 2, 0.5, 0}, {1, 2, 0.5, 1}, + {1, 0, 0.5, 1}, {2, 1, 1.0, 0}, + {2, 1, 1.0, 1}, {-1, 0, 0, 0}}; static void small_init (basis_values_t *bv) { diff --git a/converter/other/fiasco/input/basis.h b/converter/other/fiasco/input/basis.h index e2242198..d6d2f8b3 100644 --- a/converter/other/fiasco/input/basis.h +++ b/converter/other/fiasco/input/basis.h @@ -1,8 +1,8 @@ /* * basis.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ diff --git a/converter/other/fiasco/input/matrices.c b/converter/other/fiasco/input/matrices.c index d20a27eb..f59b5a30 100644 --- a/converter/other/fiasco/input/matrices.c +++ b/converter/other/fiasco/input/matrices.c @@ -1,7 +1,7 @@ /* - * matrices.c: Input of transition matrices + * matrices.c: Input of transition matrices * - * Written by: Ullrich Hafner + * Written by: Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -28,12 +28,12 @@ #include "matrices.h" #if STDC_HEADERS -# include <stdlib.h> +# include <stdlib.h> #endif /* not STDC_HEADERS */ /***************************************************************************** - prototypes + prototypes *****************************************************************************/ @@ -48,7 +48,7 @@ compute_y_state (int state, int y_state, wfa_t *wfa); /***************************************************************************** - public code + public code *****************************************************************************/ @@ -58,16 +58,16 @@ read_matrices (wfa_t *wfa, bitfile_t *input) * Read transitions of WFA given from the stream 'input'. * * Return value: - * number of edges + * number of edges * * Side effects: - * 'wfa->into' is filled with decoded values + * 'wfa->into' is filled with decoded values */ { - unsigned total; /* total number of edges in the WFA */ + unsigned total; /* total number of edges in the WFA */ unsigned root_state = wfa->wfainfo->color - ? wfa->tree [wfa->tree [wfa->root_state][0]][0] - : wfa->root_state; + ? wfa->tree [wfa->tree [wfa->root_state][0]][0] + : wfa->root_state; total = column_0_decoding (wfa, root_state, input); total += delta_decoding (wfa, root_state, input); @@ -79,7 +79,7 @@ read_matrices (wfa_t *wfa, bitfile_t *input) /***************************************************************************** - private code + private code *****************************************************************************/ @@ -91,34 +91,34 @@ delta_decoding (wfa_t *wfa, unsigned last_domain, bitfile_t *input) * 'last_domain' is the maximum state number used as domain image. * * Return value: - * number of non-zero matrix elements (WFA edges) + * number of non-zero matrix elements (WFA edges) * * Side effects: - * 'wfa->into' is filled with decoded values + * 'wfa->into' is filled with decoded values */ { - range_sort_t rs; /* ranges are sorted as in the coder */ - unsigned max_domain; /* dummy used for recursion */ - unsigned range; - unsigned count [MAXEDGES + 1]; - unsigned state, label; - unsigned *n_edges; /* number of elements per row */ - unsigned total = 0; /* total number of decoded edges */ + range_sort_t rs; /* ranges are sorted as in the coder */ + unsigned max_domain; /* dummy used for recursion */ + unsigned range; + unsigned count [MAXEDGES + 1]; + unsigned state, label; + unsigned *n_edges; /* number of elements per row */ + unsigned total = 0; /* total number of decoded edges */ /* * Generate a list of range blocks. * The order is the same as in the coder. */ rs.range_state = Calloc ((last_domain + 1) * MAXLABELS, - sizeof (u_word_t)); + sizeof (u_word_t)); rs.range_label = Calloc ((last_domain + 1) * MAXLABELS, - sizeof (byte_t)); + sizeof (byte_t)); rs.range_max_domain = Calloc ((last_domain + 1) * MAXLABELS, - sizeof (u_word_t)); + sizeof (u_word_t)); rs.range_subdivided = Calloc ((last_domain + 1) * MAXLABELS, - sizeof (bool_t)); - rs.range_no = 0; - max_domain = wfa->basis_states - 1; + sizeof (bool_t)); + rs.range_no = 0; + max_domain = wfa->basis_states - 1; sort_ranges (last_domain, &max_domain, &rs, wfa); /* @@ -127,42 +127,42 @@ delta_decoding (wfa_t *wfa, unsigned last_domain, bitfile_t *input) { arith_t *decoder; model_t *elements; - unsigned max_edges = read_rice_code (3, input); + unsigned max_edges = read_rice_code (3, input); /* * Get the probability array of the number of edges distribution * and allocate the corresponding model. */ { - unsigned edge; + unsigned edge; - for (edge = 0; edge <= max_edges; edge++) - count [edge] = read_rice_code ((int) log2 (last_domain) - 2, - input); - elements = alloc_model (max_edges + 1, 0, 0, count); + for (edge = 0; edge <= max_edges; edge++) + count [edge] = read_rice_code ((int) log2 (last_domain) - 2, + input); + elements = alloc_model (max_edges + 1, 0, 0, count); } /* * Get number of elements per matrix row */ { - unsigned row; - - n_edges = Calloc (wfa->states, sizeof (unsigned)); - decoder = alloc_decoder (input); - for (row = range = 0; range < rs.range_no; range++) - if (!rs.range_subdivided [range]) - { - state = rs.range_state [range]; - label = rs.range_label [range]; - - n_edges [row++] - = decode_symbol (decoder, elements) - - (isedge (wfa->into [state][label][0]) ? 1 : 0); - } - - free_decoder (decoder); - free_model (elements); + unsigned row; + + n_edges = Calloc (wfa->states, sizeof (unsigned)); + decoder = alloc_decoder (input); + for (row = range = 0; range < rs.range_no; range++) + if (!rs.range_subdivided [range]) + { + state = rs.range_state [range]; + label = rs.range_label [range]; + + n_edges [row++] + = decode_symbol (decoder, elements) + - (isedge (wfa->into [state][label][0]) ? 1 : 0); + } + + free_decoder (decoder); + free_model (elements); } } @@ -175,8 +175,8 @@ delta_decoding (wfa_t *wfa, unsigned last_domain, bitfile_t *input) u_word_t *mapping_coder1 = Calloc (wfa->states, sizeof (word_t)); u_word_t *mapping2 = Calloc (wfa->states, sizeof (word_t)); u_word_t *mapping_coder2 = Calloc (wfa->states, sizeof (word_t)); - bool_t use_normal_domains = get_bit (input); - bool_t use_delta_domains = get_bit (input); + bool_t use_normal_domains = get_bit (input); + bool_t use_delta_domains = get_bit (input); /* * Generate array of states which are admitted domains. @@ -187,63 +187,63 @@ delta_decoding (wfa_t *wfa, unsigned last_domain, bitfile_t *input) * coding the motion compensated prediction error */ { - unsigned n1, n2, state; - - for (n1 = n2 = state = 0; state < wfa->states; state++) - { - mapping1 [n1] = state; - mapping_coder1 [state] = n1; - if (usedomain (state, wfa) - && (state < wfa->basis_states - || use_delta_domains || !wfa->delta_state [state])) - n1++; - - mapping2 [n2] = state; - mapping_coder2 [state] = n2; - if (usedomain (state, wfa) - && (state < wfa->basis_states || use_normal_domains - || wfa->delta_state [state])) - n2++; - } + unsigned n1, n2, state; + + for (n1 = n2 = state = 0; state < wfa->states; state++) + { + mapping1 [n1] = state; + mapping_coder1 [state] = n1; + if (usedomain (state, wfa) + && (state < wfa->basis_states + || use_delta_domains || !wfa->delta_state [state])) + n1++; + + mapping2 [n2] = state; + mapping_coder2 [state] = n2; + if (usedomain (state, wfa) + && (state < wfa->basis_states || use_normal_domains + || wfa->delta_state [state])) + n2++; + } } for (row = 0, range = 0; range < rs.range_no; range++) - if (!rs.range_subdivided [range]) - { - u_word_t *mapping; - u_word_t *mapping_coder; - unsigned max_value; - unsigned edge; - unsigned state = rs.range_state [range]; - unsigned label = rs.range_label [range]; - unsigned last = 1; - - if (wfa->delta_state [state] || - wfa->mv_tree [state][label].type != NONE) - { - mapping = mapping2; - mapping_coder = mapping_coder2; - } - else - { - mapping = mapping1; - mapping_coder = mapping_coder1; - } - max_value = mapping_coder [rs.range_max_domain [range]]; - for (edge = n_edges [row]; edge; edge--) - { - unsigned domain; - - if (max_value - last) - domain = read_bin_code (max_value - last, input) + last; - else - domain = max_value; - append_edge (state, mapping [domain], -1, label, wfa); - last = domain + 1; - total++; - } - row++; - } + if (!rs.range_subdivided [range]) + { + u_word_t *mapping; + u_word_t *mapping_coder; + unsigned max_value; + unsigned edge; + unsigned state = rs.range_state [range]; + unsigned label = rs.range_label [range]; + unsigned last = 1; + + if (wfa->delta_state [state] || + wfa->mv_tree [state][label].type != NONE) + { + mapping = mapping2; + mapping_coder = mapping_coder2; + } + else + { + mapping = mapping1; + mapping_coder = mapping_coder1; + } + max_value = mapping_coder [rs.range_max_domain [range]]; + for (edge = n_edges [row]; edge; edge--) + { + unsigned domain; + + if (max_value - last) + domain = read_bin_code (max_value - last, input) + last; + else + domain = max_value; + append_edge (state, mapping [domain], -1, label, wfa); + last = domain + 1; + total++; + } + row++; + } Free (mapping1); Free (mapping_coder1); Free (mapping2); @@ -267,23 +267,23 @@ column_0_decoding (wfa_t *wfa, unsigned last_row, bitfile_t *input) * All rows from 'wfa->basis_states' up to 'last_row' are decoded. * * Return value: - * number of non-zero matrix elements (WFA edges) + * number of non-zero matrix elements (WFA edges) * * Side effects: - * 'wfa->into' is filled with decoded values + * 'wfa->into' is filled with decoded values */ { - unsigned row; /* current matrix row */ - unsigned total = 0; /* total number of edges in col 0 */ - unsigned *prob_ptr; /* pointer to current probability */ - unsigned *last; /* pointer to minimum probability */ - unsigned *first; /* pointer to maximum probability */ - unsigned *new_prob_ptr; /* ptr to probability of last domain */ - unsigned *prob; /* probability array */ - u_word_t high; /* Start of the current code range */ - u_word_t low; /* End of the current code range */ - u_word_t code; /* The present input code value */ - word_t *is_leaf; /* pointer to the tree structure */ + unsigned row; /* current matrix row */ + unsigned total = 0; /* total number of edges in col 0 */ + unsigned *prob_ptr; /* pointer to current probability */ + unsigned *last; /* pointer to minimum probability */ + unsigned *first; /* pointer to maximum probability */ + unsigned *new_prob_ptr; /* ptr to probability of last domain */ + unsigned *prob; /* probability array */ + u_word_t high; /* Start of the current code range */ + u_word_t low; /* End of the current code range */ + u_word_t code; /* The present input code value */ + word_t *is_leaf; /* pointer to the tree structure */ /* * Compute the asymmetric probability array @@ -292,14 +292,14 @@ column_0_decoding (wfa_t *wfa, unsigned last_row, bitfile_t *input) */ { unsigned n; - unsigned index; /* probability index */ - unsigned exp; /* current exponent */ + unsigned index; /* probability index */ + unsigned exp; /* current exponent */ prob = Calloc (1 << (MAX_PROB + 1), sizeof (unsigned)); for (index = 0, n = MIN_PROB; n <= MAX_PROB; n++) - for (exp = 0; exp < 1U << n; exp++, index++) - prob [index] = n; + for (exp = 0; exp < 1U << n; exp++, index++) + prob [index] = n; } first = prob_ptr = new_prob_ptr = prob; @@ -307,8 +307,8 @@ column_0_decoding (wfa_t *wfa, unsigned last_row, bitfile_t *input) is_leaf = wfa->tree [wfa->basis_states]; /* use pointer arithmetics ... */ - high = HIGH; /* 1.0 */ - low = LOW; /* 0.0 */ + high = HIGH; /* 1.0 */ + low = LOW; /* 0.0 */ code = get_bits (input, 16); /* @@ -324,73 +324,73 @@ column_0_decoding (wfa_t *wfa, unsigned last_row, bitfile_t *input) */ for (row = wfa->basis_states; row <= last_row; row++) { - unsigned count; /* value in the current interval */ + unsigned count; /* value in the current interval */ /* * Read label 0 element */ - if (isrange (*is_leaf++)) /* valid matrix index */ + if (isrange (*is_leaf++)) /* valid matrix index */ { - count = high - ((high - low) >> *prob_ptr); - if (code < count) - { - if (prob_ptr < last) /* model update */ - prob_ptr++; - /* - * Decode the MPS '0' - */ - high = count - 1; - - RESCALE_INPUT_INTERVAL; - } - else - { - prob_ptr = ((prob_ptr - first) >> 1) + first; /* model update */ - /* - * Decode the LPS '1' - */ - low = count; - - RESCALE_INPUT_INTERVAL; - /* - * Restore the transition (weight = -1) - */ - append_edge (row, 0, -1, 0, wfa); - total++; - } + count = high - ((high - low) >> *prob_ptr); + if (code < count) + { + if (prob_ptr < last) /* model update */ + prob_ptr++; + /* + * Decode the MPS '0' + */ + high = count - 1; + + RESCALE_INPUT_INTERVAL; + } + else + { + prob_ptr = ((prob_ptr - first) >> 1) + first; /* model update */ + /* + * Decode the LPS '1' + */ + low = count; + + RESCALE_INPUT_INTERVAL; + /* + * Restore the transition (weight = -1) + */ + append_edge (row, 0, -1, 0, wfa); + total++; + } } /* * Read label 1 element */ if (isrange (*is_leaf++)) /* valid matrix index */ { - count = high - ((high - low) >> *prob_ptr); - if (code < count) - { - if (prob_ptr < last) - prob_ptr++; /* model update */ - /* - * Decode the MPS '0' - */ - high = count - 1; - - RESCALE_INPUT_INTERVAL; - } - else - { - prob_ptr = ((prob_ptr - first) >> 1) + first; /* model update */ - /* - * Decode the LPS '1' - */ - low = count; - - RESCALE_INPUT_INTERVAL; - /* - * Restore the transition (weight = -1) - */ - append_edge (row, 0, -1, 1, wfa); - total++; - } + count = high - ((high - low) >> *prob_ptr); + if (code < count) + { + if (prob_ptr < last) + prob_ptr++; /* model update */ + /* + * Decode the MPS '0' + */ + high = count - 1; + + RESCALE_INPUT_INTERVAL; + } + else + { + prob_ptr = ((prob_ptr - first) >> 1) + first; /* model update */ + /* + * Decode the LPS '1' + */ + low = count; + + RESCALE_INPUT_INTERVAL; + /* + * Restore the transition (weight = -1) + */ + append_edge (row, 0, -1, 1, wfa); + total++; + } } } @@ -408,24 +408,24 @@ chroma_decoding (wfa_t *wfa, bitfile_t *input) * chroma channels Cb and Cr from stream 'input'. * * Return value: - * number of non-zero matrix elements (WFA edges) + * number of non-zero matrix elements (WFA edges) * * Side effects: - * 'wfa->into' is filled with decoded values + * 'wfa->into' is filled with decoded values */ { - unsigned domain; /* current domain, counter */ - unsigned total = 0; /* total number of chroma edges */ - unsigned *prob_ptr; /* pointer to current probability */ - unsigned *last; /* pointer to minimum probability */ - unsigned *first; /* pointer to maximum probability */ - unsigned *new_prob_ptr; /* ptr to probability of last domain */ - unsigned *prob; /* probability array */ - u_word_t high; /* Start of the current code range */ - u_word_t low; /* End of the current code range */ - u_word_t code; /* The present input code value */ - word_t *y_domains; /* domain images corresponding to Y */ - int save_index; /* YES: store current probability */ + unsigned domain; /* current domain, counter */ + unsigned total = 0; /* total number of chroma edges */ + unsigned *prob_ptr; /* pointer to current probability */ + unsigned *last; /* pointer to minimum probability */ + unsigned *first; /* pointer to maximum probability */ + unsigned *new_prob_ptr; /* ptr to probability of last domain */ + unsigned *prob; /* probability array */ + u_word_t high; /* Start of the current code range */ + u_word_t low; /* End of the current code range */ + u_word_t code; /* The present input code value */ + word_t *y_domains; /* domain images corresponding to Y */ + int save_index; /* YES: store current probability */ /* * Compute the asymmetric probability array @@ -434,26 +434,26 @@ chroma_decoding (wfa_t *wfa, bitfile_t *input) */ { unsigned n; - unsigned index; /* probability index */ - unsigned exp; /* current exponent */ + unsigned index; /* probability index */ + unsigned exp; /* current exponent */ prob = Calloc (1 << (MAX_PROB + 1), sizeof (unsigned)); for (index = 0, n = MIN_PROB; n <= MAX_PROB; n++) - for (exp = 0; exp < 1U << n; exp++, index++) - prob [index] = n; + for (exp = 0; exp < 1U << n; exp++, index++) + prob [index] = n; } - high = HIGH; /* 1.0 */ - low = LOW; /* 0.0 */ + high = HIGH; /* 1.0 */ + low = LOW; /* 0.0 */ code = get_bits (input, 16); /* * Compute list of admitted domains */ y_domains = compute_hits (wfa->basis_states, - wfa->tree [wfa->tree [wfa->root_state][0]][0], - wfa->wfainfo->chroma_max_states, wfa); + wfa->tree [wfa->tree [wfa->root_state][0]][0], + wfa->wfainfo->chroma_max_states, wfa); first = prob_ptr = new_prob_ptr = prob; last = first + 1020; @@ -465,7 +465,7 @@ chroma_decoding (wfa_t *wfa, bitfile_t *input) */ for (domain = 0; y_domains [domain] != -1; domain++) { - unsigned row = wfa->tree [wfa->tree [wfa->root_state][0]][0] + 1; + unsigned row = wfa->tree [wfa->tree [wfa->root_state][0]][0] + 1; word_t *is_leaf = wfa->tree [row]; prob_ptr = new_prob_ptr; @@ -473,87 +473,87 @@ chroma_decoding (wfa_t *wfa, bitfile_t *input) for (; row < wfa->states; row++) { - unsigned count; /* value in the current interval */ - /* - * Read label 0 element - */ - if (isrange (*is_leaf++)) /* valid matrix index */ - { - count = high - ((high - low) >> *prob_ptr); - if (code < count) - { - if (prob_ptr < last) - prob_ptr++; - /* - * Decode the MPS '0' - */ - high = count - 1; - - RESCALE_INPUT_INTERVAL; - } - else - { - prob_ptr = ((prob_ptr - first) >> 1) + first; - /* - * Decode the LPS '1' - */ - low = count; - - RESCALE_INPUT_INTERVAL; - /* - * Restore the transition (weight = -1) - */ - append_edge (row, y_domains [domain], -1, 0, wfa); - total++; - } - } - /* - * Read label 1 element - */ - if (isrange (*is_leaf++)) /* valid matrix index */ - { - count = high - ((high - low) >> *prob_ptr); - if (code < count) - { - if (prob_ptr < last) - prob_ptr++; - /* - * Decode the MPS '0' - */ - high = count - 1; - - RESCALE_INPUT_INTERVAL; - } - else - { - prob_ptr = ((prob_ptr - first) >> 1) + first; - /* - * Decode the LPS '1' - */ - low = count; - - RESCALE_INPUT_INTERVAL; - /* - * Restore the transition (weight = -1) - */ - append_edge (row, y_domains [domain], -1, 1, wfa); - total++; - } - } - if (save_index) - { - save_index = NO; - new_prob_ptr = prob_ptr; - } + unsigned count; /* value in the current interval */ + /* + * Read label 0 element + */ + if (isrange (*is_leaf++)) /* valid matrix index */ + { + count = high - ((high - low) >> *prob_ptr); + if (code < count) + { + if (prob_ptr < last) + prob_ptr++; + /* + * Decode the MPS '0' + */ + high = count - 1; + + RESCALE_INPUT_INTERVAL; + } + else + { + prob_ptr = ((prob_ptr - first) >> 1) + first; + /* + * Decode the LPS '1' + */ + low = count; + + RESCALE_INPUT_INTERVAL; + /* + * Restore the transition (weight = -1) + */ + append_edge (row, y_domains [domain], -1, 0, wfa); + total++; + } + } + /* + * Read label 1 element + */ + if (isrange (*is_leaf++)) /* valid matrix index */ + { + count = high - ((high - low) >> *prob_ptr); + if (code < count) + { + if (prob_ptr < last) + prob_ptr++; + /* + * Decode the MPS '0' + */ + high = count - 1; + + RESCALE_INPUT_INTERVAL; + } + else + { + prob_ptr = ((prob_ptr - first) >> 1) + first; + /* + * Decode the LPS '1' + */ + low = count; + + RESCALE_INPUT_INTERVAL; + /* + * Restore the transition (weight = -1) + */ + append_edge (row, y_domains [domain], -1, 1, wfa); + total++; + } + } + if (save_index) + { + save_index = NO; + new_prob_ptr = prob_ptr; + } } } Free (y_domains); compute_y_state (wfa->tree [wfa->tree [wfa->root_state][0]][1], - wfa->tree [wfa->tree [wfa->root_state][0]][0], wfa); + wfa->tree [wfa->tree [wfa->root_state][0]][0], wfa); compute_y_state (wfa->tree [wfa->tree [wfa->root_state][1]][0], - wfa->tree [wfa->tree [wfa->root_state][0]][0], wfa); + wfa->tree [wfa->tree [wfa->root_state][0]][0], wfa); first = prob_ptr = new_prob_ptr = prob; @@ -565,44 +565,44 @@ chroma_decoding (wfa_t *wfa, bitfile_t *input) * Again, quasi arithmetic decoding is used for this task. */ { - unsigned row; + unsigned row; for (row = wfa->tree [wfa->tree [wfa->root_state][0]][0] + 1; - row < wfa->states; row++) + row < wfa->states; row++) { - int label; /* current label */ - - for (label = 0; label < MAXLABELS; label++) - { - u_word_t count = high - ((high - low) >> *prob_ptr); - - if (code < count) - { - if (prob_ptr < last) - prob_ptr++; - /* - * Decode the MPS '0' - */ - high = count - 1; - - RESCALE_INPUT_INTERVAL; - } - else - { - prob_ptr = ((prob_ptr - first) >> 1) + first; - /* - * Decode the LPS '1' - */ - low = count; - - RESCALE_INPUT_INTERVAL; - /* - * Restore the transition (weight = -1) - */ - append_edge (row, wfa->y_state [row][label], -1, label, wfa); - total++; - } - } + int label; /* current label */ + + for (label = 0; label < MAXLABELS; label++) + { + u_word_t count = high - ((high - low) >> *prob_ptr); + + if (code < count) + { + if (prob_ptr < last) + prob_ptr++; + /* + * Decode the MPS '0' + */ + high = count - 1; + + RESCALE_INPUT_INTERVAL; + } + else + { + prob_ptr = ((prob_ptr - first) >> 1) + first; + /* + * Decode the LPS '1' + */ + low = count; + + RESCALE_INPUT_INTERVAL; + /* + * Restore the transition (weight = -1) + */ + append_edge (row, wfa->y_state [row][label], -1, label, wfa); + total++; + } + } } } @@ -625,20 +625,20 @@ compute_y_state (int state, int y_state, wfa_t *wfa) * No return value. * * Side effects: - * 'wfa->y_state' is filled with the generated tree structure. + * 'wfa->y_state' is filled with the generated tree structure. */ { unsigned label; for (label = 0; label < MAXLABELS; label++) if (isrange (y_state)) - wfa->y_state [state][label] = RANGE; + wfa->y_state [state][label] = RANGE; else { - wfa->y_state [state][label] = wfa->tree [y_state][label]; - if (!isrange (wfa->tree [state][label])) - compute_y_state (wfa->tree [state][label], - wfa->y_state [state][label], wfa); + wfa->y_state [state][label] = wfa->tree [y_state][label]; + if (!isrange (wfa->tree [state][label])) + compute_y_state (wfa->tree [state][label], + wfa->y_state [state][label], wfa); } } diff --git a/converter/other/fiasco/input/matrices.h b/converter/other/fiasco/input/matrices.h index 6d1cef15..193bc6a7 100644 --- a/converter/other/fiasco/input/matrices.h +++ b/converter/other/fiasco/input/matrices.h @@ -1,8 +1,8 @@ /* * matrices.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ diff --git a/converter/other/fiasco/input/mc.c b/converter/other/fiasco/input/mc.c index afc0c1c3..8d93d931 100644 --- a/converter/other/fiasco/input/mc.c +++ b/converter/other/fiasco/input/mc.c @@ -1,8 +1,8 @@ /* - * mc.c: Input of motion compensation + * mc.c: Input of motion compensation * * written by: Michael Unger - * Ullrich Hafner + * Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -31,27 +31,27 @@ /***************************************************************************** - local variables + local variables *****************************************************************************/ typedef struct huff_node { - int code_index; /* leaf if index >= 0 */ - struct huff_node *left; /* follow if '0' bit read */ - struct huff_node *right; /* follow if '1' bit read */ - int index_set [34]; + int code_index; /* leaf if index >= 0 */ + struct huff_node *left; /* follow if '0' bit read */ + struct huff_node *right; /* follow if '1' bit read */ + int index_set [34]; } huff_node_t; /***************************************************************************** - prototypes + prototypes *****************************************************************************/ static void decode_mc_tree (frame_type_e frame_type, unsigned max_state, - wfa_t *wfa, bitfile_t *input); + wfa_t *wfa, bitfile_t *input); static void decode_mc_coords (unsigned max_state, wfa_t *wfa, bitfile_t *input); static int @@ -63,7 +63,7 @@ create_huff_node (huff_node_t *hn, int bits_processed); /***************************************************************************** - public code + public code *****************************************************************************/ @@ -76,12 +76,12 @@ read_mc (frame_type_e frame_type, wfa_t *wfa, bitfile_t *input) * No return value. * * Side effects: - * 'wfa->mv_tree' is filled with the decoded values. + * 'wfa->mv_tree' is filled with the decoded values. */ { unsigned max_state = wfa->wfainfo->color - ? wfa->tree [wfa->tree [wfa->root_state][0]][0] - : wfa->states; + ? wfa->tree [wfa->tree [wfa->root_state][0]][0] + : wfa->states; decode_mc_tree (frame_type, max_state, wfa, input); decode_mc_coords (max_state, wfa, input); @@ -89,13 +89,13 @@ read_mc (frame_type_e frame_type, wfa_t *wfa, bitfile_t *input) /***************************************************************************** - private code + private code *****************************************************************************/ static void decode_mc_tree (frame_type_e frame_type, unsigned max_state, - wfa_t *wfa, bitfile_t *input) + wfa_t *wfa, bitfile_t *input) /* * Read tree of motion compensation decisions of the 'input' stream. * Depending on 'frame_type' different decoding methods are used. @@ -104,13 +104,13 @@ decode_mc_tree (frame_type_e frame_type, unsigned max_state, * No return value. * * Side effects: - * 'wfa->mv_tree' is filled with decoded values. + * 'wfa->mv_tree' is filled with decoded values. */ { - unsigned state; /* current state */ - unsigned *queue; /* states in breadth first order */ - unsigned last; /* last node - (update for each new node) */ + unsigned state; /* current state */ + unsigned *queue; /* states in breadth first order */ + unsigned last; /* last node + (update for each new node) */ /* * Traverse tree in breadth first order (starting at level @@ -120,68 +120,68 @@ decode_mc_tree (frame_type_e frame_type, unsigned max_state, queue = Calloc (MAXSTATES, sizeof (unsigned)); for (last = 0, state = wfa->basis_states; state < max_state; state++) if (wfa->level_of_state [state] - 1 == (int) wfa->wfainfo->p_max_level) - queue [last++] = state; /* init level 'p_max_level' */ + queue [last++] = state; /* init level 'p_max_level' */ if (frame_type == P_FRAME) { - unsigned label; /* current label */ - unsigned current; /* current node to process */ + unsigned label; /* current label */ + unsigned current; /* current node to process */ for (current = 0; current < last; current++) - for (label = 0; label < MAXLABELS; label++) - { - state = queue[current]; - if (wfa->x [state][label] /* process visible states only */ - + width_of_level (wfa->level_of_state [state] - 1) - <= wfa->wfainfo->width - && - wfa->y [state][label] - + height_of_level (wfa->level_of_state [state] - 1) - <= wfa->wfainfo->height) - { - wfa->mv_tree [state][label].type - = get_bit (input) ? NONE : FORWARD; - } - else - wfa->mv_tree [state][label].type = NONE; - if (wfa->mv_tree [state][label].type == NONE && - !isrange (wfa->tree [state][label]) && - wfa->level_of_state [state] - 1 >= - (int) wfa->wfainfo->p_min_level) - queue [last++] = wfa->tree [state][label]; /* append child */ - } + for (label = 0; label < MAXLABELS; label++) + { + state = queue[current]; + if (wfa->x [state][label] /* process visible states only */ + + width_of_level (wfa->level_of_state [state] - 1) + <= wfa->wfainfo->width + && + wfa->y [state][label] + + height_of_level (wfa->level_of_state [state] - 1) + <= wfa->wfainfo->height) + { + wfa->mv_tree [state][label].type + = get_bit (input) ? NONE : FORWARD; + } + else + wfa->mv_tree [state][label].type = NONE; + if (wfa->mv_tree [state][label].type == NONE && + !isrange (wfa->tree [state][label]) && + wfa->level_of_state [state] - 1 >= + (int) wfa->wfainfo->p_min_level) + queue [last++] = wfa->tree [state][label]; /* append child */ + } } else { - unsigned label; /* current label */ - unsigned current; /* current node to process */ + unsigned label; /* current label */ + unsigned current; /* current node to process */ for (current = 0; current < last; current++) - for (label = 0; label < MAXLABELS; label++) - { - state = queue[current]; - if (wfa->x [state][label] /* process visible states only */ - + width_of_level (wfa->level_of_state [state] - 1) - > wfa->wfainfo->width - || - wfa->y [state][label] - + height_of_level (wfa->level_of_state [state] - 1) - > wfa->wfainfo->height) - wfa->mv_tree[state][label].type = NONE; - else if (get_bit (input)) /* 1 */ - wfa->mv_tree[state][label].type = NONE; - else if (get_bit (input)) /* 01 */ - wfa->mv_tree[state][label].type = INTERPOLATED; - else if (get_bit (input)) /* 001 */ - wfa->mv_tree[state][label].type = BACKWARD; - else /* 000 */ - wfa->mv_tree[state][label].type = FORWARD; - if (wfa->mv_tree[state][label].type == NONE && - !isrange (wfa->tree[state][label]) && - wfa->level_of_state[state] - 1 - >= (int) wfa->wfainfo->p_min_level) - queue[last++] = wfa->tree[state][label]; /* append child */ - } + for (label = 0; label < MAXLABELS; label++) + { + state = queue[current]; + if (wfa->x [state][label] /* process visible states only */ + + width_of_level (wfa->level_of_state [state] - 1) + > wfa->wfainfo->width + || + wfa->y [state][label] + + height_of_level (wfa->level_of_state [state] - 1) + > wfa->wfainfo->height) + wfa->mv_tree[state][label].type = NONE; + else if (get_bit (input)) /* 1 */ + wfa->mv_tree[state][label].type = NONE; + else if (get_bit (input)) /* 01 */ + wfa->mv_tree[state][label].type = INTERPOLATED; + else if (get_bit (input)) /* 001 */ + wfa->mv_tree[state][label].type = BACKWARD; + else /* 000 */ + wfa->mv_tree[state][label].type = FORWARD; + if (wfa->mv_tree[state][label].type == NONE && + !isrange (wfa->tree[state][label]) && + wfa->level_of_state[state] - 1 + >= (int) wfa->wfainfo->p_min_level) + queue[last++] = wfa->tree[state][label]; /* append child */ + } } INPUT_BYTE_ALIGN (input); @@ -198,12 +198,12 @@ decode_mc_coords (unsigned max_state, wfa_t *wfa, bitfile_t *input) * No return value. * * Side effects: - * 'wfa->mv_tree' is filled with decoded values. + * 'wfa->mv_tree' is filled with decoded values. */ { - unsigned label; /* current label */ - unsigned state; /* current state */ - mv_t *mv; /* current motion vector */ + unsigned label; /* current label */ + unsigned state; /* current state */ + mv_t *mv; /* current motion vector */ static huff_node_t *huff_mv_root = NULL; /* root of huffman tree */ if (huff_mv_root == NULL) @@ -212,26 +212,26 @@ decode_mc_coords (unsigned max_state, wfa_t *wfa, bitfile_t *input) for (state = wfa->basis_states; state < max_state; state++) for (label = 0; label < MAXLABELS; label++) { - mv = &wfa->mv_tree[state][label]; - switch (mv->type) - { - case NONE: - break; - case FORWARD: - mv->fx = get_mv (1, huff_mv_root, input); - mv->fy = get_mv (1, huff_mv_root, input); - break; - case BACKWARD: - mv->bx = get_mv (1, huff_mv_root, input); - mv->by = get_mv (1, huff_mv_root, input); - break; - case INTERPOLATED: - mv->fx = get_mv (1, huff_mv_root, input); - mv->fy = get_mv (1, huff_mv_root, input); - mv->bx = get_mv (1, huff_mv_root, input); - mv->by = get_mv (1, huff_mv_root, input); - break; - } + mv = &wfa->mv_tree[state][label]; + switch (mv->type) + { + case NONE: + break; + case FORWARD: + mv->fx = get_mv (1, huff_mv_root, input); + mv->fy = get_mv (1, huff_mv_root, input); + break; + case BACKWARD: + mv->bx = get_mv (1, huff_mv_root, input); + mv->by = get_mv (1, huff_mv_root, input); + break; + case INTERPOLATED: + mv->fx = get_mv (1, huff_mv_root, input); + mv->fy = get_mv (1, huff_mv_root, input); + mv->bx = get_mv (1, huff_mv_root, input); + mv->by = get_mv (1, huff_mv_root, input); + break; + } } INPUT_BYTE_ALIGN (input); @@ -249,11 +249,11 @@ get_mv (int f_code, huff_node_t *hn, bitfile_t *input) while (hn->code_index < 0) { if (hn->code_index == -2) - error ("wrong huffman code !"); + error ("wrong huffman code !"); if (get_bit (input)) - hn = hn->right; + hn = hn->right; else - hn = hn->left; + hn = hn->left; } vlc_code = hn->code_index - 16; if (vlc_code == 0 || f_code == 1) @@ -275,7 +275,7 @@ create_huff_tree (void) * Construct huffman tree from code table */ { - unsigned i; + unsigned i; huff_node_t *huff_root = Calloc (1, sizeof (huff_node_t)); /* @@ -286,7 +286,7 @@ create_huff_tree (void) for (i = 0; i < 33; i++) huff_root->index_set [i] = i; - huff_root->index_set [i] = -1; /* end marker */ + huff_root->index_set [i] = -1; /* end marker */ create_huff_node (huff_root, 0); @@ -299,14 +299,14 @@ create_huff_node (huff_node_t *hn, int bits_processed) * Create one node in the huffman tree */ { - int lind = 0; /* next index of left huff_node */ - int rind = 0; /* next index of right huff_node */ + int lind = 0; /* next index of left huff_node */ + int rind = 0; /* next index of right huff_node */ int code_len, i, ind; hn->code_index = -1; - if (hn->index_set [0] < 0) /* empty index set ? */ + if (hn->index_set [0] < 0) /* empty index set ? */ { - hn->code_index = -2; /* error */ + hn->code_index = -2; /* error */ return; } hn->left = Calloc (1, sizeof (huff_node_t)); @@ -315,19 +315,19 @@ create_huff_node (huff_node_t *hn, int bits_processed) for (i = 0; (ind = hn->index_set[i]) >= 0; i++) { code_len = mv_code_table[ind][1]; - if (code_len == bits_processed) /* generate leaf */ + if (code_len == bits_processed) /* generate leaf */ { - hn->code_index = ind; - Free (hn->left); - Free (hn->right); - return; + hn->code_index = ind; + Free (hn->left); + Free (hn->right); + return; } if (mv_code_table[ind][0] & (1 << (code_len - 1 - bits_processed))) - hn->right->index_set[rind++] = ind; + hn->right->index_set[rind++] = ind; else - hn->left->index_set[lind++] = ind; + hn->left->index_set[lind++] = ind; } - hn->right->index_set[rind] = -1; /* set end markers */ + hn->right->index_set[rind] = -1; /* set end markers */ hn->left->index_set[lind] = -1; create_huff_node (hn->left, bits_processed + 1); create_huff_node (hn->right, bits_processed + 1); diff --git a/converter/other/fiasco/input/mc.h b/converter/other/fiasco/input/mc.h index 9d9d714d..a61f7e4a 100644 --- a/converter/other/fiasco/input/mc.h +++ b/converter/other/fiasco/input/mc.h @@ -2,8 +2,8 @@ * mc.h * * written by: Michael Unger - * Ullrich Hafner - + * Ullrich Hafner + * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ diff --git a/converter/other/fiasco/input/nd.c b/converter/other/fiasco/input/nd.c index 129a150e..0317073a 100644 --- a/converter/other/fiasco/input/nd.c +++ b/converter/other/fiasco/input/nd.c @@ -1,7 +1,7 @@ /* - * nd.c: Input of prediction tree + * nd.c: Input of prediction tree * - * Written by: Ullrich Hafner + * Written by: Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -30,7 +30,7 @@ /***************************************************************************** - prototypes + prototypes *****************************************************************************/ @@ -41,7 +41,7 @@ decode_nd_tree (wfa_t *wfa, bitfile_t *input); /***************************************************************************** - public code + public code *****************************************************************************/ @@ -52,7 +52,7 @@ read_nd (wfa_t *wfa, bitfile_t *input) * ND is used only at levels {'wfa->p_min_level', ... , 'wfa->p_max_level'}. * * Side effects: - * 'wfa->into' and 'wfa->weights' are filled with the decoded values + * 'wfa->into' and 'wfa->weights' are filled with the decoded values */ { unsigned total = decode_nd_tree (wfa, input); @@ -63,7 +63,7 @@ read_nd (wfa_t *wfa, bitfile_t *input) /***************************************************************************** - private code + private code *****************************************************************************/ @@ -75,16 +75,16 @@ decode_nd_tree (wfa_t *wfa, bitfile_t *input) * No return value. * * Side effects: - * 'wfa->into' is filled with the decoded values + * 'wfa->into' is filled with the decoded values */ { - lqueue_t *queue; /* queue of states */ - int next, state; /* state and its current child */ - unsigned total = 0; /* total number of predicted states */ - u_word_t sum0, sum1; /* Probability model */ - u_word_t code; /* The present input code value */ - u_word_t low; /* Start of the current code range */ - u_word_t high; /* End of the current code range */ + lqueue_t *queue; /* queue of states */ + int next, state; /* state and its current child */ + unsigned total = 0; /* total number of predicted states */ + u_word_t sum0, sum1; /* Probability model */ + u_word_t code; /* The present input code value */ + u_word_t low; /* Start of the current code range */ + u_word_t high; /* End of the current code range */ /* * Initialize arithmetic decoder @@ -108,78 +108,78 @@ decode_nd_tree (wfa_t *wfa, bitfile_t *input) if (wfa->level_of_state [next] > wfa->wfainfo->p_max_level + 1) { - /* - * Nondetermismn is not allowed at levels larger than - * 'wfa->wfainfo->p_max_level'. - */ - for (label = 0; label < MAXLABELS; label++) - if (ischild (state = wfa->tree [next][label])) - queue_append (queue, &state); /* continue with children */ + /* + * Nondetermismn is not allowed at levels larger than + * 'wfa->wfainfo->p_max_level'. + */ + for (label = 0; label < MAXLABELS; label++) + if (ischild (state = wfa->tree [next][label])) + queue_append (queue, &state); /* continue with children */ } else if (wfa->level_of_state [next] > wfa->wfainfo->p_min_level) { - for (label = 0; label < MAXLABELS; label++) - if (ischild (state = wfa->tree [next][label])) - { - unsigned count; /* Current interval count */ - unsigned range; /* Current interval range */ - - count = (((code - low) + 1) * sum1 - 1) / ((high - low) + 1); - if (count < sum0) - { - /* - * Decode a '0' symbol - * First, the range is expanded to account for the - * symbol removal. - */ - range = (high - low) + 1; - high = low + (u_word_t) ((range * sum0) / sum1 - 1 ); - RESCALE_INPUT_INTERVAL; - /* - * Update the frequency counts - */ - sum0++; - sum1++; - if (sum1 > 50) /* scale the symbol frequencies */ - { - sum0 >>= 1; - sum1 >>= 1; - if (!sum0) - sum0 = 1; - if (sum0 >= sum1) - sum1 = sum0 + 1; - } - if (wfa->level_of_state [state] > wfa->wfainfo->p_min_level) - queue_append (queue, &state); - } - else - { - /* - * Decode a '1' symbol - * First, the range is expanded to account for the - * symbol removal. - */ - range = (high - low) + 1; - high = low + (u_word_t) ((range * sum1) / sum1 - 1); - low = low + (u_word_t) ((range * sum0) / sum1); - RESCALE_INPUT_INTERVAL; - /* - * Update the frequency counts - */ - sum1++; - if (sum1 > 50) /* scale the symbol frequencies */ - { - sum0 >>= 1; - sum1 >>= 1; - if (!sum0) - sum0 = 1; - if (sum0 >= sum1) - sum1 = sum0 + 1; - } - append_edge (next, 0, -1, label, wfa); - total++; - } - } + for (label = 0; label < MAXLABELS; label++) + if (ischild (state = wfa->tree [next][label])) + { + unsigned count; /* Current interval count */ + unsigned range; /* Current interval range */ + + count = (((code - low) + 1) * sum1 - 1) / ((high - low) + 1); + if (count < sum0) + { + /* + * Decode a '0' symbol + * First, the range is expanded to account for the + * symbol removal. + */ + range = (high - low) + 1; + high = low + (u_word_t) ((range * sum0) / sum1 - 1 ); + RESCALE_INPUT_INTERVAL; + /* + * Update the frequency counts + */ + sum0++; + sum1++; + if (sum1 > 50) /* scale the symbol frequencies */ + { + sum0 >>= 1; + sum1 >>= 1; + if (!sum0) + sum0 = 1; + if (sum0 >= sum1) + sum1 = sum0 + 1; + } + if (wfa->level_of_state [state] > wfa->wfainfo->p_min_level) + queue_append (queue, &state); + } + else + { + /* + * Decode a '1' symbol + * First, the range is expanded to account for the + * symbol removal. + */ + range = (high - low) + 1; + high = low + (u_word_t) ((range * sum1) / sum1 - 1); + low = low + (u_word_t) ((range * sum0) / sum1); + RESCALE_INPUT_INTERVAL; + /* + * Update the frequency counts + */ + sum1++; + if (sum1 > 50) /* scale the symbol frequencies */ + { + sum0 >>= 1; + sum1 >>= 1; + if (!sum0) + sum0 = 1; + if (sum0 >= sum1) + sum1 = sum0 + 1; + } + append_edge (next, 0, -1, label, wfa); + total++; + } + } } } free_queue (queue); @@ -199,21 +199,21 @@ decode_nd_coefficients (unsigned total, wfa_t *wfa, bitfile_t *input) * No return value. * * Side effects: - * 'wfa->weights' is filled with the decoded values. + * 'wfa->weights' is filled with the decoded values. */ { - unsigned *coefficients; /* array of factors to encode */ - unsigned *ptr; /* pointer to current factor */ + unsigned *coefficients; /* array of factors to encode */ + unsigned *ptr; /* pointer to current factor */ /* * Decode array of coefficients stored with arithmetic coding */ { - const int scaling = 50; /* scaling factor of prob. model */ + const int scaling = 50; /* scaling factor of prob. model */ unsigned c_symbols = 1 << (wfa->wfainfo->dc_rpf->mantissa_bits + 1); ptr = coefficients = decode_array (input, NULL, &c_symbols, 1, - total, scaling); + total, scaling); } /* @@ -223,15 +223,15 @@ decode_nd_coefficients (unsigned total, wfa_t *wfa, bitfile_t *input) unsigned state, label; for (state = wfa->basis_states; state < wfa->states; state++) - for (label = 0; label < MAXLABELS; label++) - if (ischild (wfa->tree [state][label]) - && isedge (wfa->into [state][label][0])) - { - wfa->weight [state][label][0] = btor (*ptr++, - wfa->wfainfo->dc_rpf); - wfa->int_weight [state][label][0] - = wfa->weight [state][label][0] * 512 + 0.5; - } + for (label = 0; label < MAXLABELS; label++) + if (ischild (wfa->tree [state][label]) + && isedge (wfa->into [state][label][0])) + { + wfa->weight [state][label][0] = btor (*ptr++, + wfa->wfainfo->dc_rpf); + wfa->int_weight [state][label][0] + = wfa->weight [state][label][0] * 512 + 0.5; + } } Free (coefficients); } diff --git a/converter/other/fiasco/input/nd.h b/converter/other/fiasco/input/nd.h index 0fe06cf1..57f46440 100644 --- a/converter/other/fiasco/input/nd.h +++ b/converter/other/fiasco/input/nd.h @@ -1,8 +1,8 @@ /* * nd.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ diff --git a/converter/other/fiasco/input/read.c b/converter/other/fiasco/input/read.c index c3aa77a8..50e271e5 100644 --- a/converter/other/fiasco/input/read.c +++ b/converter/other/fiasco/input/read.c @@ -1,7 +1,7 @@ /* - * read.c: Input of WFA files + * read.c: Input of WFA files * - * Written by: Ullrich Hafner + * Written by: Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -46,17 +46,17 @@ /***************************************************************************** - prototypes + prototypes *****************************************************************************/ static void read_tiling (tiling_t *tiling, unsigned image_width, unsigned image_height, - unsigned image_level, bitfile_t *input); + unsigned image_level, bitfile_t *input); /***************************************************************************** - public code + public code *****************************************************************************/ @@ -66,14 +66,14 @@ open_wfa (const char *filename, wfa_info_t *wi) * Open WFA file 'filename' and read header information. * * Return value: - * Pointer to input stream (fileposition: first WFA frame) + * Pointer to input stream (fileposition: first WFA frame) * * Side effects: - * The values of the header of 'filename' are copied to 'wfainfo'. + * The values of the header of 'filename' are copied to 'wfainfo'. * */ { - bitfile_t *input; /* pointer to WFA bitfile */ + bitfile_t *input; /* pointer to WFA bitfile */ assert (filename && wi); @@ -83,7 +83,7 @@ open_wfa (const char *filename, wfa_info_t *wi) * Check whether 'filename' is a regular WFA file */ { - unsigned n; + unsigned n; const char *str; if (!(input = open_bitfile (filename, "FIASCO_DATA", READ_ACCESS))) @@ -92,57 +92,57 @@ open_wfa (const char *filename, wfa_info_t *wi) for (str = FIASCO_MAGIC, n = strlen (FIASCO_MAGIC); n; n--) if (get_bits (input, 8) != (unsigned) *str++) error ("Input file %s is not a valid FIASCO file!", filename); - get_bits (input, 8); /* fetch newline */ + get_bits (input, 8); /* fetch newline */ } /* * Read WFA header information */ { - char basis_name [MAXSTRLEN]; /* temp. buffer */ - const unsigned rice_k = 8; /* parameter of Rice Code */ - char *str = basis_name; + char basis_name [MAXSTRLEN]; /* temp. buffer */ + const unsigned rice_k = 8; /* parameter of Rice Code */ + char *str = basis_name; while ((*str++ = get_bits (input, 8)) != 0 - && str < basis_name + MAXSTRLEN) - ; + && str < basis_name + MAXSTRLEN) + ; if (str == basis_name + MAXSTRLEN) - error ("Input file %s is not a valid FIASCO file!", filename); + error ("Input file %s is not a valid FIASCO file!", filename); { - wi->release = read_rice_code (rice_k, input); + wi->release = read_rice_code (rice_k, input); - if (wi->release > FIASCO_BINFILE_RELEASE) - error ("Can't decode FIASCO files of file format release `%d'." - "\nCurrent file format release is `%d'.", wi->release, - FIASCO_BINFILE_RELEASE); + if (wi->release > FIASCO_BINFILE_RELEASE) + error ("Can't decode FIASCO files of file format release `%d'." + "\nCurrent file format release is `%d'.", wi->release, + FIASCO_BINFILE_RELEASE); } if (wi->release > 1) { - header_type_e type; - - while ((type = read_rice_code (rice_k, input)) != HEADER_END) - { - char buffer [MAXSTRLEN]; - unsigned n = 0; - - switch (type) - { - case HEADER_TITLE: - while ((buffer [n++] = get_bits (input, 8))) - ; - wi->title = strdup (buffer); - break; - case HEADER_COMMENT: - while ((buffer [n++] = get_bits (input, 8))) - ; - wi->comment = strdup (buffer); - break; - default: /* should not happen */ - break; - } - } + header_type_e type; + + while ((type = read_rice_code (rice_k, input)) != HEADER_END) + { + char buffer [MAXSTRLEN]; + unsigned n = 0; + + switch (type) + { + case HEADER_TITLE: + while ((buffer [n++] = get_bits (input, 8))) + ; + wi->title = strdup (buffer); + break; + case HEADER_COMMENT: + while ((buffer [n++] = get_bits (input, 8))) + ; + wi->comment = strdup (buffer); + break; + default: /* should not happen */ + break; + } + } } wi->basis_name = strdup (basis_name); @@ -155,65 +155,65 @@ open_wfa (const char *filename, wfa_info_t *wi) * Compute bintree level */ { - unsigned lx = log2 (wi->width - 1) + 1; - unsigned ly = log2 (wi->height - 1) + 1; + 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); wi->p_max_level = read_rice_code (rice_k, input); wi->frames = read_rice_code (rice_k, input); - wi->smoothing = read_rice_code (rice_k, input); + wi->smoothing = read_rice_code (rice_k, input); /* * Read RPF models from disk */ { - unsigned mantissa; - fiasco_rpf_range_e range; - - mantissa = get_bits (input, 3) + 2; - range = get_bits (input, 2); - wi->rpf = alloc_rpf (mantissa, range); - - if (get_bit (input)) /* different DC model */ - { - mantissa = get_bits (input, 3) + 2; - range = get_bits (input, 2); - wi->dc_rpf = alloc_rpf (mantissa, range); - } - else /* use same model for DC coefficients */ - wi->dc_rpf = alloc_rpf (wi->rpf->mantissa_bits, - wi->rpf->range_e); - - if (get_bit (input)) /* different delta model */ - { - mantissa = get_bits (input, 3) + 2; - range = get_bits (input, 2); - wi->d_rpf = alloc_rpf (mantissa, range); - } - else - wi->d_rpf = alloc_rpf (wi->rpf->mantissa_bits, - wi->rpf->range_e); - - if (get_bit (input)) /* different DC delta model */ - { - mantissa = get_bits (input, 3) + 2; - range = get_bits (input, 2); - wi->d_dc_rpf = alloc_rpf (mantissa, range); - } - else - wi->d_dc_rpf = alloc_rpf (wi->dc_rpf->mantissa_bits, - wi->dc_rpf->range_e); + unsigned mantissa; + fiasco_rpf_range_e range; + + mantissa = get_bits (input, 3) + 2; + range = get_bits (input, 2); + wi->rpf = alloc_rpf (mantissa, range); + + if (get_bit (input)) /* different DC model */ + { + mantissa = get_bits (input, 3) + 2; + range = get_bits (input, 2); + wi->dc_rpf = alloc_rpf (mantissa, range); + } + else /* use same model for DC coefficients */ + wi->dc_rpf = alloc_rpf (wi->rpf->mantissa_bits, + wi->rpf->range_e); + + if (get_bit (input)) /* different delta model */ + { + mantissa = get_bits (input, 3) + 2; + range = get_bits (input, 2); + wi->d_rpf = alloc_rpf (mantissa, range); + } + else + wi->d_rpf = alloc_rpf (wi->rpf->mantissa_bits, + wi->rpf->range_e); + + if (get_bit (input)) /* different DC delta model */ + { + mantissa = get_bits (input, 3) + 2; + range = get_bits (input, 2); + wi->d_dc_rpf = alloc_rpf (mantissa, range); + } + else + wi->d_dc_rpf = alloc_rpf (wi->dc_rpf->mantissa_bits, + wi->dc_rpf->range_e); } - if (wi->frames > 1) /* motion compensation stuff */ + if (wi->frames > 1) /* motion compensation stuff */ { - wi->fps = read_rice_code (rice_k, input); - wi->search_range = read_rice_code (rice_k, input); - wi->half_pixel = get_bit (input) ? YES : NO; - wi->B_as_past_ref = get_bit (input) ? YES : NO; + wi->fps = read_rice_code (rice_k, input); + wi->search_range = read_rice_code (rice_k, input); + wi->half_pixel = get_bit (input) ? YES : NO; + wi->B_as_past_ref = get_bit (input) ? YES : NO; } } @@ -230,12 +230,12 @@ read_basis (const char *filename, wfa_t *wfa) * No return value. * * Side effects: - * wfa->into, wfa->weights, wfa->final_distribution, wfa->basis_states - * wfa->domain_type wfa->wfainfo->basis_name, are filled with the - * values of the WFA basis. + * wfa->into, wfa->weights, wfa->final_distribution, wfa->basis_states + * wfa->domain_type wfa->wfainfo->basis_name, are filled with the + * values of the WFA basis. */ { - FILE *input; /* ASCII WFA initial basis file */ + FILE *input; /* ASCII WFA initial basis file */ assert (filename && wfa); @@ -243,27 +243,27 @@ read_basis (const char *filename, wfa_t *wfa) !streq (wfa->wfainfo->basis_name, filename)) { if (wfa->wfainfo->basis_name) - Free (wfa->wfainfo->basis_name); + Free (wfa->wfainfo->basis_name); wfa->wfainfo->basis_name = strdup (filename); } if (get_linked_basis (filename, wfa)) - return; /* basis is linked with executable */ + return; /* basis is linked with executable */ /* * Check whether 'wfa_name' is a regular ASCII WFA initial basis file */ { - char magic [MAXSTRLEN]; /* WFA magic number */ + char magic [MAXSTRLEN]; /* WFA magic number */ if (!(input = open_file (filename, "FIASCO_DATA", READ_ACCESS))) - file_error(filename); + file_error(filename); if (fscanf (input, MAXSTRLEN_SCANF, magic) != 1) - error ("Format error: ASCII FIASCO initial basis file %s", filename); + error ("Format error: ASCII FIASCO initial basis file %s", filename); else if (!streq (FIASCO_BASIS_MAGIC, magic)) - error ("Input file %s is not an ASCII FIASCO initial basis!", - filename); + error ("Input file %s is not an ASCII FIASCO initial basis!", + filename); } /* @@ -273,74 +273,74 @@ read_basis (const char *filename, wfa_t *wfa) * Don't define any transitions of state 0 in an initial basis. * * Header: - * type |description - * ----------------+----------- - * string |MAGIC Number "Wfa" - * int |Number of basis states 'N' - * bool_t-array[N] |use vector in linear combinations, - * |0: don't use vector (auxiliary state) - * |1: use vector in linear combinations - * float-array[N] |final distribution of every state + * type |description + * ----------------+----------- + * string |MAGIC Number "Wfa" + * int |Number of basis states 'N' + * bool_t-array[N] |use vector in linear combinations, + * |0: don't use vector (auxiliary state) + * |1: use vector in linear combinations + * float-array[N] |final distribution of every state * * Transitions: * - * <state 1> current state - * <label> <into> <weight> transition 1 of current state - * <label> <into> <weight> transition 2 of current state + * <state 1> current state + * <label> <into> <weight> transition 1 of current state + * <label> <into> <weight> transition 2 of current state * ... - * <-1> last transition marker + * <-1> last transition marker * <state 2> * ... - * <-1> last transition marker + * <-1> last transition marker * <state N> * ... * - * <-1> last transition marker - * <-1> last state marker + * <-1> last transition marker + * <-1> last state marker */ { unsigned state; if (fscanf (input ,"%u", &wfa->basis_states) != 1) - error ("Format error: ASCII FIASCO initial basis file %s", filename); + error ("Format error: ASCII FIASCO initial basis file %s", filename); /* * State 0 is assumed to be the constant function f(x, y) = 128. */ wfa->domain_type [0] = USE_DOMAIN_MASK; wfa->final_distribution [0] = 128; - wfa->states = wfa->basis_states; + wfa->states = wfa->basis_states; wfa->basis_states++; append_edge (0, 0, 1.0, 0, wfa); append_edge (0, 0, 1.0, 1, wfa); for (state = 1; state < wfa->basis_states; state++) - wfa->domain_type [state] - = read_int (input) ? USE_DOMAIN_MASK : AUXILIARY_MASK; + wfa->domain_type [state] + = read_int (input) ? USE_DOMAIN_MASK : AUXILIARY_MASK; for (state = 1; state < wfa->basis_states; state++) - wfa->final_distribution[state] = read_real (input); + wfa->final_distribution[state] = read_real (input); /* * Read transitions */ for (state = 1; state < wfa->basis_states; state++) { - unsigned domain; - int label; - real_t weight; - - if (read_int (input) != (int) state) - error ("Format error: ASCII FIASCO initial basis file %s", - filename); - - while((label = read_int (input)) != -1) - { - domain = read_int (input); - weight = read_real (input); - append_edge (state, domain, weight, label, wfa); - } + unsigned domain; + int label; + real_t weight; + + if (read_int (input) != (int) state) + error ("Format error: ASCII FIASCO initial basis file %s", + filename); + + while((label = read_int (input)) != -1) + { + domain = read_int (input); + weight = read_real (input); + append_edge (state, domain, weight, label, wfa); + } } } @@ -357,13 +357,13 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) * No return value. * * Side effects: - * wfa->into, wfa->weights, wfa->final_distribution, wfa->states - * wfa->x, wfa->y, wfa->level_of_state, wfa->domain_type + * wfa->into, wfa->weights, wfa->final_distribution, wfa->states + * wfa->x, wfa->y, wfa->level_of_state, wfa->domain_type * mt->type, mt->number are filled with the values of the WFA file. */ { - tiling_t tiling; /* tiling information */ - unsigned frame_number; /* current frame number */ + tiling_t tiling; /* tiling information */ + unsigned frame_number; /* current frame number */ assert (wfa && input); @@ -371,14 +371,14 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) * Frame header information */ { - const unsigned rice_k = 8; /* parameter of Rice Code */ + const unsigned rice_k = 8; /* parameter of Rice Code */ wfa->states = read_rice_code (rice_k, input); wfa->frame_type = read_rice_code (rice_k, input); frame_number = read_rice_code (rice_k, input); } - if (wfa->wfainfo->release > 1) /* no alignment in version 1 */ + if (wfa->wfainfo->release > 1) /* no alignment in version 1 */ { INPUT_BYTE_ALIGN (input); } @@ -386,9 +386,9 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) /* * Read image tiling info */ - if (get_bit (input)) /* tiling performed ? */ + if (get_bit (input)) /* tiling performed ? */ read_tiling (&tiling, wfa->wfainfo->width, wfa->wfainfo->height, - wfa->wfainfo->level, input); + wfa->wfainfo->level, input); else tiling.exponent = 0; @@ -404,30 +404,30 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) unsigned state; for (state = wfa->basis_states; state < wfa->states; state++) - if ((!wfa->wfainfo->color - || (int) state <= wfa->tree [wfa->tree [wfa->root_state][0]][0]) - && - (!tiling.exponent || - wfa->level_of_state [state] <= (wfa->wfainfo->level - - tiling.exponent)) - && ((wfa->x [state][0] - + width_of_level (wfa->level_of_state [state])) - <= wfa->wfainfo->width) - && ((wfa->y [state][0] - + height_of_level (wfa->level_of_state [state])) - <= wfa->wfainfo->height)) - wfa->domain_type [state] = USE_DOMAIN_MASK; - else - wfa->domain_type [state] = 0; + if ((!wfa->wfainfo->color + || (int) state <= wfa->tree [wfa->tree [wfa->root_state][0]][0]) + && + (!tiling.exponent || + wfa->level_of_state [state] <= (wfa->wfainfo->level + - tiling.exponent)) + && ((wfa->x [state][0] + + width_of_level (wfa->level_of_state [state])) + <= wfa->wfainfo->width) + && ((wfa->y [state][0] + + height_of_level (wfa->level_of_state [state])) + <= wfa->wfainfo->height)) + wfa->domain_type [state] = USE_DOMAIN_MASK; + else + wfa->domain_type [state] = 0; } if (tiling.exponent) Free (tiling.vorder); - if (get_bit (input)) /* nondeterministic prediction used */ + if (get_bit (input)) /* nondeterministic prediction used */ read_nd (wfa, input); - if (wfa->frame_type != I_FRAME) /* motion compensation used */ + if (wfa->frame_type != I_FRAME) /* motion compensation used */ read_mc (wfa->frame_type, wfa, input); locate_delta_images (wfa); @@ -439,7 +439,7 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) unsigned edges = read_matrices (wfa, input); if (edges) - read_weights (edges, wfa, input); + read_weights (edges, wfa, input); } /* @@ -449,8 +449,8 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) unsigned state; for (state = wfa->basis_states; state <= wfa->states; state++) - wfa->final_distribution[state] - = compute_final_distribution (state, wfa); + wfa->final_distribution[state] + = compute_final_distribution (state, wfa); } return frame_number; @@ -458,13 +458,13 @@ read_next_wfa (wfa_t *wfa, bitfile_t *input) /***************************************************************************** - private code + private code *****************************************************************************/ static void read_tiling (tiling_t *tiling, unsigned image_width, unsigned image_height, - unsigned image_level, bitfile_t *input) + unsigned image_level, bitfile_t *input) /* * Read image tiling information from the given file 'input' * and store parameters in struct 'tiling'. @@ -472,32 +472,32 @@ read_tiling (tiling_t *tiling, unsigned image_width, unsigned image_height, * No return value. */ { - const unsigned rice_k = 8; /* parameter of Rice Code */ + const unsigned rice_k = 8; /* parameter of Rice Code */ tiling->exponent = read_rice_code (rice_k, input); - if (get_bit (input)) /* variance order */ + if (get_bit (input)) /* variance order */ { - unsigned tile; /* current image tile */ - unsigned x0, y0; /* NW corner of image tile */ - unsigned width, height; /* size of image tile */ + unsigned tile; /* current image tile */ + unsigned x0, y0; /* NW corner of image tile */ + unsigned width, height; /* size of image tile */ tiling->vorder = Calloc (1 << tiling->exponent, sizeof (int)); for (tile = 0; tile < 1U << tiling->exponent; tile++) { - locate_subimage (image_level, image_level - tiling->exponent, tile, - &x0, &y0, &width, &height); - if (x0 < image_width && y0 < image_height) - tiling->vorder [tile] = get_bits (input, tiling->exponent); - else - tiling->vorder [tile] = -1; + locate_subimage (image_level, image_level - tiling->exponent, tile, + &x0, &y0, &width, &height); + if (x0 < image_width && y0 < image_height) + tiling->vorder [tile] = get_bits (input, tiling->exponent); + else + tiling->vorder [tile] = -1; } } - else /* spiral order */ + else /* spiral order */ { tiling->vorder = Calloc (1 << tiling->exponent, sizeof (int)); compute_spiral (tiling->vorder, image_width, image_height, - tiling->exponent, get_bit (input) ? YES : NO); + tiling->exponent, get_bit (input) ? YES : NO); } } diff --git a/converter/other/fiasco/input/read.h b/converter/other/fiasco/input/read.h index 1f59f103..f41cb874 100644 --- a/converter/other/fiasco/input/read.h +++ b/converter/other/fiasco/input/read.h @@ -1,8 +1,8 @@ /* * read.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ diff --git a/converter/other/fiasco/input/tree.c b/converter/other/fiasco/input/tree.c index 74ceeb68..8d81ae1b 100644 --- a/converter/other/fiasco/input/tree.c +++ b/converter/other/fiasco/input/tree.c @@ -1,7 +1,7 @@ /* - * tree.c: Input of bintree partitioning + * tree.c: Input of bintree partitioning * - * Written by: Ullrich Hafner + * Written by: Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -30,22 +30,22 @@ /***************************************************************************** - prototypes + prototypes *****************************************************************************/ static unsigned restore_depth_first_order (unsigned src_state, unsigned level, unsigned x, - unsigned y, unsigned *dst_state, - word_t (*bfo_tree)[MAXLABELS], - wfa_t *wfa, tiling_t *tiling); + unsigned y, unsigned *dst_state, + word_t (*bfo_tree)[MAXLABELS], + wfa_t *wfa, tiling_t *tiling); static void decode_tree (bitfile_t *input, byte_t *data, unsigned n_data, unsigned scaling, - u_word_t sum0, u_word_t sum1); + u_word_t sum0, u_word_t sum1); /***************************************************************************** - public code + public code *****************************************************************************/ @@ -58,12 +58,12 @@ read_tree (wfa_t *wfa, tiling_t *tiling, bitfile_t *input) * No return value. * * Side effects: - * 'wfa->tree', 'wfa->x', 'wfa->y', 'wfa->level_of_state' + * 'wfa->tree', 'wfa->x', 'wfa->y', 'wfa->level_of_state' * are filled with decoded values. */ { - byte_t *bitstring; /* the encoded data */ - word_t (*bfo_tree)[MAXLABELS]; /* node numbers in BFO */ + byte_t *bitstring; /* the encoded data */ + word_t (*bfo_tree)[MAXLABELS]; /* node numbers in BFO */ /* * Read WFA tree stored in breadth first order @@ -80,15 +80,15 @@ read_tree (wfa_t *wfa, tiling_t *tiling, bitfile_t *input) * Generate tree using a breadth first traversal */ { - unsigned next; /* next free node number of the tree */ - unsigned state; - unsigned label; - byte_t *buffer = bitstring; /* pointer to decoded data */ + unsigned next; /* next free node number of the tree */ + unsigned state; + unsigned label; + byte_t *buffer = bitstring; /* pointer to decoded data */ bfo_tree = Calloc (wfa->states * MAXLABELS, sizeof (word_t)); for (state = 0, next = 1; state < next; state++) - for (label = 0; label < MAXLABELS; label++) - bfo_tree [state][label] = *buffer++ ? next++ : RANGE; + for (label = 0; label < MAXLABELS; label++) + bfo_tree [state][label] = *buffer++ ? next++ : RANGE; } /* @@ -98,9 +98,9 @@ read_tree (wfa_t *wfa, tiling_t *tiling, bitfile_t *input) unsigned dst_state = wfa->basis_states; wfa->root_state - = restore_depth_first_order (0, (wfa->wfainfo->level - + (wfa->wfainfo->color ? 2 : 0)), - 0, 0, &dst_state, bfo_tree, wfa, tiling); + = restore_depth_first_order (0, (wfa->wfainfo->level + + (wfa->wfainfo->color ? 2 : 0)), + 0, 0, &dst_state, bfo_tree, wfa, tiling); } Free (bitstring); @@ -109,15 +109,15 @@ read_tree (wfa_t *wfa, tiling_t *tiling, bitfile_t *input) /***************************************************************************** - private code + private code *****************************************************************************/ static unsigned restore_depth_first_order (unsigned src_state, unsigned level, unsigned x, - unsigned y, unsigned *dst_state, - word_t (*bfo_tree)[MAXLABELS], - wfa_t *wfa, tiling_t *tiling) + unsigned y, unsigned *dst_state, + word_t (*bfo_tree)[MAXLABELS], + wfa_t *wfa, tiling_t *tiling) /* * Map state 'src_state' (breadth first order) * to state '*dst_state' (depth first order) @@ -127,17 +127,17 @@ restore_depth_first_order (unsigned src_state, unsigned level, unsigned x, * of size 'image_level'. 'tiling' defines the image partitioning. * * Return value: - * new node number in depth first order + * new node number in depth first order * * Side effects: - * 'wfa->tree', 'wfa->x', 'wfa->y', 'wfa->level_of_state' + * 'wfa->tree', 'wfa->x', 'wfa->y', 'wfa->level_of_state' * are filled with decoded values. */ { - unsigned newx [MAXLABELS]; /* x coordinate of children */ - unsigned newy [MAXLABELS]; /* y coordinate of children */ - unsigned x0, y0; /* NW corner of image tile */ - unsigned width, height; /* size of image tile */ + unsigned newx [MAXLABELS]; /* x coordinate of children */ + unsigned newy [MAXLABELS]; /* y coordinate of children */ + unsigned x0, y0; /* NW corner of image tile */ + unsigned width, height; /* size of image tile */ /* * If tiling is performed then replace current coordinates @@ -148,14 +148,14 @@ restore_depth_first_order (unsigned src_state, unsigned level, unsigned x, for (tile = 0; tile < 1U << tiling->exponent; tile++) { - locate_subimage (wfa->wfainfo->level, level, tile, - &x0, &y0, &width, &height); - if (x0 == x && y0 == y) /* matched ! */ - { - locate_subimage (wfa->wfainfo->level, level, tiling->vorder[tile], - &x, &y, &width, &height); - break; - } + locate_subimage (wfa->wfainfo->level, level, tile, + &x0, &y0, &width, &height); + if (x0 == x && y0 == y) /* matched ! */ + { + locate_subimage (wfa->wfainfo->level, level, tiling->vorder[tile], + &x, &y, &width, &height); + break; + } } } /* @@ -175,24 +175,24 @@ restore_depth_first_order (unsigned src_state, unsigned level, unsigned x, * Remap node numbers */ { - int child [MAXLABELS]; /* children of current node (state) */ - int domain; /* current domain */ + int child [MAXLABELS]; /* children of current node (state) */ + int domain; /* current domain */ unsigned label; for (label = 0; label < MAXLABELS; label++) - if (!isrange (domain = bfo_tree [src_state][label])) - child [label] = restore_depth_first_order (domain, level - 1, - newx [label], - newy [label], dst_state, - bfo_tree, wfa, tiling); - else - child [label] = RANGE; + if (!isrange (domain = bfo_tree [src_state][label])) + child [label] = restore_depth_first_order (domain, level - 1, + newx [label], + newy [label], dst_state, + bfo_tree, wfa, tiling); + else + child [label] = RANGE; for (label = 0; label < MAXLABELS; label++) { - wfa->tree [*dst_state][label] = child [label]; - wfa->x [*dst_state][label] = newx [label]; - wfa->y [*dst_state][label] = newy [label]; + wfa->tree [*dst_state][label] = child [label]; + wfa->x [*dst_state][label] = newx [label]; + wfa->y [*dst_state][label] = newy [label]; } wfa->level_of_state [*dst_state] = level; } @@ -208,26 +208,26 @@ restore_depth_first_order (unsigned src_state, unsigned level, unsigned x, static void decode_tree (bitfile_t *input, byte_t *data, unsigned n_data, unsigned scaling, - u_word_t sum0, u_word_t sum1) + u_word_t sum0, u_word_t sum1) /* * Decode bintree partitioning using adaptive binary arithmetic decoding. - * 'input' input stream, - * 'data' buffer for decoded szmbols, - * 'n_data' number of symbols to decode, - * 'scaling' rescale probability models if range > 'scaling' - * 'sum0' initial totals of symbol '0' - * 'sum1' initial totals of symbol '1' + * 'input' input stream, + * 'data' buffer for decoded szmbols, + * 'n_data' number of symbols to decode, + * 'scaling' rescale probability models if range > 'scaling' + * 'sum0' initial totals of symbol '0' + * 'sum1' initial totals of symbol '1' * * No return value. * * Side effects: - * 'data []' is filled with the decoded bitstring + * 'data []' is filled with the decoded bitstring */ { - u_word_t code; /* The present input code value */ - u_word_t low; /* Start of the current code range */ - u_word_t high; /* End of the current code range */ - unsigned n; /* Data counter */ + u_word_t code; /* The present input code value */ + u_word_t low; /* Start of the current code range */ + u_word_t high; /* End of the current code range */ + unsigned n; /* Data counter */ assert (data); @@ -237,64 +237,64 @@ decode_tree (bitfile_t *input, byte_t *data, unsigned n_data, unsigned scaling, for (n = n_data; n; n--) { - unsigned count; /* Current interval count */ - unsigned range; /* Current interval range */ + unsigned count; /* Current interval count */ + unsigned range; /* Current interval range */ count = (((code - low) + 1) * sum1 - 1) / ((high - low) + 1); if (count < sum0) { - /* - * Decode a '0' symbol - * First, the range is expanded to account for the symbol removal. - */ - range = (high - low) + 1; - high = low + (u_word_t) ((range * sum0) / sum1 - 1 ); - - RESCALE_INPUT_INTERVAL; - - *data++ = 0; - /* - * Update the frequency counts - */ - sum0++; - sum1++; - if (sum1 > scaling) /* scale the symbol frequencies */ - { - sum0 >>= 1; - sum1 >>= 1; - if (!sum0) - sum0 = 1; - if (sum0 >= sum1) - sum1 = sum0 + 1; - } + /* + * Decode a '0' symbol + * First, the range is expanded to account for the symbol removal. + */ + range = (high - low) + 1; + high = low + (u_word_t) ((range * sum0) / sum1 - 1 ); + + RESCALE_INPUT_INTERVAL; + + *data++ = 0; + /* + * Update the frequency counts + */ + sum0++; + sum1++; + if (sum1 > scaling) /* scale the symbol frequencies */ + { + sum0 >>= 1; + sum1 >>= 1; + if (!sum0) + sum0 = 1; + if (sum0 >= sum1) + sum1 = sum0 + 1; + } } else { - /* - * Decode a '1' symbol - * First, the range is expanded to account for the symbol removal. - */ - range = (high - low) + 1; - high = low + (u_word_t) ((range * sum1) / sum1 - 1); - low = low + (u_word_t) ((range * sum0) / sum1); - - RESCALE_INPUT_INTERVAL; - - *data++ = 1; - /* - * Update the frequency counts - */ - sum1++; - if (sum1 > scaling) /* scale the symbol frequencies */ - { - sum0 >>= 1; - sum1 >>= 1; - if (!sum0) - sum0 = 1; - if (sum0 >= sum1) - sum1 = sum0 + 1; - } + /* + * Decode a '1' symbol + * First, the range is expanded to account for the symbol removal. + */ + range = (high - low) + 1; + high = low + (u_word_t) ((range * sum1) / sum1 - 1); + low = low + (u_word_t) ((range * sum0) / sum1); + + RESCALE_INPUT_INTERVAL; + + *data++ = 1; + /* + * Update the frequency counts + */ + sum1++; + if (sum1 > scaling) /* scale the symbol frequencies */ + { + sum0 >>= 1; + sum1 >>= 1; + if (!sum0) + sum0 = 1; + if (sum0 >= sum1) + sum1 = sum0 + 1; + } } } INPUT_BYTE_ALIGN (input); diff --git a/converter/other/fiasco/input/tree.h b/converter/other/fiasco/input/tree.h index f743ee98..31b73fa5 100644 --- a/converter/other/fiasco/input/tree.h +++ b/converter/other/fiasco/input/tree.h @@ -1,8 +1,8 @@ /* * tree.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ diff --git a/converter/other/fiasco/input/weights.c b/converter/other/fiasco/input/weights.c index 8a1e8899..debf38ad 100644 --- a/converter/other/fiasco/input/weights.c +++ b/converter/other/fiasco/input/weights.c @@ -2,7 +2,7 @@ * weights.c: Input of weights * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -32,7 +32,7 @@ /***************************************************************************** public code - + *****************************************************************************/ void @@ -55,7 +55,7 @@ read_weights (unsigned total, wfa_t *wfa, bitfile_t *input) 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 */ @@ -65,7 +65,7 @@ read_weights (unsigned total, wfa_t *wfa, bitfile_t *input) delta_approx = YES; break; } - + /* * Generate array of corresponding levels (context of probability model) */ @@ -82,7 +82,7 @@ read_weights (unsigned total, wfa_t *wfa, bitfile_t *input) 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])) @@ -156,7 +156,7 @@ read_weights (unsigned total, wfa_t *wfa, bitfile_t *input) 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); - + weights_array = decode_array (input, level_array, c_symbols, offset4, total, scale); Free (c_symbols); @@ -198,7 +198,7 @@ read_weights (unsigned total, wfa_t *wfa, bitfile_t *input) = wfa->weight [state][label][edge] * 512 + 0.5; } } - + Free (weights_array); } - + diff --git a/converter/other/fiasco/input/weights.h b/converter/other/fiasco/input/weights.h index 36cea5c2..4a6bdf0a 100644 --- a/converter/other/fiasco/input/weights.h +++ b/converter/other/fiasco/input/weights.h @@ -1,8 +1,8 @@ /* * weights.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ diff --git a/converter/other/fiasco/lib/arith.c b/converter/other/fiasco/lib/arith.c index e61e753e..7fac0c6d 100644 --- a/converter/other/fiasco/lib/arith.c +++ b/converter/other/fiasco/lib/arith.c @@ -1,7 +1,7 @@ /* - * arith.c: Adaptive arithmetic coding and decoding + * arith.c: Adaptive arithmetic coding and decoding * - * Written by: Ullrich Hafner + * Written by: Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -26,7 +26,7 @@ /****************************************************************************** - public code + public code ******************************************************************************/ @@ -37,7 +37,7 @@ alloc_encoder (bitfile_t *output) * Initialize the arithmetic coder. * * Return value: - * A pointer to the new coder structure + * A pointer to the new coder structure */ { arith_t *arith = Calloc (1, sizeof (arith_t)); @@ -47,7 +47,7 @@ alloc_encoder (bitfile_t *output) arith->low = LOW; arith->high = HIGH; arith->underflow = 0; - arith->file = output; + arith->file = output; return arith; } @@ -62,9 +62,9 @@ free_encoder (arith_t *arith) * No return value. */ { - u_word_t low; /* start of the current code range */ - u_word_t high; /* end of the current code range */ - u_word_t underflow; /* number of underflow bits pending */ + u_word_t low; /* start of the current code range */ + u_word_t high; /* end of the current code range */ + u_word_t underflow; /* number of underflow bits pending */ bitfile_t *output; assert (arith); @@ -94,22 +94,22 @@ encode_symbol (unsigned symbol, arith_t *arith, model_t *model) * symbol counts are rescaled). * * Return value: - * information content of the encoded symbol. + * information content of the encoded symbol. * * Side effects: - * 'model' is updated (probability distribution) - * 'arith' is updated (coder state) + * 'model' is updated (probability distribution) + * 'arith' is updated (coder state) */ { - u_word_t low_count; /* lower bound of 'symbol' interval */ - u_word_t high_count; /* upper bound of 'symbol' interval */ - u_word_t scale; /* range of all 'm' symbol intervals */ - unsigned range; /* range of current interval */ - unsigned index; /* index of probability model */ - u_word_t low; /* start of the current code range */ - u_word_t high; /* end of the current code range */ - u_word_t underflow; /* number of underflow bits pending */ - bitfile_t *output; /* output file */ + u_word_t low_count; /* lower bound of 'symbol' interval */ + u_word_t high_count; /* upper bound of 'symbol' interval */ + u_word_t scale; /* range of all 'm' symbol intervals */ + unsigned range; /* range of current interval */ + unsigned index; /* index of probability model */ + u_word_t low; /* start of the current code range */ + u_word_t high; /* end of the current code range */ + u_word_t underflow; /* number of underflow bits pending */ + bitfile_t *output; /* output file */ assert (model && arith); @@ -123,28 +123,28 @@ encode_symbol (unsigned symbol, arith_t *arith, model_t *model) assert (high > low); - if (model->order > 0) /* order-'n' model*/ + if (model->order > 0) /* order-'n' model*/ { - unsigned power; /* multiplicator */ + unsigned power; /* multiplicator */ unsigned i; /* * Compute index of the probability model to use. * See init_model() for more details. */ - power = 1; /* multiplicator */ - index = 0; /* address of prob. model */ + power = 1; /* multiplicator */ + index = 0; /* address of prob. model */ for (i = 0; i < model->order; i++) /* generate a M-nary number */ { - index += model->context [i] * power; - power *= model->symbols; + index += model->context [i] * power; + power *= model->symbols; } - index *= model->symbols + 1; /* we need space for M + 1 elements */ + index *= model->symbols + 1; /* we need space for M + 1 elements */ for (i = 0; i < model->order - 1; i++) - model->context [i] = model->context [i + 1]; + model->context [i] = model->context [i + 1]; model->context [i] = symbol; } else @@ -163,7 +163,7 @@ encode_symbol (unsigned symbol, arith_t *arith, model_t *model) RESCALE_OUTPUT_INTERVAL; - if (model->scale > 0) /* adaptive model */ + if (model->scale > 0) /* adaptive model */ { unsigned i; @@ -171,23 +171,23 @@ encode_symbol (unsigned symbol, arith_t *arith, model_t *model) * Update probability model */ for (i = symbol + 1; i <= model->symbols; i++) - model->totals [index + i]++; + model->totals [index + i]++; if (model->totals [index + model->symbols] > model->scale) /* scaling */ { - for (i = 1; i <= model->symbols; i++) - { - model->totals [index + i] >>= 1; - if (model->totals [index + i] <= model->totals [index + i - 1]) - model->totals [index + i] = model->totals [index + i - 1] + 1; - } + for (i = 1; i <= model->symbols; i++) + { + model->totals [index + i] >>= 1; + if (model->totals [index + i] <= model->totals [index + i - 1]) + model->totals [index + i] = model->totals [index + i - 1] + 1; + } } } /* * Store interval values */ - arith->low = low; - arith->high = high; + arith->low = low; + arith->high = high; arith->underflow = underflow; return - log2 ((high_count - low_count) / (real_t) scale); @@ -195,8 +195,8 @@ encode_symbol (unsigned symbol, arith_t *arith, model_t *model) void encode_array (bitfile_t *output, const unsigned *data, const unsigned *context, - const unsigned *c_symbols, unsigned n_context, unsigned n_data, - unsigned scaling) + const unsigned *c_symbols, unsigned n_context, unsigned n_data, + unsigned scaling) /* * Arithmetic coding of #'n_data' symbols given in the array 'data'. * If 'n_context' > 1 then a number (context [n]) is assigned to every @@ -207,10 +207,10 @@ encode_array (bitfile_t *output, const unsigned *data, const unsigned *context, * No return value. */ { - u_word_t **totals; /* probability model */ + u_word_t **totals; /* probability model */ if (!n_context) - n_context = 1; /* always use one context */ + n_context = 1; /* always use one context */ assert (output && c_symbols && data); assert (n_context == 1 || context); @@ -224,13 +224,13 @@ encode_array (bitfile_t *output, const unsigned *data, const unsigned *context, for (c = 0; c < n_context; c++) { - unsigned i; + unsigned i; - totals [c] = Calloc (c_symbols [c] + 1, sizeof (u_word_t)); - totals [c][0] = 0; + totals [c] = Calloc (c_symbols [c] + 1, sizeof (u_word_t)); + totals [c][0] = 0; - for (i = 0; i < c_symbols [c]; i++) - totals [c][i + 1] = totals [c][i] + 1; + for (i = 0; i < c_symbols [c]; i++) + totals [c][i + 1] = totals [c][i] + 1; } } @@ -238,52 +238,52 @@ encode_array (bitfile_t *output, const unsigned *data, const unsigned *context, * Encode array elements */ { - u_word_t low = 0; /* Start of the current code range */ - u_word_t high = 0xffff; /* End of the current code range */ - u_word_t underflow = 0; /* Number of underflow bits pending */ + u_word_t low = 0; /* Start of the current code range */ + u_word_t high = 0xffff; /* End of the current code range */ + u_word_t underflow = 0; /* Number of underflow bits pending */ unsigned n; for (n = 0; n < n_data; n++) { - u_word_t low_count; /* lower bound of 'symbol' interval */ - u_word_t high_count; /* upper bound of 'symbol' interval */ - u_word_t scale; /* range of all 'm' symbol intervals */ - unsigned range; /* current range */ - int d; /* current data symbol */ - int c; /* context of current data symbol */ - - d = data [n]; - c = n_context > 1 ? context [n] : 0; - - scale = totals [c][c_symbols [c]]; - low_count = totals [c][d]; - high_count = totals [c][d + 1]; - - /* - * Rescale high and low for the new symbol. - */ - range = (high - low) + 1; - high = low + (u_word_t) ((range * high_count) / scale - 1); - low = low + (u_word_t) ((range * low_count) / scale); - RESCALE_OUTPUT_INTERVAL; - - /* - * Update probability models - */ - { - unsigned i; - - for (i = d + 1; i < c_symbols [c] + 1; i++) - totals [c][i]++; - - if (totals [c][c_symbols [c]] > scaling) /* scaling */ - for (i = 1; i < c_symbols [c] + 1; i++) - { - totals [c][i] >>= 1; - if (totals [c][i] <= totals [c][i - 1]) - totals [c][i] = totals [c][i - 1] + 1; - } - } + u_word_t low_count; /* lower bound of 'symbol' interval */ + u_word_t high_count; /* upper bound of 'symbol' interval */ + u_word_t scale; /* range of all 'm' symbol intervals */ + unsigned range; /* current range */ + int d; /* current data symbol */ + int c; /* context of current data symbol */ + + d = data [n]; + c = n_context > 1 ? context [n] : 0; + + scale = totals [c][c_symbols [c]]; + low_count = totals [c][d]; + high_count = totals [c][d + 1]; + + /* + * Rescale high and low for the new symbol. + */ + range = (high - low) + 1; + high = low + (u_word_t) ((range * high_count) / scale - 1); + low = low + (u_word_t) ((range * low_count) / scale); + RESCALE_OUTPUT_INTERVAL; + + /* + * Update probability models + */ + { + unsigned i; + + for (i = d + 1; i < c_symbols [c] + 1; i++) + totals [c][i]++; + + if (totals [c][c_symbols [c]] > scaling) /* scaling */ + for (i = 1; i < c_symbols [c] + 1; i++) + { + totals [c][i] >>= 1; + if (totals [c][i] <= totals [c][i - 1]) + totals [c][i] = totals [c][i - 1] + 1; + } + } } /* * Flush arithmetic encoder @@ -299,7 +299,7 @@ encode_array (bitfile_t *output, const unsigned *data, const unsigned *context, { unsigned c; for (c = 0; c < n_context; c++) - Free (totals [c]); + Free (totals [c]); Free (totals); } } @@ -312,7 +312,7 @@ alloc_decoder (bitfile_t *input) * 16 input bits from the stream 'input'. * * Return value: - * A pointer to the new decoder structure + * A pointer to the new decoder structure */ { @@ -338,7 +338,7 @@ free_decoder (arith_t *arith) * No return value. * * Side effects: - * structure 'arith' is discarded. + * structure 'arith' is discarded. */ { assert (arith); @@ -357,22 +357,22 @@ decode_symbol (arith_t *arith, model_t *model) * decoding the symbol (if necessary also rescale the symbol counts). * * Return value: - * decoded symbol + * decoded symbol * * Side effects: - * 'model' is updated (probability distribution) - * 'arith' is updated (decoder state) + * 'model' is updated (probability distribution) + * 'arith' is updated (decoder state) */ { - unsigned range; /* range of current interval */ - unsigned count; /* value in the current interval */ - unsigned index; /* index of probability model */ - unsigned symbol; /* decoded symbol */ - u_word_t scale; /* range of all 'm' symbol intervals */ - u_word_t low; /* start of the current code range */ - u_word_t high; /* end of the current code range */ - u_word_t code; /* the present input code value */ - bitfile_t *input; /* input file */ + unsigned range; /* range of current interval */ + unsigned count; /* value in the current interval */ + unsigned index; /* index of probability model */ + unsigned symbol; /* decoded symbol */ + u_word_t scale; /* range of all 'm' symbol intervals */ + u_word_t low; /* start of the current code range */ + u_word_t high; /* end of the current code range */ + u_word_t code; /* the present input code value */ + bitfile_t *input; /* input file */ assert (arith && model); @@ -386,25 +386,25 @@ decode_symbol (arith_t *arith, model_t *model) assert (high > low); - if (model->order > 0) /* order-'n' model */ + if (model->order > 0) /* order-'n' model */ { - unsigned power; /* multiplicator */ + unsigned power; /* multiplicator */ unsigned i; /* * Compute index of the probability model to use. * See init_model() for more details. */ - power = 1; /* multiplicator */ - index = 0; /* address of prob. model */ + power = 1; /* multiplicator */ + index = 0; /* address of prob. model */ for (i = 0; i < model->order; i++) /* generate a m-nary number */ { - index += model->context[i] * power; - power *= model->symbols; + index += model->context[i] * power; + power *= model->symbols; } - index *= model->symbols + 1; /* we need space for m + 1 elements */ + index *= model->symbols + 1; /* we need space for m + 1 elements */ } else index = 0; @@ -414,15 +414,15 @@ decode_symbol (arith_t *arith, model_t *model) count = ((code - low + 1) * scale - 1) / range; for (symbol = model->symbols; count < model->totals [index + symbol]; - symbol--) + symbol--) ; - if (model->order > 0) /* order-'n' model */ + if (model->order > 0) /* order-'n' model */ { unsigned i; for (i = 0; i < model->order - 1; i++) - model->context [i] = model->context [i + 1]; + model->context [i] = model->context [i + 1]; model->context [i] = symbol; } @@ -430,8 +430,8 @@ decode_symbol (arith_t *arith, model_t *model) * Compute interval boundaries */ { - u_word_t low_count; /* lower bound of 'symbol' interval */ - u_word_t high_count; /* upper bound of 'symbol' interval */ + u_word_t low_count; /* lower bound of 'symbol' interval */ + u_word_t high_count; /* upper bound of 'symbol' interval */ low_count = model->totals [index + symbol]; high_count = model->totals [index + symbol + 1]; @@ -441,7 +441,7 @@ decode_symbol (arith_t *arith, model_t *model) RESCALE_INPUT_INTERVAL; - if (model->scale > 0) /* adaptive model */ + if (model->scale > 0) /* adaptive model */ { unsigned i; @@ -449,15 +449,15 @@ decode_symbol (arith_t *arith, model_t *model) * Update probability model */ for (i = symbol + 1; i <= model->symbols; i++) - model->totals [index + i]++; + model->totals [index + i]++; if (model->totals [index + model->symbols] > model->scale) /* scaling */ { - for (i = 1; i <= model->symbols; i++) - { - model->totals [index + i] >>= 1; - if (model->totals [index + i] <= model->totals [index + i - 1]) - model->totals [index + i] = model->totals [index + i - 1] + 1; - } + for (i = 1; i <= model->symbols; i++) + { + model->totals [index + i] >>= 1; + if (model->totals [index + i] <= model->totals [index + i - 1]) + model->totals [index + i] = model->totals [index + i - 1] + 1; + } } } @@ -473,8 +473,8 @@ decode_symbol (arith_t *arith, model_t *model) unsigned * decode_array (bitfile_t *input, const unsigned *context, - const unsigned *c_symbols, unsigned n_context, - unsigned n_data, unsigned scaling) + const unsigned *c_symbols, unsigned n_context, + unsigned n_data, unsigned scaling) /* * Arithmetic decoding of #'n_data' symbols. * If 'n_context' > 1 then a number (context [n]) is assigned to every @@ -483,14 +483,14 @@ decode_array (bitfile_t *input, const unsigned *context, * Rescale probability models if range > 'scaling'. * * Return value: - * pointer to array containing the decoded symbols + * pointer to array containing the decoded symbols */ { - unsigned *data; /* array to store decoded symbols */ - u_word_t **totals; /* probability model */ + unsigned *data; /* array to store decoded symbols */ + u_word_t **totals; /* probability model */ if (n_context < 1) - n_context = 1; /* always use one context */ + n_context = 1; /* always use one context */ assert (input && c_symbols); assert (n_context == 1 || context); @@ -505,13 +505,13 @@ decode_array (bitfile_t *input, const unsigned *context, for (c = 0; c < n_context; c++) { - unsigned i; + unsigned i; - totals [c] = Calloc (c_symbols [c] + 1, sizeof (u_word_t)); - totals [c][0] = 0; + totals [c] = Calloc (c_symbols [c] + 1, sizeof (u_word_t)); + totals [c][0] = 0; - for (i = 0; i < c_symbols [c]; i++) - totals [c][i + 1] = totals [c][i] + 1; + for (i = 0; i < c_symbols [c]; i++) + totals [c][i + 1] = totals [c][i] + 1; } } @@ -520,54 +520,54 @@ decode_array (bitfile_t *input, const unsigned *context, */ { u_word_t code = get_bits (input, 16); /* The present input code value */ - u_word_t low = 0; /* Start of the current code range */ - u_word_t high = 0xffff; /* End of the current code range */ + u_word_t low = 0; /* Start of the current code range */ + u_word_t high = 0xffff; /* End of the current code range */ unsigned n; for (n = 0; n < n_data; n++) { - u_word_t scale; /* range of all 'm' symbol intervals */ - u_word_t low_count; /* lower bound of 'symbol' interval */ - u_word_t high_count; /* upper bound of 'symbol' interval */ - unsigned count; /* value in the current interval */ - unsigned range; /* current interval range */ - unsigned d; /* current data symbol */ - unsigned c; /* context of current data symbol */ - - c = n_context > 1 ? context [n] : 0; - - assert (high > low); - scale = totals [c][c_symbols [c]]; - range = (high - low) + 1; - count = (((code - low) + 1 ) * scale - 1) / range; - - for (d = c_symbols [c]; count < totals [c][d]; d--) /* next symbol */ - ; - low_count = totals [c][d]; - high_count = totals [c][d + 1]; - - high = low + (u_word_t) ((range * high_count) / scale - 1 ); - low = low + (u_word_t) ((range * low_count) / scale ); - RESCALE_INPUT_INTERVAL; - - /* - * Updata probability models - */ - { - unsigned i; - - for (i = d + 1; i < c_symbols [c] + 1; i++) - totals [c][i]++; - - if (totals [c][c_symbols [c]] > scaling) /* scaling */ - for (i = 1; i < c_symbols [c] + 1; i++) - { - totals [c][i] >>= 1; - if (totals [c][i] <= totals [c][i - 1]) - totals [c][i] = totals [c][i - 1] + 1; - } - } - data [n] = d; + u_word_t scale; /* range of all 'm' symbol intervals */ + u_word_t low_count; /* lower bound of 'symbol' interval */ + u_word_t high_count; /* upper bound of 'symbol' interval */ + unsigned count; /* value in the current interval */ + unsigned range; /* current interval range */ + unsigned d; /* current data symbol */ + unsigned c; /* context of current data symbol */ + + c = n_context > 1 ? context [n] : 0; + + assert (high > low); + scale = totals [c][c_symbols [c]]; + range = (high - low) + 1; + count = (((code - low) + 1 ) * scale - 1) / range; + + for (d = c_symbols [c]; count < totals [c][d]; d--) /* next symbol */ + ; + low_count = totals [c][d]; + high_count = totals [c][d + 1]; + + high = low + (u_word_t) ((range * high_count) / scale - 1 ); + low = low + (u_word_t) ((range * low_count) / scale ); + RESCALE_INPUT_INTERVAL; + + /* + * Updata probability models + */ + { + unsigned i; + + for (i = d + 1; i < c_symbols [c] + 1; i++) + totals [c][i]++; + + if (totals [c][c_symbols [c]] > scaling) /* scaling */ + for (i = 1; i < c_symbols [c] + 1; i++) + { + totals [c][i] >>= 1; + if (totals [c][i] <= totals [c][i - 1]) + totals [c][i] = totals [c][i - 1] + 1; + } + } + data [n] = d; } INPUT_BYTE_ALIGN (input); } @@ -579,7 +579,7 @@ decode_array (bitfile_t *input, const unsigned *context, unsigned c; for (c = 0; c < n_context; c++) - Free (totals [c]); + Free (totals [c]); Free (totals); } @@ -599,17 +599,17 @@ alloc_model (unsigned m, unsigned scale, unsigned n, unsigned *totals) * the initial counts. * * Return value: - * a pointer to the new probability model structure. + * a pointer to the new probability model structure. * * Note: We recommend a small size of the alphabet because no escape codes * are used to encode/decode previously unseen symbols. * */ { - model_t *model; /* new probability model */ - unsigned num; /* number of contexts to allocate */ - bool_t cont; /* continue flag */ - bool_t dec; /* next order flag */ + model_t *model; /* new probability model */ + unsigned num; /* number of contexts to allocate */ + bool_t cont; /* continue flag */ + bool_t dec; /* next order flag */ unsigned i; /* @@ -630,56 +630,56 @@ alloc_model (unsigned m, unsigned scale, unsigned n, unsigned *totals) model->totals = Calloc (num * (model->symbols + 1), sizeof (unsigned)); for (i = 0; i < model->order; i++) - model->context[i] = 0; /* start with context 0,0, .. ,0 */ + model->context[i] = 0; /* start with context 0,0, .. ,0 */ cont = YES; - while (cont) /* repeat while context != M ... M */ + while (cont) /* repeat while context != M ... M */ { - int power; /* multiplicator */ - int index; /* index of probability model */ + int power; /* multiplicator */ + int index; /* index of probability model */ /* * There are m^n different contexts: * Let "context_1 context_2 ... context_n symbol" be the current input * stream then the index of the probability model is given by: * index = context_1 * M^0 + context_2 * M^1 + ... + context_n * M^(n-1) */ - power = 1; /* multiplicator */ - index = 0; /* address of prob. model */ + power = 1; /* multiplicator */ + index = 0; /* address of prob. model */ - for (i = 0; i < model->order; i++) /* generate a m-nary number */ + for (i = 0; i < model->order; i++) /* generate a m-nary number */ { - index += model->context[i] * power; - power *= model->symbols; + index += model->context[i] * power; + power *= model->symbols; } - index *= model->symbols + 1; /* size of each model is m + 1 */ + index *= model->symbols + 1; /* size of each model is m + 1 */ - model->totals [index + 0] = 0; /* always zero */ + model->totals [index + 0] = 0; /* always zero */ for (i = 1; i <= model->symbols; i++) /* prob of each symbol is 1/m or - as given in totals */ - model->totals[index + i] = model->totals [index + i - 1] - + (totals ? totals [i - 1] : 1); - - if (model->order == 0) /* order-0 model */ - cont = NO; - else /* try next context */ - for (i = model->order - 1, dec = YES; dec; i--) - { - dec = NO; - model->context[i]++; - if (model->context[i] >= model->symbols) - { - /* change previous context */ - model->context[i] = 0; - if (i > 0) /* there's still a context remaining */ - dec = YES; - else - cont = NO; /* all context models initialized */ - } - } + as given in totals */ + model->totals[index + i] = model->totals [index + i - 1] + + (totals ? totals [i - 1] : 1); + + if (model->order == 0) /* order-0 model */ + cont = NO; + else /* try next context */ + for (i = model->order - 1, dec = YES; dec; i--) + { + dec = NO; + model->context[i]++; + if (model->context[i] >= model->symbols) + { + /* change previous context */ + model->context[i] = 0; + if (i > 0) /* there's still a context remaining */ + dec = YES; + else + cont = NO; /* all context models initialized */ + } + } } for (i = 0; i < model->order; i++) - model->context[i] = 0; /* start with context 0,0, .. ,0 */ + model->context[i] = 0; /* start with context 0,0, .. ,0 */ return model; } @@ -693,13 +693,13 @@ free_model (model_t *model) * No return value. * * Side effects: - * struct 'model' is discarded + * struct 'model' is discarded */ { if (model != NULL) { if (model->context != NULL) - Free (model->context); + Free (model->context); Free (model->totals); Free (model); } diff --git a/converter/other/fiasco/lib/arith.h b/converter/other/fiasco/lib/arith.h index 04297eb5..152dabab 100644 --- a/converter/other/fiasco/lib/arith.h +++ b/converter/other/fiasco/lib/arith.h @@ -20,24 +20,24 @@ typedef struct model { - unsigned symbols; /* number of symbols in the alphabet */ - unsigned scale; /* if totals > scale rescale totals */ - unsigned order; /* order of the probability model */ - unsigned *context; /* context of the model */ - unsigned *totals; /* the totals */ + unsigned symbols; /* number of symbols in the alphabet */ + unsigned scale; /* if totals > scale rescale totals */ + unsigned order; /* order of the probability model */ + unsigned *context; /* context of the model */ + unsigned *totals; /* the totals */ } model_t; typedef struct arith { - u_word_t low; /* start of the current code range */ - u_word_t high; /* end of the current code range */ - u_word_t underflow; /* number of underflow bits pending */ - u_word_t code; /* the present input code value */ - bitfile_t *file; /* I/O stream */ + u_word_t low; /* start of the current code range */ + u_word_t high; /* end of the current code range */ + u_word_t underflow; /* number of underflow bits pending */ + u_word_t code; /* the present input code value */ + bitfile_t *file; /* I/O stream */ } arith_t; enum interval {LOW = 0x0000, FIRST_QUARTER = 0x4000, HALF = 0x8000, - THIRD_QUARTER = 0xc000, HIGH = 0xffff}; + THIRD_QUARTER = 0xc000, HIGH = 0xffff}; arith_t * alloc_encoder (bitfile_t *file); @@ -47,8 +47,8 @@ real_t encode_symbol (unsigned symbol, arith_t *arith, model_t *model); void encode_array (bitfile_t *output, const unsigned *data, const unsigned *context, - const unsigned *c_symbols, unsigned n_context, unsigned n_data, - unsigned scaling); + const unsigned *c_symbols, unsigned n_context, unsigned n_data, + unsigned scaling); arith_t * alloc_decoder (bitfile_t *input); void @@ -57,8 +57,8 @@ unsigned decode_symbol (arith_t *arith, model_t *model); unsigned * decode_array (bitfile_t *input, const unsigned *context, - const unsigned *c_symbols, unsigned n_context, - unsigned n_data, unsigned scaling); + const unsigned *c_symbols, unsigned n_context, + unsigned n_data, unsigned scaling); model_t * alloc_model (unsigned m, unsigned scale, unsigned n, unsigned *totals); void @@ -67,7 +67,7 @@ free_model (model_t *model); #define RESCALE_INPUT_INTERVAL for (;;) \ if ((high >= HALF) && (low < HALF) && \ ((low & FIRST_QUARTER) != FIRST_QUARTER \ - || (high & FIRST_QUARTER) != 0)) \ + || (high & FIRST_QUARTER) != 0)) \ { \ break; \ } \ @@ -88,8 +88,8 @@ free_model (model_t *model); high |= HALF + 1; \ code <<= 1; \ code += get_bit (input); \ - } - + } + #define RESCALE_OUTPUT_INTERVAL for (;;) \ { \ if (high < HALF) \ @@ -116,7 +116,7 @@ free_model (model_t *model); high <<= 1; \ high |= 1; \ low <<= 1; \ - } - + } + #endif /* not _ARITH_H */ diff --git a/converter/other/fiasco/lib/bit-io.h b/converter/other/fiasco/lib/bit-io.h index 08029824..6de7e396 100644 --- a/converter/other/fiasco/lib/bit-io.h +++ b/converter/other/fiasco/lib/bit-io.h @@ -1,7 +1,7 @@ /* * bit-io.h * - * Written by: Ullrich Hafner + * Written by: Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -27,14 +27,14 @@ typedef enum {READ_ACCESS, WRITE_ACCESS} openmode_e; typedef struct bitfile { - FILE *file; /* associated filepointer */ - char *filename; /* corresponding filename */ - byte_t *buffer; /* stream buffer */ - byte_t *ptr; /* pointer to current buffer pos */ - unsigned bytepos; /* current I/O byte */ - unsigned bitpos; /* current I/O bit */ - unsigned bits_processed; /* number of bits already processed */ - openmode_e mode; /* access mode */ + FILE *file; /* associated filepointer */ + char *filename; /* corresponding filename */ + byte_t *buffer; /* stream buffer */ + byte_t *ptr; /* pointer to current buffer pos */ + unsigned bytepos; /* current I/O byte */ + unsigned bitpos; /* current I/O bit */ + unsigned bits_processed; /* number of bits already processed */ + openmode_e mode; /* access mode */ } bitfile_t; FILE * @@ -47,7 +47,7 @@ void put_bits (bitfile_t *bitfile, unsigned value, unsigned bits); bool_t get_bit (bitfile_t *bitfile); -unsigned +unsigned get_bits (bitfile_t *bitfile, unsigned bits); void close_bitfile (bitfile_t *bitfile); diff --git a/converter/other/fiasco/lib/dither.c b/converter/other/fiasco/lib/dither.c index 669bb16c..c394f5ec 100644 --- a/converter/other/fiasco/lib/dither.c +++ b/converter/other/fiasco/lib/dither.c @@ -1,8 +1,8 @@ /* - * dither.c: Various dithering routines + * dither.c: Various dithering routines + * + * Adapted by: Ullrich Hafner * - * Adapted by: Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -10,17 +10,17 @@ /* * Copyright (c) 1995 Erik Corry * All rights reserved. - * + * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. - * + * * IN NO EVENT SHALL ERIK CORRY BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF * THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF ERIK CORRY HAS BEEN ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. - * + * * ERIK CORRY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" @@ -52,25 +52,25 @@ /***************************************************************************** - prototypes - + prototypes + *****************************************************************************/ -static int +static int display_16_bit (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image); + const fiasco_image_t *fiasco_image); -static int +static int display_24_bit_bgr (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image); + const fiasco_image_t *fiasco_image); -static int +static int display_24_bit_rgb (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image); + const fiasco_image_t *fiasco_image); -static int +static int display_32_bit (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image); + const fiasco_image_t *fiasco_image); static int free_bits_at_bottom (unsigned long a); @@ -80,26 +80,26 @@ number_of_bits_set (unsigned long a); /***************************************************************************** - public code - + public code + *****************************************************************************/ fiasco_renderer_t * fiasco_renderer_new (unsigned long red_mask, unsigned long green_mask, - unsigned long blue_mask, unsigned bpp, - int double_resolution) + unsigned long blue_mask, unsigned bpp, + int double_resolution) /* * FIASCO renderer constructor. * Allocate memory for the FIASCO renderer structure and * initialize values. * `red_mask', `green_mask', and `blue_mask' are the corresponding masks - * of the X11R6 XImage structure. + * of the X11R6 XImage structure. * `bpp' gives the depth of the image in bits per pixel (16, 24, or 32). * If `double_resolution' is not 0 the the image width and height is doubled. * (fast pixel doubling, no interpolation!) * * Return value: - * pointer to the new structure or NULL on error + * pointer to the new structure or NULL on error */ { if (bpp != 16 && bpp != 24 && bpp !=32) @@ -111,30 +111,30 @@ fiasco_renderer_new (unsigned long red_mask, unsigned long green_mask, { fiasco_renderer_t *render = calloc (1, sizeof (fiasco_renderer_t)); renderer_private_t *private = calloc (1, sizeof (renderer_private_t)); - bool_t twopixels = (bpp == 16 && double_resolution); - int crval, cbval, i; /* counter */ + bool_t twopixels = (bpp == 16 && double_resolution); + int crval, cbval, i; /* counter */ if (!render || !private) { - set_error (_("Out of memory.")); - return NULL; + set_error (_("Out of memory.")); + return NULL; } switch (bpp) { - case 16: - render->render = display_16_bit; - break; - case 24: - if (red_mask > green_mask) - render->render = display_24_bit_rgb; - else - render->render = display_24_bit_bgr; - break; - case 32: - render->render = display_32_bit; - break; - default: - break; /* does not happen */ + case 16: + render->render = display_16_bit; + break; + case 24: + if (red_mask > green_mask) + render->render = display_24_bit_rgb; + else + render->render = display_24_bit_bgr; + break; + case 32: + render->render = display_32_bit; + break; + default: + break; /* does not happen */ } render->private = private; render->delete = fiasco_renderer_delete; @@ -146,42 +146,42 @@ fiasco_renderer_new (unsigned long red_mask, unsigned long green_mask, private->Cb_b_tab = calloc (256 + 2 * 1024, sizeof (int)); if (!private->Cr_r_tab || !private->Cr_g_tab - || !private->Cb_b_tab || !private->Cb_g_tab) + || !private->Cb_b_tab || !private->Cb_g_tab) { - set_error (_("Out of memory.")); - return NULL; + set_error (_("Out of memory.")); + return NULL; } - + for (i = 1024; i < 1024 + 256; i++) { - cbval = crval = i - 128 - 1024; + cbval = crval = i - 128 - 1024; - private->Cr_r_tab [i] = 1.4022 * crval + 0.5; - private->Cr_g_tab [i] = -0.7145 * crval + 0.5; - private->Cb_g_tab [i] = -0.3456 * cbval + 0.5; - private->Cb_b_tab [i] = 1.7710 * cbval + 0.5; + private->Cr_r_tab [i] = 1.4022 * crval + 0.5; + private->Cr_g_tab [i] = -0.7145 * crval + 0.5; + private->Cb_g_tab [i] = -0.3456 * cbval + 0.5; + private->Cb_b_tab [i] = 1.7710 * cbval + 0.5; } for (i = 0; i < 1024; i++) { - private->Cr_r_tab [i] = private->Cr_r_tab [1024]; - private->Cr_g_tab [i] = private->Cr_g_tab [1024]; - private->Cb_g_tab [i] = private->Cb_g_tab [1024]; - private->Cb_b_tab [i] = private->Cb_b_tab [1024]; + private->Cr_r_tab [i] = private->Cr_r_tab [1024]; + private->Cr_g_tab [i] = private->Cr_g_tab [1024]; + private->Cb_g_tab [i] = private->Cb_g_tab [1024]; + private->Cb_b_tab [i] = private->Cb_b_tab [1024]; } for (i = 1024 + 256; i < 2048 + 256; i++) { - private->Cr_r_tab [i] = private->Cr_r_tab [1024 + 255]; - private->Cr_g_tab [i] = private->Cr_g_tab [1024 + 255]; - private->Cb_g_tab [i] = private->Cb_g_tab [1024 + 255]; - private->Cb_b_tab [i] = private->Cb_b_tab [1024 + 255]; + private->Cr_r_tab [i] = private->Cr_r_tab [1024 + 255]; + private->Cr_g_tab [i] = private->Cr_g_tab [1024 + 255]; + private->Cb_g_tab [i] = private->Cb_g_tab [1024 + 255]; + private->Cb_b_tab [i] = private->Cb_b_tab [1024 + 255]; } private->Cr_r_tab += 1024 + 128; private->Cr_g_tab += 1024 + 128; private->Cb_g_tab += 1024 + 128; private->Cb_b_tab += 1024 + 128; - - /* + + /* * Set up entries 0-255 in rgb-to-pixel value tables. */ private->r_table = calloc (256 + 2 * 1024, sizeof (unsigned int)); @@ -190,38 +190,38 @@ fiasco_renderer_new (unsigned long red_mask, unsigned long green_mask, private->y_table = calloc (256 + 2 * 1024, sizeof (unsigned int)); if (!private->r_table || !private->g_table - || !private->b_table || !private->y_table) + || !private->b_table || !private->y_table) { - set_error (_("Out of memory.")); - return NULL; + set_error (_("Out of memory.")); + return NULL; } - + for (i = 0; i < 256; i++) { - private->r_table [i + 1024] - = i >> (8 - number_of_bits_set(red_mask)); - private->r_table [i + 1024] - <<= free_bits_at_bottom (red_mask); - private->g_table [i + 1024] - = i >> (8 - number_of_bits_set (green_mask)); - private->g_table [i + 1024] - <<= free_bits_at_bottom (green_mask); - private->b_table [i + 1024] - <<= free_bits_at_bottom (blue_mask); - private->b_table [i + 1024] - = i >> (8 - number_of_bits_set (blue_mask)); - if (twopixels) - { - private->r_table [i + 1024] = ((private->r_table [i + 1024] << 16) - | private->r_table [i + 1024]); - private->g_table [i + 1024] = ((private->g_table [i + 1024] << 16) - | private->g_table [i + 1024]); - private->b_table [i + 1024] = ((private->b_table [i + 1024] << 16) - | private->b_table [i + 1024]); - } - private->y_table [i + 1024] = (private->r_table [i + 1024] - | private->g_table [i + 1024] - | private->b_table [i + 1024]); + private->r_table [i + 1024] + = i >> (8 - number_of_bits_set(red_mask)); + private->r_table [i + 1024] + <<= free_bits_at_bottom (red_mask); + private->g_table [i + 1024] + = i >> (8 - number_of_bits_set (green_mask)); + private->g_table [i + 1024] + <<= free_bits_at_bottom (green_mask); + private->b_table [i + 1024] + <<= free_bits_at_bottom (blue_mask); + private->b_table [i + 1024] + = i >> (8 - number_of_bits_set (blue_mask)); + if (twopixels) + { + private->r_table [i + 1024] = ((private->r_table [i + 1024] << 16) + | private->r_table [i + 1024]); + private->g_table [i + 1024] = ((private->g_table [i + 1024] << 16) + | private->g_table [i + 1024]); + private->b_table [i + 1024] = ((private->b_table [i + 1024] << 16) + | private->b_table [i + 1024]); + } + private->y_table [i + 1024] = (private->r_table [i + 1024] + | private->g_table [i + 1024] + | private->b_table [i + 1024]); } /* @@ -230,14 +230,14 @@ fiasco_renderer_new (unsigned long red_mask, unsigned long green_mask, */ for (i = 0; i < 1024; i++) { - private->r_table [i] = private->r_table [1024]; - private->r_table [i + 1024 + 256] = private->r_table [1024 + 255]; - private->g_table [i] = private->g_table [1024]; - private->g_table [i + 1024 + 256] = private->g_table [1024 + 255]; - private->b_table [i] = private->b_table [1024]; - private->b_table [i + 1024 + 256] = private->b_table [1024 + 255]; - private->y_table [i] = private->y_table [1024]; - private->y_table [i + 1024 + 256] = private->y_table [1024 + 255]; + private->r_table [i] = private->r_table [1024]; + private->r_table [i + 1024 + 256] = private->r_table [1024 + 255]; + private->g_table [i] = private->g_table [1024]; + private->g_table [i + 1024 + 256] = private->g_table [1024 + 255]; + private->b_table [i] = private->b_table [1024]; + private->b_table [i + 1024 + 256] = private->b_table [1024 + 255]; + private->y_table [i] = private->y_table [1024]; + private->y_table [i + 1024 + 256] = private->y_table [1024 + 255]; } private->r_table += 1024; @@ -247,7 +247,7 @@ fiasco_renderer_new (unsigned long red_mask, unsigned long green_mask, return render; } - + } void @@ -259,7 +259,7 @@ fiasco_renderer_delete (fiasco_renderer_t *renderer) * No return value. * * Side effects: - * structure 'renderer' is discarded. + * structure 'renderer' is discarded. */ { if (!renderer) @@ -284,8 +284,8 @@ fiasco_renderer_delete (fiasco_renderer_t *renderer) int fiasco_renderer_render (const fiasco_renderer_t *renderer, - unsigned char *ximage, - const fiasco_image_t *fiasco_image) + unsigned char *ximage, + const fiasco_image_t *fiasco_image) { if (!renderer) { @@ -298,8 +298,8 @@ fiasco_renderer_render (const fiasco_renderer_t *renderer, /***************************************************************************** - private code - + private code + *****************************************************************************/ /* @@ -313,7 +313,7 @@ fiasco_renderer_render (const fiasco_renderer_t *renderer, * mode, since this involves getting down to byte level again. It is * assumed that the bits for each color are contiguous in the * longword. - * + * * Writing to memory is done in shorts or ints. (Unfortunately, short * is not very fast on Alpha, so there is room for improvement * here). There is no dither time check for overflow - instead the @@ -357,9 +357,9 @@ free_bits_at_bottom (unsigned long a) return 1 + free_bits_at_bottom ( a >> 1); } -static int +static int display_16_bit (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image) + const fiasco_image_t *fiasco_image) /* * Convert 'image' to 16 bit color bitmap. * If 'double_resolution' is true then double image size in both directions. @@ -367,13 +367,13 @@ display_16_bit (const struct fiasco_renderer *this, unsigned char *ximage, * No return value. * * Side effects: - * 'out[]' is filled with dithered image + * 'out[]' is filled with dithered image */ { const image_t *image; renderer_private_t *private; - byte_t *out; - + byte_t *out; + if (!this) { set_error (_("Parameter `%s' not defined (NULL)."), "this"); @@ -390,21 +390,21 @@ display_16_bit (const struct fiasco_renderer *this, unsigned char *ximage, return 0; } - out = (byte_t *) ximage; + out = (byte_t *) ximage; image = cast_image ((fiasco_image_t *) fiasco_image); if (!image) return 0; private = (renderer_private_t *) this->private; - + if (image->color) { - word_t *cbptr, *crptr; /* pointer to chroma bands */ - word_t *yptr; /* pointers to lumincance band */ - int yval, crval, cbval; /* pixel value in YCbCr color space */ - int R, G, B; /* pixel value in RGB color space */ - int n; /* pixel counter */ - int x, y; /* pixel coordinates */ - int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; + word_t *cbptr, *crptr; /* pointer to chroma bands */ + word_t *yptr; /* pointers to lumincance band */ + int yval, crval, cbval; /* pixel value in YCbCr color space */ + int R, G, B; /* pixel value in RGB color space */ + int n; /* pixel counter */ + int x, y; /* pixel coordinates */ + int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; unsigned int *r_table, *g_table, *b_table; Cr_g_tab = private->Cr_g_tab; @@ -420,245 +420,245 @@ display_16_bit (const struct fiasco_renderer *this, unsigned char *ximage, if (image->format == FORMAT_4_2_0) { - u_word_t *dst, *dst2; /* pointers to dithered pixels */ - word_t *yptr2; /* pointers to lumincance band */ - - if (private->double_resolution) - { - yptr2 = yptr + image->width; - dst = (u_word_t *) out; - dst2 = dst + 4 * image->width; - for (y = image->height / 2; y; y--) - { - for (x = image->width / 2; x; x--) - { + u_word_t *dst, *dst2; /* pointers to dithered pixels */ + word_t *yptr2; /* pointers to lumincance band */ + + if (private->double_resolution) + { + yptr2 = yptr + image->width; + dst = (u_word_t *) out; + dst2 = dst + 4 * image->width; + for (y = image->height / 2; y; y--) + { + for (x = image->width / 2; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr++ >> 4) + 128; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr++ / 16 + 128; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - } - memcpy (dst, dst - 2 * image->width, - 2 * image->width * sizeof (u_word_t)); - memcpy (dst2, dst2 - 2 * image->width, - 2 * image->width * sizeof (u_word_t)); - yptr += image->width; - yptr2 += image->width; - dst += 3 * image->width * 2; - dst2 += 3 * image->width * 2; - } - } - else - { - yptr2 = yptr + image->width; - dst = (u_word_t *) out; - dst2 = dst + image->width; - - for (y = image->height / 2; y; y--) - { - for (x = image->width / 2; x; x--) - { + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + } + memcpy (dst, dst - 2 * image->width, + 2 * image->width * sizeof (u_word_t)); + memcpy (dst2, dst2 - 2 * image->width, + 2 * image->width * sizeof (u_word_t)); + yptr += image->width; + yptr2 += image->width; + dst += 3 * image->width * 2; + dst2 += 3 * image->width * 2; + } + } + else + { + yptr2 = yptr + image->width; + dst = (u_word_t *) out; + dst2 = dst + image->width; + + for (y = image->height / 2; y; y--) + { + for (x = image->width / 2; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr++ >> 4) + 128; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr++ / 16 + 128; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - } - yptr += image->width; - yptr2 += image->width; - dst += image->width; - dst2 += image->width; - } - } + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + } + yptr += image->width; + yptr2 += image->width; + dst += image->width; + dst2 += image->width; + } + } } - else /* 4:4:4 format */ + else /* 4:4:4 format */ { - if (private->double_resolution) - { - unsigned int *dst; /* pointer to dithered pixels */ - - dst = (unsigned int *) out; - - for (y = image->height; y; y--) - { - for (x = image->width; x; x--) - { + if (private->double_resolution) + { + unsigned int *dst; /* pointer to dithered pixels */ + + dst = (unsigned int *) out; + + for (y = image->height; y; y--) + { + for (x = image->width; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - - *dst++ = r_table [R] | g_table [G] | b_table [B]; - } - memcpy (dst, dst - image->width, - image->width * sizeof (unsigned int)); - dst += image->width; - } - } - else - { - u_word_t *dst; /* pointer to dithered pixels */ - - dst = (u_word_t *) out; - - for (n = image->width * image->height; n; n--) - { + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + + *dst++ = r_table [R] | g_table [G] | b_table [B]; + } + memcpy (dst, dst - image->width, + image->width * sizeof (unsigned int)); + dst += image->width; + } + } + else + { + u_word_t *dst; /* pointer to dithered pixels */ + + dst = (u_word_t *) out; + + for (n = image->width * image->height; n; n--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - } - } + *dst++ = r_table [R] | g_table [G] | b_table [B]; + } + } } } else { - unsigned int *dst; /* pointer to dithered pixels */ - word_t *src; /* current pixel of frame */ + unsigned int *dst; /* pointer to dithered pixels */ + word_t *src; /* current pixel of frame */ unsigned int *y_table; y_table = private->y_table; dst = (unsigned int *) out; src = image->pixels [GRAY]; - + if (private->double_resolution) { - int x, y; /* pixel coordinates */ - - for (y = image->height; y; y--) - { - for (x = image->width; x; x--) - { - int value; - + int x, y; /* pixel coordinates */ + + for (y = image->height; y; y--) + { + for (x = image->width; x; x--) + { + int value; + #ifdef HAVE_SIGNED_SHIFT - value = y_table [*src++ >> 4]; + value = y_table [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - value = y_table [*src++ / 16]; + value = y_table [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - *dst++ = (value << 16) | value; - } - - memcpy (dst, dst - image->width, - image->width * sizeof (unsigned int)); - dst += image->width; - } + *dst++ = (value << 16) | value; + } + + memcpy (dst, dst - image->width, + image->width * sizeof (unsigned int)); + dst += image->width; + } } else { - int n; /* pixel counter */ - - for (n = image->width * image->height / 2; n; n--, src += 2) + int n; /* pixel counter */ + + for (n = image->width * image->height / 2; n; n--, src += 2) #ifdef HAVE_SIGNED_SHIFT -# if BYTE_ORDER == LITTLE_ENDIAN - *dst++ = (y_table [src [1] >> 4] << 16) | y_table [src [0] >> 4]; -# else - *dst++ = (y_table [src [0] >> 4] << 16) | y_table [src [1] >> 4]; -# endif +# if BYTE_ORDER == LITTLE_ENDIAN + *dst++ = (y_table [src [1] >> 4] << 16) | y_table [src [0] >> 4]; +# else + *dst++ = (y_table [src [0] >> 4] << 16) | y_table [src [1] >> 4]; +# endif #else /* not HAVE_SIGNED_SHIFT */ -# if BYTE_ORDER == LITTLE_ENDIAN - *dst++ = (y_table [src [1] / 16] << 16) | y_table [src [0] / 16]; -# else - *dst++ = (y_table [src [0] / 16] << 16) | y_table [src [1] / 16]; -# endif +# if BYTE_ORDER == LITTLE_ENDIAN + *dst++ = (y_table [src [1] / 16] << 16) | y_table [src [0] / 16]; +# else + *dst++ = (y_table [src [0] / 16] << 16) | y_table [src [1] / 16]; +# endif #endif /* not HAVE_SIGNED_SHIFT */ } } @@ -666,9 +666,9 @@ display_16_bit (const struct fiasco_renderer *this, unsigned char *ximage, return 1; } -static int +static int display_24_bit_bgr (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image) + const fiasco_image_t *fiasco_image) /* * Convert 'image' to 16 bit color bitmap. * If 'double_resolution' is true then double image size in both directions. @@ -676,13 +676,13 @@ display_24_bit_bgr (const struct fiasco_renderer *this, unsigned char *ximage, * No return value. * * Side effects: - * 'out[]' is filled with dithered image + * 'out[]' is filled with dithered image */ { - unsigned *gray_clip = init_clipping (); + unsigned *gray_clip = init_clipping (); const image_t *image; renderer_private_t *private; - byte_t *out; + byte_t *out; if (!gray_clip) return 0; @@ -702,17 +702,17 @@ display_24_bit_bgr (const struct fiasco_renderer *this, unsigned char *ximage, return 0; } - out = (byte_t *) ximage; + out = (byte_t *) ximage; image = cast_image ((fiasco_image_t *) fiasco_image); if (!image) return 0; private = (renderer_private_t *) this->private; - + if (image->color) { - word_t *cbptr, *crptr; /* pointer to chroma bands */ - word_t *yptr; /* pointers to lumincance band */ - int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; + word_t *cbptr, *crptr; /* pointer to chroma bands */ + word_t *yptr; /* pointers to lumincance band */ + int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; Cr_g_tab = private->Cr_g_tab; Cr_r_tab = private->Cr_r_tab; @@ -724,396 +724,396 @@ display_24_bit_bgr (const struct fiasco_renderer *this, unsigned char *ximage, if (image->format == FORMAT_4_2_0) { - if (private->double_resolution) - { - int yval1; /* lumincance pixel */ - int crval1, cbval1; /* chroma pixels */ - int yval2; /* pixel in YCbCr color space */ - unsigned int R1, G1, B1; /* pixel in RGB color space */ - unsigned int R2, G2, B2; /* pixel in RGB color space */ - int x, y; /* pixel counter */ - unsigned int *dst; /* pointer to dithered pixels */ - unsigned int *dst2; /* pointers to dithered pixels */ - word_t *yptr2; /* pointers to lumincance band */ - - dst = (unsigned int *) out; - dst2 = dst + (image->width >> 1) * 3 * 2; - yptr2 = yptr + image->width; - - for (y = image->height >> 1; y; y--) - { - for (x = image->width >> 1; x; x--) - { + if (private->double_resolution) + { + int yval1; /* lumincance pixel */ + int crval1, cbval1; /* chroma pixels */ + int yval2; /* pixel in YCbCr color space */ + unsigned int R1, G1, B1; /* pixel in RGB color space */ + unsigned int R2, G2, B2; /* pixel in RGB color space */ + int x, y; /* pixel counter */ + unsigned int *dst; /* pointer to dithered pixels */ + unsigned int *dst2; /* pointers to dithered pixels */ + word_t *yptr2; /* pointers to lumincance band */ + + dst = (unsigned int *) out; + dst2 = dst + (image->width >> 1) * 3 * 2; + yptr2 = yptr + image->width; + + for (y = image->height >> 1; y; y--) + { + for (x = image->width >> 1; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B1 << 24); - *dst++ = G1 | (R1 << 8) | (B2 << 16) | (G2 << 24); - *dst++ = R2 | (B2 << 8) | (G2 << 16) | (R2 << 24); + *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B1 << 24); + *dst++ = G1 | (R1 << 8) | (B2 << 16) | (G2 << 24); + *dst++ = R2 | (B2 << 8) | (G2 << 16) | (R2 << 24); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr2++ >> 4) + 128; - yval2 = (*yptr2++ >> 4) + 128; + yval1 = (*yptr2++ >> 4) + 128; + yval2 = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr2++ / 16 + 128; - yval2 = *yptr2++ / 16 + 128; + yval1 = *yptr2++ / 16 + 128; + yval2 = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - - *dst2++ = B1 | (G1 << 8) | (R1 << 16) | (B1 << 24); - *dst2++ = G1 | (R1 << 8) | (B2 << 16) | (G2 << 24); - *dst2++ = R2 | (B2 << 8) | (G2 << 16) | (R2 << 24); - } - memcpy (dst, dst - (image->width >> 1) * 3, - (image->width >> 1) * 3 * sizeof (unsigned int)); - memcpy (dst2, dst2 - (image->width >> 1) * 3, - (image->width >> 1) * 3 * sizeof (unsigned int)); - dst += (image->width >> 1) * 3 * 3; - dst2 += (image->width >> 1) * 3 * 3; - yptr += image->width; - yptr2 += image->width; - } - } - else - { - int yval1; /* lumincance pixel */ - int crval1, cbval1; /* chroma pixels */ - int yval2; /* pixel in YCbCr color space */ - unsigned int R1, G1, B1; /* pixel in RGB color space */ - unsigned int R2, G2, B2; /* pixel in RGB color space */ - int x, y; /* pixel counter */ - unsigned int *dst; /* pointer to dithered pixels */ - unsigned int *dst2; /* pointers to dithered pixels */ - word_t *yptr2; /* pointers to lumincance band */ - - dst = (unsigned int *) out; - dst2 = dst + (image->width >> 2) * 3; - yptr2 = yptr + image->width; - - for (y = image->height >> 1; y; y--) - { - for (x = image->width >> 2; x; x--) - { + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + + *dst2++ = B1 | (G1 << 8) | (R1 << 16) | (B1 << 24); + *dst2++ = G1 | (R1 << 8) | (B2 << 16) | (G2 << 24); + *dst2++ = R2 | (B2 << 8) | (G2 << 16) | (R2 << 24); + } + memcpy (dst, dst - (image->width >> 1) * 3, + (image->width >> 1) * 3 * sizeof (unsigned int)); + memcpy (dst2, dst2 - (image->width >> 1) * 3, + (image->width >> 1) * 3 * sizeof (unsigned int)); + dst += (image->width >> 1) * 3 * 3; + dst2 += (image->width >> 1) * 3 * 3; + yptr += image->width; + yptr2 += image->width; + } + } + else + { + int yval1; /* lumincance pixel */ + int crval1, cbval1; /* chroma pixels */ + int yval2; /* pixel in YCbCr color space */ + unsigned int R1, G1, B1; /* pixel in RGB color space */ + unsigned int R2, G2, B2; /* pixel in RGB color space */ + int x, y; /* pixel counter */ + unsigned int *dst; /* pointer to dithered pixels */ + unsigned int *dst2; /* pointers to dithered pixels */ + word_t *yptr2; /* pointers to lumincance band */ + + dst = (unsigned int *) out; + dst2 = dst + (image->width >> 2) * 3; + yptr2 = yptr + image->width; + + for (y = image->height >> 1; y; y--) + { + for (x = image->width >> 2; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B2 << 24); - *dst = G2 | (R2 << 8); + *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B2 << 24); + *dst = G2 | (R2 << 8); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr2++ >> 4) + 128; - yval2 = (*yptr2++ >> 4) + 128; + yval1 = (*yptr2++ >> 4) + 128; + yval2 = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr2++ / 16 + 128; - yval2 = *yptr2++ / 16 + 128; + yval1 = *yptr2++ / 16 + 128; + yval2 = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - - *dst2++ = B1 | (G1 << 8) | (R1 << 16) | (B2 << 24); - *dst2 = G2 | (R2 << 8); - + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + + *dst2++ = B1 | (G1 << 8) | (R1 << 16) | (B2 << 24); + *dst2 = G2 | (R2 << 8); + #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - *dst++ |= (B1 << 16) | (G1 << 24); - *dst++ = R1 | (B2 << 8) | (G2 << 16) | (R2 << 24); + *dst++ |= (B1 << 16) | (G1 << 24); + *dst++ = R1 | (B2 << 8) | (G2 << 16) | (R2 << 24); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr2++ >> 4) + 128; - yval2 = (*yptr2++ >> 4) + 128; + yval1 = (*yptr2++ >> 4) + 128; + yval2 = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr2++ / 16 + 128; - yval2 = *yptr2++ / 16 + 128; + yval1 = *yptr2++ / 16 + 128; + yval2 = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - - *dst2++ |= (B1 << 16) | (G1 << 24); - *dst2++ = R1 | (B2 << 8) | (G2 << 16) | (R2 << 24); - } - dst += (image->width >> 2) * 3; - dst2 += (image->width >> 2) * 3; - yptr += image->width; - yptr2 += image->width; - } - } + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + + *dst2++ |= (B1 << 16) | (G1 << 24); + *dst2++ = R1 | (B2 << 8) | (G2 << 16) | (R2 << 24); + } + dst += (image->width >> 2) * 3; + dst2 += (image->width >> 2) * 3; + yptr += image->width; + yptr2 += image->width; + } + } } - else /* 4:4:4 format */ + else /* 4:4:4 format */ { - if (private->double_resolution) - { - unsigned int R1, G1, B1; /* pixel1 in RGB color space */ - unsigned int R2, G2, B2; /* pixel2 in RGB color space */ - int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ - int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ - int x, y; /* pixel counter */ - unsigned int *dst; /* dithered pixel pointer */ - - dst = (unsigned int *) out; - - for (y = image->height; y; y--) - { - for (x = image->width >> 1; x; x--) - { + if (private->double_resolution) + { + unsigned int R1, G1, B1; /* pixel1 in RGB color space */ + unsigned int R2, G2, B2; /* pixel2 in RGB color space */ + int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ + int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ + int x, y; /* pixel counter */ + unsigned int *dst; /* dithered pixel pointer */ + + dst = (unsigned int *) out; + + for (y = image->height; y; y--) + { + for (x = image->width >> 1; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - crval2 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; - cbval2 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + crval2 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; + cbval2 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval2] - + Cb_g_tab [cbval2]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; - - *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B1 << 24); - *dst++ = G1 | (R1 << 8) | (B2 << 16) | (G2 << 24); - *dst++ = R2 | (B2 << 8) | (G2 << 16) | (R2 << 24); - } - memcpy (dst, dst - 3 * (image->width >> 1), - 3 * (image->width >> 1) * sizeof (unsigned int)); - dst += 3 * (image->width >> 1); - } - } - else - { - unsigned int R1, G1, B1; /* pixel in RGB color space */ - unsigned int R2, G2, B2; /* pixel in RGB color space */ - int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ - int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ - int n; /* pixel counter */ - unsigned int *dst; /* dithered pixel pointer */ - - dst = (unsigned int *) out; - - for (n = (image->width * image->height) >> 2; n; n--) - { + + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval2] + + Cb_g_tab [cbval2]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; + + *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B1 << 24); + *dst++ = G1 | (R1 << 8) | (B2 << 16) | (G2 << 24); + *dst++ = R2 | (B2 << 8) | (G2 << 16) | (R2 << 24); + } + memcpy (dst, dst - 3 * (image->width >> 1), + 3 * (image->width >> 1) * sizeof (unsigned int)); + dst += 3 * (image->width >> 1); + } + } + else + { + unsigned int R1, G1, B1; /* pixel in RGB color space */ + unsigned int R2, G2, B2; /* pixel in RGB color space */ + int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ + int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ + int n; /* pixel counter */ + unsigned int *dst; /* dithered pixel pointer */ + + dst = (unsigned int *) out; + + for (n = (image->width * image->height) >> 2; n; n--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - crval2 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; - cbval2 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + crval2 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; + cbval2 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; - *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B2 << 24); - *dst = G2 | (R2 << 8); + *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B2 << 24); + *dst = G2 | (R2 << 8); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - crval2 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; - cbval2 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + crval2 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; + cbval2 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; - - *dst++ |= (B1 << 16) | (G1 << 24); - *dst++ = R1 | (B2 << 8) | (G2 << 16) | (R2 << 24); - } - } + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; + + *dst++ |= (B1 << 16) | (G1 << 24); + *dst++ = R1 | (B2 << 8) | (G2 << 16) | (R2 << 24); + } + } } } else { - unsigned int *dst; /* pointer to dithered pixels */ - word_t *src; /* current pixel of frame */ + unsigned int *dst; /* pointer to dithered pixels */ + word_t *src; /* current pixel of frame */ dst = (unsigned int *) out; src = image->pixels [GRAY]; if (private->double_resolution) { - int x, y; /* pixel counter */ - unsigned *shift_clipping = gray_clip + 128; - - for (y = image->height; y; y--) - { - for (x = image->width >> 1; x; x--) - { - unsigned int val1, val2; + int x, y; /* pixel counter */ + unsigned *shift_clipping = gray_clip + 128; + + for (y = image->height; y; y--) + { + for (x = image->width >> 1; x; x--) + { + unsigned int val1, val2; #ifdef HAVE_SIGNED_SHIFT - val1 = shift_clipping [*src++ >> 4]; - val2 = shift_clipping [*src++ >> 4]; + val1 = shift_clipping [*src++ >> 4]; + val2 = shift_clipping [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - val1 = shift_clipping [*src++ / 16]; - val2 = shift_clipping [*src++ / 16]; + val1 = shift_clipping [*src++ / 16]; + val2 = shift_clipping [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - *dst++ = val1 | (val1 << 8) | (val1 << 16) | (val1 << 24); - *dst++ = val1 | (val1 << 8) | (val2 << 16) | (val2 << 24); - *dst++ = val2 | (val2 << 8) | (val2 << 16) | (val2 << 24); - } + *dst++ = val1 | (val1 << 8) | (val1 << 16) | (val1 << 24); + *dst++ = val1 | (val1 << 8) | (val2 << 16) | (val2 << 24); + *dst++ = val2 | (val2 << 8) | (val2 << 16) | (val2 << 24); + } - memcpy (dst, dst - 3 * (image->width >> 1), - 3 * (image->width >> 1) * sizeof (unsigned int)); - dst += 3 * (image->width >> 1); - } + memcpy (dst, dst - 3 * (image->width >> 1), + 3 * (image->width >> 1) * sizeof (unsigned int)); + dst += 3 * (image->width >> 1); + } } else { - int n; /* pixel counter */ - unsigned *shift_clipping = gray_clip + 128; + int n; /* pixel counter */ + unsigned *shift_clipping = gray_clip + 128; - for (n = (image->width * image->height) >> 2; n; n--) - { - unsigned int val1, val2; + for (n = (image->width * image->height) >> 2; n; n--) + { + unsigned int val1, val2; #ifdef HAVE_SIGNED_SHIFT - val1 = shift_clipping [*src++ >> 4]; - val2 = shift_clipping [*src++ >> 4]; + val1 = shift_clipping [*src++ >> 4]; + val2 = shift_clipping [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - val1 = shift_clipping [*src++ / 16]; - val2 = shift_clipping [*src++ / 16]; + val1 = shift_clipping [*src++ / 16]; + val2 = shift_clipping [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - *dst++ = val1 | (val1 << 8) - | (val1 << 16) | (val2 << 24); /* RGBR */ - *dst = val2 | (val2 << 8); /* GB-- */ + *dst++ = val1 | (val1 << 8) + | (val1 << 16) | (val2 << 24); /* RGBR */ + *dst = val2 | (val2 << 8); /* GB-- */ #ifdef HAVE_SIGNED_SHIFT - val1 = shift_clipping [*src++ >> 4]; - val2 = shift_clipping [*src++ >> 4]; + val1 = shift_clipping [*src++ >> 4]; + val2 = shift_clipping [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - val1 = shift_clipping [*src++ / 16]; - val2 = shift_clipping [*src++ / 16]; + val1 = shift_clipping [*src++ / 16]; + val2 = shift_clipping [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - - *dst++ |= (val1 << 16) | (val1 << 24); /* --RG */ - *dst++ = val1 | (val2 << 8) - | (val2 << 16) | (val2 << 24); /* BRGB */ - } + + *dst++ |= (val1 << 16) | (val1 << 24); /* --RG */ + *dst++ = val1 | (val2 << 8) + | (val2 << 16) | (val2 << 24); /* BRGB */ + } } } - + return 1; } -static int +static int display_24_bit_rgb (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image) + const fiasco_image_t *fiasco_image) /* * Convert 'image' to 16 bit color bitmap. * If 'double_resolution' is true then double image size in both directions. @@ -1121,13 +1121,13 @@ display_24_bit_rgb (const struct fiasco_renderer *this, unsigned char *ximage, * No return value. * * Side effects: - * 'out[]' is filled with dithered image + * 'out[]' is filled with dithered image */ { - unsigned *gray_clip = init_clipping (); + unsigned *gray_clip = init_clipping (); const image_t *image; renderer_private_t *private; - byte_t *out; + byte_t *out; if (!gray_clip) return 0; @@ -1147,17 +1147,17 @@ display_24_bit_rgb (const struct fiasco_renderer *this, unsigned char *ximage, return 0; } - out = (byte_t *) ximage; + out = (byte_t *) ximage; image = cast_image ((fiasco_image_t *) fiasco_image); if (!image) return 0; private = (renderer_private_t *) this->private; - + if (image->color) { - word_t *cbptr, *crptr; /* pointer to chroma bands */ - word_t *yptr; /* pointers to lumincance band */ - int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; + word_t *cbptr, *crptr; /* pointer to chroma bands */ + word_t *yptr; /* pointers to lumincance band */ + int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; Cr_g_tab = private->Cr_g_tab; Cr_r_tab = private->Cr_r_tab; @@ -1169,396 +1169,396 @@ display_24_bit_rgb (const struct fiasco_renderer *this, unsigned char *ximage, if (image->format == FORMAT_4_2_0) { - if (private->double_resolution) - { - int yval1; /* lumincance pixel */ - int crval1, cbval1; /* chroma pixels */ - int yval2; /* pixel in YCbCr color space */ - unsigned int R1, G1, B1; /* pixel in RGB color space */ - unsigned int R2, G2, B2; /* pixel in RGB color space */ - int x, y; /* pixel counter */ - unsigned int *dst; /* pointer to dithered pixels */ - unsigned int *dst2; /* pointers to dithered pixels */ - word_t *yptr2; /* pointers to lumincance band */ - - dst = (unsigned int *) out; - dst2 = dst + (image->width >> 1) * 3 * 2; - yptr2 = yptr + image->width; - - for (y = image->height >> 1; y; y--) - { - for (x = image->width >> 1; x; x--) - { + if (private->double_resolution) + { + int yval1; /* lumincance pixel */ + int crval1, cbval1; /* chroma pixels */ + int yval2; /* pixel in YCbCr color space */ + unsigned int R1, G1, B1; /* pixel in RGB color space */ + unsigned int R2, G2, B2; /* pixel in RGB color space */ + int x, y; /* pixel counter */ + unsigned int *dst; /* pointer to dithered pixels */ + unsigned int *dst2; /* pointers to dithered pixels */ + word_t *yptr2; /* pointers to lumincance band */ + + dst = (unsigned int *) out; + dst2 = dst + (image->width >> 1) * 3 * 2; + yptr2 = yptr + image->width; + + for (y = image->height >> 1; y; y--) + { + for (x = image->width >> 1; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R1 << 24); - *dst++ = G1 | (B1 << 8) | (R2 << 16) | (G2 << 24); - *dst++ = B2 | (R2 << 8) | (G2 << 16) | (B2 << 24); + *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R1 << 24); + *dst++ = G1 | (B1 << 8) | (R2 << 16) | (G2 << 24); + *dst++ = B2 | (R2 << 8) | (G2 << 16) | (B2 << 24); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr2++ >> 4) + 128; - yval2 = (*yptr2++ >> 4) + 128; + yval1 = (*yptr2++ >> 4) + 128; + yval2 = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr2++ / 16 + 128; - yval2 = *yptr2++ / 16 + 128; + yval1 = *yptr2++ / 16 + 128; + yval2 = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - - *dst2++ = R1 | (G1 << 8) | (B1 << 16) | (R1 << 24); - *dst2++ = G1 | (B1 << 8) | (R2 << 16) | (G2 << 24); - *dst2++ = B2 | (R2 << 8) | (G2 << 16) | (B2 << 24); - } - memcpy (dst, dst - (image->width >> 1) * 3, - (image->width >> 1) * 3 * sizeof (unsigned int)); - memcpy (dst2, dst2 - (image->width >> 1) * 3, - (image->width >> 1) * 3 * sizeof (unsigned int)); - dst += (image->width >> 1) * 3 * 3; - dst2 += (image->width >> 1) * 3 * 3; - yptr += image->width; - yptr2 += image->width; - } - } - else - { - int yval1; /* lumincance pixel */ - int crval1, cbval1; /* chroma pixels */ - int yval2; /* pixel in YCbCr color space */ - unsigned int R1, G1, B1; /* pixel in RGB color space */ - unsigned int R2, G2, B2; /* pixel in RGB color space */ - int x, y; /* pixel counter */ - unsigned int *dst; /* pointer to dithered pixels */ - unsigned int *dst2; /* pointers to dithered pixels */ - word_t *yptr2; /* pointers to lumincance band */ - - dst = (unsigned int *) out; - dst2 = dst + (image->width >> 2) * 3; - yptr2 = yptr + image->width; - - for (y = image->height >> 1; y; y--) - { - for (x = image->width >> 2; x; x--) - { + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + + *dst2++ = R1 | (G1 << 8) | (B1 << 16) | (R1 << 24); + *dst2++ = G1 | (B1 << 8) | (R2 << 16) | (G2 << 24); + *dst2++ = B2 | (R2 << 8) | (G2 << 16) | (B2 << 24); + } + memcpy (dst, dst - (image->width >> 1) * 3, + (image->width >> 1) * 3 * sizeof (unsigned int)); + memcpy (dst2, dst2 - (image->width >> 1) * 3, + (image->width >> 1) * 3 * sizeof (unsigned int)); + dst += (image->width >> 1) * 3 * 3; + dst2 += (image->width >> 1) * 3 * 3; + yptr += image->width; + yptr2 += image->width; + } + } + else + { + int yval1; /* lumincance pixel */ + int crval1, cbval1; /* chroma pixels */ + int yval2; /* pixel in YCbCr color space */ + unsigned int R1, G1, B1; /* pixel in RGB color space */ + unsigned int R2, G2, B2; /* pixel in RGB color space */ + int x, y; /* pixel counter */ + unsigned int *dst; /* pointer to dithered pixels */ + unsigned int *dst2; /* pointers to dithered pixels */ + word_t *yptr2; /* pointers to lumincance band */ + + dst = (unsigned int *) out; + dst2 = dst + (image->width >> 2) * 3; + yptr2 = yptr + image->width; + + for (y = image->height >> 1; y; y--) + { + for (x = image->width >> 2; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R2 << 24); - *dst = G2 | (B2 << 8); + *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R2 << 24); + *dst = G2 | (B2 << 8); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr2++ >> 4) + 128; - yval2 = (*yptr2++ >> 4) + 128; + yval1 = (*yptr2++ >> 4) + 128; + yval2 = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr2++ / 16 + 128; - yval2 = *yptr2++ / 16 + 128; + yval1 = *yptr2++ / 16 + 128; + yval2 = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - - *dst2++ = R1 | (G1 << 8) | (B1 << 16) | (R2 << 24); - *dst2 = G2 | (B2 << 8); - + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + + *dst2++ = R1 | (G1 << 8) | (B1 << 16) | (R2 << 24); + *dst2 = G2 | (B2 << 8); + #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - *dst++ |= (R1 << 16) | (G1 << 24); - *dst++ = B1 | (R2 << 8) | (G2 << 16) | (B2 << 24); + *dst++ |= (R1 << 16) | (G1 << 24); + *dst++ = B1 | (R2 << 8) | (G2 << 16) | (B2 << 24); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr2++ >> 4) + 128; - yval2 = (*yptr2++ >> 4) + 128; + yval1 = (*yptr2++ >> 4) + 128; + yval2 = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr2++ / 16 + 128; - yval2 = *yptr2++ / 16 + 128; + yval1 = *yptr2++ / 16 + 128; + yval2 = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - - *dst2++ |= (R1 << 16) | (G1 << 24); - *dst2++ = B1 | (R2 << 8) | (G2 << 16) | (B2 << 24); - } - dst += (image->width >> 2) * 3; - dst2 += (image->width >> 2) * 3; - yptr += image->width; - yptr2 += image->width; - } - } + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + + *dst2++ |= (R1 << 16) | (G1 << 24); + *dst2++ = B1 | (R2 << 8) | (G2 << 16) | (B2 << 24); + } + dst += (image->width >> 2) * 3; + dst2 += (image->width >> 2) * 3; + yptr += image->width; + yptr2 += image->width; + } + } } - else /* 4:4:4 format */ + else /* 4:4:4 format */ { - if (private->double_resolution) - { - unsigned int R1, G1, B1; /* pixel1 in RGB color space */ - unsigned int R2, G2, B2; /* pixel2 in RGB color space */ - int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ - int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ - int x, y; /* pixel counter */ - unsigned int *dst; /* dithered pixel pointer */ - - dst = (unsigned int *) out; - - for (y = image->height; y; y--) - { - for (x = image->width >> 1; x; x--) - { + if (private->double_resolution) + { + unsigned int R1, G1, B1; /* pixel1 in RGB color space */ + unsigned int R2, G2, B2; /* pixel2 in RGB color space */ + int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ + int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ + int x, y; /* pixel counter */ + unsigned int *dst; /* dithered pixel pointer */ + + dst = (unsigned int *) out; + + for (y = image->height; y; y--) + { + for (x = image->width >> 1; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - crval2 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; - cbval2 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + crval2 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; + cbval2 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval2] - + Cb_g_tab [cbval2]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; - - *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R1 << 24); - *dst++ = G1 | (B1 << 8) | (R2 << 16) | (G2 << 24); - *dst++ = B2 | (R2 << 8) | (G2 << 16) | (B2 << 24); - } - memcpy (dst, dst - 3 * (image->width >> 1), - 3 * (image->width >> 1) * sizeof (unsigned int)); - dst += 3 * (image->width >> 1); - } - } - else - { - unsigned int R1, G1, B1; /* pixel in RGB color space */ - unsigned int R2, G2, B2; /* pixel in RGB color space */ - int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ - int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ - int n; /* pixel counter */ - unsigned int *dst; /* dithered pixel pointer */ - - dst = (unsigned int *) out; - - for (n = (image->width * image->height) >> 2; n; n--) - { + + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval2] + + Cb_g_tab [cbval2]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; + + *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R1 << 24); + *dst++ = G1 | (B1 << 8) | (R2 << 16) | (G2 << 24); + *dst++ = B2 | (R2 << 8) | (G2 << 16) | (B2 << 24); + } + memcpy (dst, dst - 3 * (image->width >> 1), + 3 * (image->width >> 1) * sizeof (unsigned int)); + dst += 3 * (image->width >> 1); + } + } + else + { + unsigned int R1, G1, B1; /* pixel in RGB color space */ + unsigned int R2, G2, B2; /* pixel in RGB color space */ + int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ + int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ + int n; /* pixel counter */ + unsigned int *dst; /* dithered pixel pointer */ + + dst = (unsigned int *) out; + + for (n = (image->width * image->height) >> 2; n; n--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - crval2 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; - cbval2 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + crval2 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; + cbval2 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; - *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R2 << 24); - *dst = G2 | (B2 << 8); + *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R2 << 24); + *dst = G2 | (B2 << 8); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - crval2 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; - cbval2 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + crval2 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; + cbval2 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; - - *dst++ |= (R1 << 16) | (G1 << 24); - *dst++ = B1 | (R2 << 8) | (G2 << 16) | (B2 << 24); - } - } + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; + + *dst++ |= (R1 << 16) | (G1 << 24); + *dst++ = B1 | (R2 << 8) | (G2 << 16) | (B2 << 24); + } + } } } else { - unsigned int *dst; /* pointer to dithered pixels */ - word_t *src; /* current pixel of frame */ + unsigned int *dst; /* pointer to dithered pixels */ + word_t *src; /* current pixel of frame */ dst = (unsigned int *) out; src = image->pixels [GRAY]; if (private->double_resolution) { - int x, y; /* pixel counter */ - unsigned *shift_clipping = gray_clip + 128; - - for (y = image->height; y; y--) - { - for (x = image->width >> 1; x; x--) - { - unsigned int val1, val2; + int x, y; /* pixel counter */ + unsigned *shift_clipping = gray_clip + 128; + + for (y = image->height; y; y--) + { + for (x = image->width >> 1; x; x--) + { + unsigned int val1, val2; #ifdef HAVE_SIGNED_SHIFT - val1 = shift_clipping [*src++ >> 4]; - val2 = shift_clipping [*src++ >> 4]; + val1 = shift_clipping [*src++ >> 4]; + val2 = shift_clipping [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - val1 = shift_clipping [*src++ / 16]; - val2 = shift_clipping [*src++ / 16]; + val1 = shift_clipping [*src++ / 16]; + val2 = shift_clipping [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - *dst++ = val1 | (val1 << 8) | (val1 << 16) | (val1 << 24); - *dst++ = val1 | (val1 << 8) | (val2 << 16) | (val2 << 24); - *dst++ = val2 | (val2 << 8) | (val2 << 16) | (val2 << 24); - } + *dst++ = val1 | (val1 << 8) | (val1 << 16) | (val1 << 24); + *dst++ = val1 | (val1 << 8) | (val2 << 16) | (val2 << 24); + *dst++ = val2 | (val2 << 8) | (val2 << 16) | (val2 << 24); + } - memcpy (dst, dst - 3 * (image->width >> 1), - 3 * (image->width >> 1) * sizeof (unsigned int)); - dst += 3 * (image->width >> 1); - } + memcpy (dst, dst - 3 * (image->width >> 1), + 3 * (image->width >> 1) * sizeof (unsigned int)); + dst += 3 * (image->width >> 1); + } } else { - int n; /* pixel counter */ - unsigned *shift_clipping = gray_clip + 128; + int n; /* pixel counter */ + unsigned *shift_clipping = gray_clip + 128; - for (n = (image->width * image->height) >> 2; n; n--) - { - unsigned int val1, val2; + for (n = (image->width * image->height) >> 2; n; n--) + { + unsigned int val1, val2; #ifdef HAVE_SIGNED_SHIFT - val1 = shift_clipping [*src++ >> 4]; - val2 = shift_clipping [*src++ >> 4]; + val1 = shift_clipping [*src++ >> 4]; + val2 = shift_clipping [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - val1 = shift_clipping [*src++ / 16]; - val2 = shift_clipping [*src++ / 16]; + val1 = shift_clipping [*src++ / 16]; + val2 = shift_clipping [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - *dst++ = val1 | (val1 << 8) - | (val1 << 16) | (val2 << 24); /* RGBR */ - *dst = val2 | (val2 << 8); /* GB-- */ + *dst++ = val1 | (val1 << 8) + | (val1 << 16) | (val2 << 24); /* RGBR */ + *dst = val2 | (val2 << 8); /* GB-- */ #ifdef HAVE_SIGNED_SHIFT - val1 = shift_clipping [*src++ >> 4]; - val2 = shift_clipping [*src++ >> 4]; + val1 = shift_clipping [*src++ >> 4]; + val2 = shift_clipping [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - val1 = shift_clipping [*src++ / 16]; - val2 = shift_clipping [*src++ / 16]; + val1 = shift_clipping [*src++ / 16]; + val2 = shift_clipping [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - - *dst++ |= (val1 << 16) | (val1 << 24); /* --RG */ - *dst++ = val1 | (val2 << 8) - | (val2 << 16) | (val2 << 24); /* BRGB */ - } + + *dst++ |= (val1 << 16) | (val1 << 24); /* --RG */ + *dst++ = val1 | (val2 << 8) + | (val2 << 16) | (val2 << 24); /* BRGB */ + } } } - + return 1; } -static int +static int display_32_bit (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image) + const fiasco_image_t *fiasco_image) /* * Convert 'image' to 16 bit color bitmap. * If 'double_resolution' is true then double image size in both directions. @@ -1566,13 +1566,13 @@ display_32_bit (const struct fiasco_renderer *this, unsigned char *ximage, * No return value. * * Side effects: - * 'out[]' is filled with dithered image + * 'out[]' is filled with dithered image */ { const image_t *image; renderer_private_t *private; - byte_t *out; - + byte_t *out; + if (!this) { set_error (_("Parameter `%s' not defined (NULL)."), "this"); @@ -1589,21 +1589,21 @@ display_32_bit (const struct fiasco_renderer *this, unsigned char *ximage, return 0; } - out = (byte_t *) ximage; + out = (byte_t *) ximage; private = (renderer_private_t *) this->private; image = cast_image ((fiasco_image_t *) fiasco_image); if (!image) return 0; - + if (image->color) { - word_t *cbptr, *crptr; /* pointer to chroma bands */ - word_t *yptr; /* pointers to lumincance band */ - int yval, crval, cbval; /* pixel value in YCbCr color space */ - int R, G, B; /* pixel value in RGB color space */ - int n; /* pixel counter */ - int x, y; /* pixel coordinates */ - int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; + word_t *cbptr, *crptr; /* pointer to chroma bands */ + word_t *yptr; /* pointers to lumincance band */ + int yval, crval, cbval; /* pixel value in YCbCr color space */ + int R, G, B; /* pixel value in RGB color space */ + int n; /* pixel counter */ + int x, y; /* pixel coordinates */ + int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; unsigned int *r_table, *g_table, *b_table; Cr_g_tab = private->Cr_g_tab; @@ -1619,245 +1619,245 @@ display_32_bit (const struct fiasco_renderer *this, unsigned char *ximage, if (image->format == FORMAT_4_2_0) { - unsigned int *dst, *dst2; /* pointers to dithered pixels */ - word_t *yptr2; /* pointers to lumincance band */ - - if (private->double_resolution) - { - yptr2 = yptr + image->width; - dst = (unsigned int *) out; - dst2 = dst + 4 * image->width; - for (y = image->height / 2; y; y--) - { - for (x = image->width / 2; x; x--) - { + unsigned int *dst, *dst2; /* pointers to dithered pixels */ + word_t *yptr2; /* pointers to lumincance band */ + + if (private->double_resolution) + { + yptr2 = yptr + image->width; + dst = (unsigned int *) out; + dst2 = dst + 4 * image->width; + for (y = image->height / 2; y; y--) + { + for (x = image->width / 2; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr++ >> 4) + 128; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr++ / 16 + 128; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - } - memcpy (dst, dst - 2 * image->width, - 2 * image->width * sizeof (unsigned int)); - memcpy (dst2, dst2 - 2 * image->width, - 2 * image->width * sizeof (unsigned int)); - yptr += image->width; - yptr2 += image->width; - dst += 3 * image->width * 2; - dst2 += 3 * image->width * 2; - } - } - else - { - yptr2 = yptr + image->width; - dst = (unsigned int *) out; - dst2 = dst + image->width; - - for (y = image->height / 2; y; y--) - { - for (x = image->width / 2; x; x--) - { + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + } + memcpy (dst, dst - 2 * image->width, + 2 * image->width * sizeof (unsigned int)); + memcpy (dst2, dst2 - 2 * image->width, + 2 * image->width * sizeof (unsigned int)); + yptr += image->width; + yptr2 += image->width; + dst += 3 * image->width * 2; + dst2 += 3 * image->width * 2; + } + } + else + { + yptr2 = yptr + image->width; + dst = (unsigned int *) out; + dst2 = dst + image->width; + + for (y = image->height / 2; y; y--) + { + for (x = image->width / 2; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr++ >> 4) + 128; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr++ / 16 + 128; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - } - yptr += image->width; - yptr2 += image->width; - dst += image->width; - dst2 += image->width; - } - } + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + } + yptr += image->width; + yptr2 += image->width; + dst += image->width; + dst2 += image->width; + } + } } - else /* 4:4:4 format */ + else /* 4:4:4 format */ { - if (private->double_resolution) - { - unsigned int *dst; /* pointer to dithered pixels */ - - dst = (unsigned int *) out; - - for (y = image->height; y; y--) - { - for (x = image->width; x; x--) - { + if (private->double_resolution) + { + unsigned int *dst; /* pointer to dithered pixels */ + + dst = (unsigned int *) out; + + for (y = image->height; y; y--) + { + for (x = image->width; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - - *dst++ = r_table [R] | g_table [G] | b_table [B]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - } - memcpy (dst, dst - 2 * image->width, - 2 * image->width * sizeof (unsigned int)); - dst += image->width * 2; - } - } - else - { - unsigned int *dst; /* pointer to dithered pixels */ - - dst = (unsigned int *) out; - - for (n = image->width * image->height; n; n--) - { + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + + *dst++ = r_table [R] | g_table [G] | b_table [B]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + } + memcpy (dst, dst - 2 * image->width, + 2 * image->width * sizeof (unsigned int)); + dst += image->width * 2; + } + } + else + { + unsigned int *dst; /* pointer to dithered pixels */ + + dst = (unsigned int *) out; + + for (n = image->width * image->height; n; n--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - } - } + *dst++ = r_table [R] | g_table [G] | b_table [B]; + } + } } } else { - unsigned int *dst; /* pointer to dithered pixels */ - word_t *src; /* current pixel of frame */ + unsigned int *dst; /* pointer to dithered pixels */ + word_t *src; /* current pixel of frame */ unsigned int *y_table; y_table = private->y_table; dst = (unsigned int *) out; src = image->pixels [GRAY]; - + if (private->double_resolution) { - int x, y; /* pixel coordinates */ - - for (y = image->height; y; y--) - { - for (x = image->width; x; x--) - { - int value; + int x, y; /* pixel coordinates */ + + for (y = image->height; y; y--) + { + for (x = image->width; x; x--) + { + int value; #ifdef HAVE_SIGNED_SHIFT - value = y_table [*src++ >> 4]; + value = y_table [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - value = y_table [*src++ / 16]; + value = y_table [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - *dst++ = value; - *dst++ = value; - } - - memcpy (dst, dst - 2 * image->width, - 2 * image->width * sizeof (unsigned int)); - dst += 2 * image->width; - } + *dst++ = value; + *dst++ = value; + } + + memcpy (dst, dst - 2 * image->width, + 2 * image->width * sizeof (unsigned int)); + dst += 2 * image->width; + } } else { - int n; /* pixel counter */ - - for (n = image->width * image->height; n; n--) + int n; /* pixel counter */ + + for (n = image->width * image->height; n; n--) #ifdef HAVE_SIGNED_SHIFT - *dst++ = y_table [*src++ >> 4]; + *dst++ = y_table [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - *dst++ = y_table [*src++ / 16]; + *dst++ = y_table [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ } } - + return 1; } - + diff --git a/converter/other/fiasco/lib/dither.h b/converter/other/fiasco/lib/dither.h index 767bca28..e786af1f 100644 --- a/converter/other/fiasco/lib/dither.h +++ b/converter/other/fiasco/lib/dither.h @@ -1,8 +1,8 @@ /* * dither.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -19,9 +19,9 @@ typedef struct renderer_private { - int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; + int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; unsigned int *r_table, *g_table, *b_table, *y_table; - bool_t double_resolution; + bool_t double_resolution; } renderer_private_t; #endif /* _DITHER_H */ diff --git a/converter/other/fiasco/lib/error.c b/converter/other/fiasco/lib/error.c index 394f896f..30d0cf97 100644 --- a/converter/other/fiasco/lib/error.c +++ b/converter/other/fiasco/lib/error.c @@ -1,11 +1,11 @@ /* - * error.c: Error handling + * error.c: Error handling * - * Written by: Stefan Frank - * Ullrich Hafner + * Written by: Stefan Frank + * Ullrich Hafner * - * Credits: Modelled after variable argument routines from Jef - * Poskanzer's pbmplus package. + * Credits: Modelled after variable argument routines from Jef + * Poskanzer's pbmplus package. * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -24,7 +24,7 @@ #include <string.h> #if HAVE_SETJMP_H -# include <setjmp.h> +# include <setjmp.h> #endif /* HAVE_SETJMP_H */ #include "types.h" @@ -36,12 +36,12 @@ /***************************************************************************** - local variables + local variables *****************************************************************************/ static fiasco_verbosity_e verboselevel = FIASCO_SOME_VERBOSITY; -static char *error_message = NULL; +static char *error_message = NULL; #if HAVE_SETJMP_H jmp_buf env; @@ -49,7 +49,7 @@ jmp_buf env; /***************************************************************************** - public code + public code *****************************************************************************/ @@ -195,7 +195,7 @@ warning(const char * const format, ...) { /*---------------------------------------------------------------------------- Issue a warning. -----------------------------------------------------------------------------*/ - va_list args; + va_list args; VA_START (args, format); diff --git a/converter/other/fiasco/lib/error.h b/converter/other/fiasco/lib/error.h index 4159ccd2..dd6a049f 100644 --- a/converter/other/fiasco/lib/error.h +++ b/converter/other/fiasco/lib/error.h @@ -1,6 +1,6 @@ /* * error.h - * + * * Written by: Stefan Frank * Ullrich Hafner * @@ -19,11 +19,11 @@ void file_error (const char *filename); void message (const char *format, ...); -void +void debug_message (const char *format, ...); void warning (const char *format, ...); -void +void info (const char *format, ...); const char * get_system_error (void); diff --git a/converter/other/fiasco/lib/image.h b/converter/other/fiasco/lib/image.h index c3c5f0df..d6a3c6c0 100644 --- a/converter/other/fiasco/lib/image.h +++ b/converter/other/fiasco/lib/image.h @@ -1,8 +1,8 @@ /* * image.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -31,11 +31,11 @@ typedef struct image { char id [8]; /* NUL-terminated "IFIASCO" */ unsigned reference_count; - unsigned width; /* Width of the image */ - unsigned height; /* Height of the image */ - bool_t color; /* Color or grayscale image */ - format_e format; /* Pixel format 4:4:4 or 4:2:0 */ - word_t *pixels [3]; /* Pixels in short format */ + unsigned width; /* Width of the image */ + unsigned height; /* Height of the image */ + bool_t color; /* Color or grayscale image */ + format_e format; /* Pixel format 4:4:4 or 4:2:0 */ + word_t *pixels [3]; /* Pixels in short format */ } image_t; image_t * @@ -48,7 +48,7 @@ void free_image (image_t *image); FILE * read_pnmheader (const char *image_name, unsigned *width, unsigned *height, - bool_t *color); + bool_t *color); image_t * read_image_stream(FILE * const ifP, diff --git a/converter/other/fiasco/lib/list.c b/converter/other/fiasco/lib/list.c index b67ff4b8..24ba4985 100644 --- a/converter/other/fiasco/lib/list.c +++ b/converter/other/fiasco/lib/list.c @@ -1,8 +1,8 @@ /* - * list.c: List operations + * list.c: List operations + * + * Written by: Ullrich Hafner * - * Written by: Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -27,8 +27,8 @@ /***************************************************************************** - public code - + public code + *****************************************************************************/ list_t * @@ -39,15 +39,15 @@ alloc_list (size_t size_of_element) * Size of list element values is given by 'size_of_element'. * * Return value: - * pointer to an empty list + * pointer to an empty list */ { list_t *new_list = Calloc (1, sizeof (list_t)); assert (size_of_element > 0); - new_list->head = NULL; - new_list->tail = NULL; + new_list->head = NULL; + new_list->tail = NULL; new_list->size_of_element = size_of_element; return new_list; @@ -62,11 +62,11 @@ free_list (list_t *list) * No return value. * * Side effects: - * struct 'list' is discarded + * struct 'list' is discarded */ { assert (list); - + while (list_remove (list, HEAD, NULL)) ; Free (list); @@ -76,7 +76,7 @@ void list_insert (list_t *list, pos_e pos, const void *data) /* * Insert a new 'list' element at head ('pos' = HEAD) or - * tail ('pos' = TAIL) of 'list'. + * tail ('pos' = TAIL) of 'list'. * 'data' is a pointer to a memory segment of size * 'list'->size_of_element containing the value to store. * The value is directly copied - no references are stored. @@ -84,14 +84,14 @@ list_insert (list_t *list, pos_e pos, const void *data) * No return value. * * Side effects: - * lists current tail or head is replaced by the new element + * lists current tail or head is replaced by the new element */ { node_t *element; assert (list && data); - element = Calloc (1, sizeof (node_t)); + element = Calloc (1, sizeof (node_t)); element->value = Calloc (1, list->size_of_element); memcpy (element->value, data, list->size_of_element); @@ -100,20 +100,20 @@ list_insert (list_t *list, pos_e pos, const void *data) element->next = NULL; element->prev = list->tail; if (list->tail) - list->tail->next = element; + list->tail->next = element; list->tail = element; if (!list->head) - list->head = element; + list->head = element; } - else /* pos == HEAD */ + else /* pos == HEAD */ { element->prev = NULL; element->next = list->head; if (list->head) - list->head->prev = element; + list->head->prev = element; list->head = element; if (!list->tail) - list->tail = element; + list->tail = element; } } @@ -123,57 +123,57 @@ list_remove (list_t *list, pos_e pos, void *data) * Remove 'list' element from head or tail of 'list'. * * Return value: - * TRUE on success, - * FALSE if list is empty or - * if list value data is NULL + * TRUE on success, + * FALSE if list is empty or + * if list value data is NULL * * Side effects: - * lists current head or tail is removed - * value of the removed list element (if not NULL) is copied to + * lists current head or tail is removed + * value of the removed list element (if not NULL) is copied to * 'data' (if 'data' is not NULL) */ { node_t *element; - void *valueptr; + void *valueptr; assert (list); - + if (pos == TAIL) { element = list->tail; if (element) { - list->tail = element->prev; - valueptr = element->value; - Free (element); + list->tail = element->prev; + valueptr = element->value; + Free (element); } else - valueptr = NULL; - if (!list->tail) /* 'element' was last node */ - list->head = NULL; + valueptr = NULL; + if (!list->tail) /* 'element' was last node */ + list->head = NULL; } - else /* pos == HEAD */ + else /* pos == HEAD */ { element = list->head; if (element) { - list->head = element->next; - valueptr = element->value; - Free (element); + list->head = element->next; + valueptr = element->value; + Free (element); } else - valueptr = NULL; - if (!list->head) /* 'element' was last node */ - list->tail = NULL; + valueptr = NULL; + if (!list->head) /* 'element' was last node */ + list->tail = NULL; } - if (valueptr) /* copy value of node */ + if (valueptr) /* copy value of node */ { - if (data) - memcpy (data, valueptr, list->size_of_element); + if (data) + memcpy (data, valueptr, list->size_of_element); Free (valueptr); } - + return valueptr ? TRUE : FALSE; } @@ -184,27 +184,27 @@ list_element_n (const list_t *list, pos_e pos, unsigned n, void *data) * (First element is list head if 'pos' == HEAD * or list tail if 'pos' == TAIL. * Accordingly, traverse the list in ascending or descending order). - * + * * Return value: - * TRUE on success, FALSE if there is no element 'n' + * TRUE on success, FALSE if there is no element 'n' * * Side effects: - * value of list element 'n' is copied to 'data' + * value of list element 'n' is copied to 'data' */ { node_t *element; assert (list && data); - + if (pos == HEAD) for (element = list->head; element != NULL && n; - element = element->next, n--) - ; + element = element->next, n--) + ; else for (element = list->tail; element != NULL && n; - element = element->prev, n--) - ; - + element = element->prev, n--) + ; + if (element) { memcpy (data, element->value, list->size_of_element); @@ -220,14 +220,14 @@ list_sizeof (const list_t *list) * Count number of 'list' elements. * * Return value: - * number of 'list' elements. + * number of 'list' elements. */ { node_t *element; unsigned n = 0; assert (list); - + for (element = list->head; element != NULL; element = element->next) n++; @@ -247,7 +247,7 @@ list_foreach (const list_t *list, void (*function)(void *, void *), void *data) node_t *element; assert (list && function && data); - + for (element = list->head; element; element = element->next) function (element->value, data); } diff --git a/converter/other/fiasco/lib/list.h b/converter/other/fiasco/lib/list.h index 68577dfd..3ba860c0 100644 --- a/converter/other/fiasco/lib/list.h +++ b/converter/other/fiasco/lib/list.h @@ -1,8 +1,8 @@ /* * list.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -22,16 +22,16 @@ typedef struct node { - struct node *prev; /* pointer to prev list element */ - struct node *next; /* pointer to next list element */ - void *value; /* pointer to value of node */ + struct node *prev; /* pointer to prev list element */ + struct node *next; /* pointer to next list element */ + void *value; /* pointer to value of node */ } node_t; typedef struct list { node_t *head; node_t *tail; - size_t size_of_element; /* number of bytes to store value */ + size_t size_of_element; /* number of bytes to store value */ } list_t; typedef enum {TAIL, HEAD} pos_e; @@ -41,26 +41,26 @@ typedef enum {TAIL, HEAD} pos_e; */ typedef list_t lqueue_t ; -#define alloc_queue alloc_list -#define free_queue free_list -#define queue_append(q, d) (list_insert ((q), TAIL, (d))) -#define queue_remove(q, d) (list_remove ((q), HEAD, (d))) +#define alloc_queue alloc_list +#define free_queue free_list +#define queue_append(q, d) (list_insert ((q), TAIL, (d))) +#define queue_remove(q, d) (list_remove ((q), HEAD, (d))) typedef list_t lstack_t ; -#define alloc_stack alloc_list -#define free_stack free_list -#define stack_push(q, d) (list_insert ((q), TAIL, (d))) -#define stack_pop(q, d) (list_remove ((q), TAIL, (d))) +#define alloc_stack alloc_list +#define free_stack free_list +#define stack_push(q, d) (list_insert ((q), TAIL, (d))) +#define stack_pop(q, d) (list_remove ((q), TAIL, (d))) list_t * alloc_list (size_t size_of_element); -void +void free_list (list_t *list); bool_t list_element_n (const list_t *list, pos_e pos, unsigned n, void *data); void list_foreach (const list_t *list, void (*function)(void *, void *), - void *data); + void *data); void list_insert (list_t *list, pos_e pos, const void *data); bool_t diff --git a/converter/other/fiasco/lib/macros.h b/converter/other/fiasco/lib/macros.h index 2f404a74..aafea45b 100644 --- a/converter/other/fiasco/lib/macros.h +++ b/converter/other/fiasco/lib/macros.h @@ -1,8 +1,8 @@ /* * macros.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -20,34 +20,34 @@ #include <string.h> /******************************************************************************* - System configuration section - + System configuration section + *******************************************************************************/ #ifndef SEEK_CUR -# define SEEK_CUR 1 +# define SEEK_CUR 1 #endif /* not SEEK_CUR */ /***************************************************************************** - Various macros - + Various macros + *****************************************************************************/ -#define square(x) ((x) * (x)) -#define first_band(color) ((unsigned) ((color) ? Y : GRAY)) +#define square(x) ((x) * (x)) +#define first_band(color) ((unsigned) ((color) ? Y : GRAY)) #define last_band(color) ((unsigned) ((color) ? Cr : GRAY)) -#define width_of_level(l) ((unsigned) (1 << ((l) >> 1))) -#define height_of_level(l) ((unsigned) (1 << (((l) + 1) >> 1))) -#define size_of_level(l) ((unsigned) (1 << (l))) -#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) -#define _(x) (x) +#define width_of_level(l) ((unsigned) (1 << ((l) >> 1))) +#define height_of_level(l) ((unsigned) (1 << (((l) + 1) >> 1))) +#define size_of_level(l) ((unsigned) (1 << (l))) +#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) +#define _(x) (x) -#define MAXSTRLEN 1024 -#define MAXSTRLEN_SCANF "%1024s" +#define MAXSTRLEN 1024 +#define MAXSTRLEN_SCANF "%1024s" typedef enum color {GRAY = 0, Y = 0, Cb = 1, Cr = 2} color_e; diff --git a/converter/other/fiasco/lib/misc.c b/converter/other/fiasco/lib/misc.c index c5629c5c..d02511de 100644 --- a/converter/other/fiasco/lib/misc.c +++ b/converter/other/fiasco/lib/misc.c @@ -1,11 +1,11 @@ /* - * misc.c: Some useful functions, that don't fit in one of - * the other files and that are needed by at least - * two modules. + * misc.c: Some useful functions, that don't fit in one of + * the other files and that are needed by at least + * two modules. + * + * Written by: Stefan Frank + * Ullrich Hafner * - * Written by: Stefan Frank - * Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -23,14 +23,14 @@ #include <ctype.h> #ifdef TIME_WITH_SYS_TIME -# include <sys/time.h> -# include <time.h> +# include <sys/time.h> +# include <time.h> #else /* not TIME_WITH_SYS_TIME */ -# if HAVE_SYS_TIME_H -# include <sys/time.h> -# else /* not HAVE_SYS_TIME_H */ -# include <time.h> -# endif /* not HAVE_SYS_TIME_H */ +# if HAVE_SYS_TIME_H +# include <sys/time.h> +# else /* not HAVE_SYS_TIME_H */ +# include <time.h> +# endif /* not HAVE_SYS_TIME_H */ #endif /* not TIME_WITH_SYS_TIME */ #include <stdlib.h> @@ -47,8 +47,8 @@ /***************************************************************************** - prototypes - + prototypes + *****************************************************************************/ static void @@ -56,8 +56,8 @@ remove_comments (FILE *file); /***************************************************************************** - public code - + public code + *****************************************************************************/ void * @@ -66,14 +66,14 @@ Calloc (size_t n, size_t size) * Allocate memory like calloc (). * * Return value: Pointer to the new block of memory on success, - * otherwise the program is terminated. + * otherwise the program is terminated. */ { - void *ptr; /* pointer to the new memory block */ + void *ptr; /* pointer to the new memory block */ if (n <= 0 || size <= 0) error ("Can't allocate memory for %d items of size %d", - (int) n, (int) size); + (int) n, (int) size); ptr = calloc (n, size); if (!ptr) @@ -100,20 +100,20 @@ unsigned prg_timer (clock_t *last_timer, enum action_e action) /* * If 'action' == START then store current value of system timer. - * If 'action' == STOP then compute number of elapsed micro seconds since - * the last time 'prg_timer' was called - * with 'action' == START. + * If 'action' == STOP then compute number of elapsed micro seconds since + * the last time 'prg_timer' was called + * with 'action' == START. * * Return value: - * Number of elapsed micro seconds if 'action' == STOP - * 0 if 'action' == START + * Number of elapsed micro seconds if 'action' == STOP + * 0 if 'action' == START * * Side effects: - * last_timer is set to current timer if action == START + * last_timer is set to current timer if action == START */ { assert (last_timer); - + if (action == START) { *last_timer = clock (); @@ -123,19 +123,19 @@ prg_timer (clock_t *last_timer, enum action_e action) return (clock () - *last_timer) / (CLOCKS_PER_SEC / 1000.0); } -real_t +real_t read_real (FILE *infile) -/* +/* * Read one real value from the given input stream 'infile'. - * + * * Return value: - * real value on success + * real value on success */ { float input; assert (infile); - + remove_comments (infile); if (fscanf(infile, "%f", &input) != 1) error("Can't read float value!"); @@ -143,26 +143,26 @@ read_real (FILE *infile) return (real_t) input; } -int +int read_int (FILE *infile) -/* +/* * Read one integer value from the given input stream 'infile'. * * Return value: - * integer value on success + * integer value on success */ { - int input; /* integer */ + int input; /* integer */ assert (infile); - + remove_comments (infile); if (fscanf(infile, "%d", &input) != 1) error("Can't read integer value!"); return input; } - + static void remove_comments (FILE *file) /* @@ -171,27 +171,27 @@ remove_comments (FILE *file) * No return value. */ { - int c; /* current character */ - + int c; /* current character */ + assert (file); - + do { while (isspace(c = getc (file))) - ; + ; if (c == EOF) - error ("EOF reached, input seems to be truncated!"); + error ("EOF reached, input seems to be truncated!"); if (c == '#') { - int dummy; - - while (((dummy = getc (file)) != '\n') && dummy != EOF) - ; - if (dummy == EOF) - error ("EOF reached, input seems to be truncated!"); + int dummy; + + while (((dummy = getc (file)) != '\n') && dummy != EOF) + ; + if (dummy == EOF) + error ("EOF reached, input seems to be truncated!"); } - else - ungetc (c, file); + else + ungetc (c, file); } while (c == '#'); } @@ -203,10 +203,10 @@ write_rice_code (unsigned value, unsigned rice_k, bitfile_t *output) * No return value. */ { - unsigned unary; /* unary part of Rice Code */ + unsigned unary; /* unary part of Rice Code */ assert (output); - + for (unary = value >> rice_k; unary; unary--) put_bit (output, 1); put_bit (output, 0); @@ -219,13 +219,13 @@ read_rice_code (unsigned rice_k, bitfile_t *input) * Read a Rice encoded integer (base 'rice_k') from the stream 'input'. * * Return value: - * decoded integer + * decoded integer */ { - unsigned unary; /* unary part of Rice code */ - + unsigned unary; /* unary part of Rice code */ + assert (input); - + for (unary = 0; get_bit (input); unary++) /* unary part */ ; @@ -243,15 +243,15 @@ write_bin_code (unsigned value, unsigned maxval, bitfile_t *output) { unsigned k; unsigned r; - + assert (output && maxval && value <= maxval); k = log2 (maxval + 1); r = (maxval + 1) % (1 << k); - if (value < maxval + 1 - 2 * r) /* 0, ... , maxval - 2r */ + if (value < maxval + 1 - 2 * r) /* 0, ... , maxval - 2r */ put_bits (output, value, k); - else /* maxval - 2r + 1, ..., maxval */ + else /* maxval - 2r + 1, ..., maxval */ put_bits (output, value + maxval + 1 - 2 * r, k + 1); } @@ -261,13 +261,13 @@ read_bin_code (unsigned maxval, bitfile_t *input) * Read a bincode encoded integer from the stream 'input'. * * Return value: - * decoded integer + * decoded integer */ { unsigned k; unsigned r; unsigned value; - + assert (input); k = log2 (maxval + 1); @@ -280,7 +280,7 @@ read_bin_code (unsigned maxval, bitfile_t *input) { value <<= 1; if (get_bit (input)) - value++; + value++; return value - maxval - 1 + 2 * r; } } @@ -292,12 +292,12 @@ bits_rice_code (unsigned value, unsigned rice_k) * with given Rice code 'rice_k'. * * Return value: - * number of bits + * number of bits */ { unsigned unary; unsigned bits = 0; - + for (unary = value >> rice_k; unary; unary--) bits++; bits += rice_k + 1; @@ -312,7 +312,7 @@ bits_bin_code (unsigned value, unsigned maxval) * with adjusted binary code of given maximum value 'maxval'. * * Return value: - * number of bits + * number of bits */ { unsigned k; @@ -332,30 +332,30 @@ init_clipping (void) * Initialize the clipping tables * * Return value: - * pointer to clipping table + * pointer to clipping table */ { - static unsigned *gray_clip = NULL; /* clipping array */ + static unsigned *gray_clip = NULL; /* clipping array */ - if (gray_clip == NULL) /* initialize clipping table */ + if (gray_clip == NULL) /* initialize clipping table */ { - int i; /* counter */ + int i; /* counter */ gray_clip = calloc (256 * 3, sizeof (unsigned)); if (!gray_clip) { - set_error (_("Out of memory.")); - return NULL; + set_error (_("Out of memory.")); + return NULL; } gray_clip += 256; for (i = -256; i < 512; i++) - if (i < 0) - gray_clip [i] = 0; - else if (i > 255) - gray_clip [i] = 255; - else - gray_clip [i] = i; + if (i < 0) + gray_clip [i] = 0; + else if (i > 255) + gray_clip [i] = 255; + else + gray_clip [i] = i; } return gray_clip; @@ -369,29 +369,29 @@ memmove (void *v_dst, const void *v_src, size_t n) * The memory areas may overlap. * * Return value: - * pointer 'dest' + * pointer 'dest' */ { - byte_t *to, *dst = (byte_t *) v_dst; - const byte_t *from, *src = (byte_t *) v_src; - + byte_t *to, *dst = (byte_t *) v_dst; + const byte_t *from, *src = (byte_t *) v_src; + assert (v_dst && v_src); - + if (dst <= src) { from = src; to = dst; for (; n; n--) - *to++ = *from++; + *to++ = *from++; } else - { + { from = src + (n - 1); to = dst + (n - 1); for (; n; n--) - *to-- = *from--; + *to-- = *from--; } - + return v_dst; } #endif /* not HAVE_MEMMOVE */ @@ -405,7 +405,7 @@ double Log2 (double x) /* * Return value: - * base-2 logarithm of 'x' + * base-2 logarithm of 'x' */ { return log (x) / 0.69314718; @@ -413,32 +413,32 @@ Log2 (double x) real_t variance (const word_t *pixels, unsigned x0, unsigned y0, - unsigned width, unsigned height, unsigned cols) + unsigned width, unsigned height, unsigned cols) /* - * Compute variance of subimage ('x0', y0', 'width', 'height') of + * Compute variance of subimage ('x0', y0', 'width', 'height') of * the image data given by 'pixels' ('cols' is the number of pixels * in one row of the image). * * Return value: - * variance + * variance */ { - real_t average; /* average of pixel values */ - real_t variance; /* variance of pixel values */ - unsigned x, y; /* pixel counter */ - unsigned n; /* number of pixels */ + real_t average; /* average of pixel values */ + real_t variance; /* variance of pixel values */ + unsigned x, y; /* pixel counter */ + unsigned n; /* number of pixels */ assert (pixels); - + for (average = 0, n = 0, y = y0; y < y0 + height; y++) for (x = x0; x < MIN(x0 + width, cols); x++, n++) - average += pixels [y * cols + x] / 16; + 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++) - variance += square ((pixels [y * cols + x] / 16) - average); + variance += square ((pixels [y * cols + x] / 16) - average); return variance; } @@ -482,7 +482,7 @@ sort_asc_pair (const void *value1, const void *value2) { word_t v1 = ((pair_t *) value1)->key; word_t v2 = ((pair_t *) value2)->key; - + if (v1 < v2) return -1; else if (v1 > v2) diff --git a/converter/other/fiasco/lib/misc.h b/converter/other/fiasco/lib/misc.h index 6f643b7a..48f8bdaa 100644 --- a/converter/other/fiasco/lib/misc.h +++ b/converter/other/fiasco/lib/misc.h @@ -1,9 +1,9 @@ /* * misc.h * - * Written by: Stefan Frank - * Ullrich Hafner - * + * Written by: Stefan Frank + * Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -21,14 +21,14 @@ #include "config.h" #if TIME_WITH_SYS_TIME -# include <sys/time.h> -# include <time.h> +# include <sys/time.h> +# include <time.h> #else /* not TIME_WITH_SYS_TIME */ -# if HAVE_SYS_TIME_H -# include <sys/time.h> -# else /* not HAVE_SYS_TIME_H */ -# include <time.h> -# endif /* not HAVE_SYS_TIME_H */ +# if HAVE_SYS_TIME_H +# include <sys/time.h> +# else /* not HAVE_SYS_TIME_H */ +# include <time.h> +# endif /* not HAVE_SYS_TIME_H */ #endif /* not TIME_WITH_SYS_TIME */ #include <stdio.h> @@ -43,9 +43,9 @@ void Free (void *memory); unsigned prg_timer (clock_t *ptimer, enum action_e action); -int +int read_int(FILE *infile); -real_t +real_t read_real(FILE *infile); unsigned read_rice_code (unsigned rice_k, bitfile_t *input); @@ -63,7 +63,7 @@ unsigned * init_clipping (void); real_t variance (const word_t *pixels, unsigned x0, unsigned y0, - unsigned width, unsigned height, unsigned cols); + unsigned width, unsigned height, unsigned cols); #ifndef HAVE_MEMMOVE void * diff --git a/converter/other/fiasco/lib/mvcode.c b/converter/other/fiasco/lib/mvcode.c index d9ce91e2..0e6b6626 100644 --- a/converter/other/fiasco/lib/mvcode.c +++ b/converter/other/fiasco/lib/mvcode.c @@ -8,7 +8,7 @@ unsigned mv_code_table [33][2] = {0x19, 11}, {0x1b, 11}, {0x1d, 11}, {0x1f, 11}, {0x21, 11}, {0x23, 11}, {0x13, 10}, {0x15, 10}, {0x17, 10}, {0x7, 8}, {0x9, 8}, {0xb, 8}, {0x7, 7}, {0x3, 5}, {0x3, 4}, {0x3, 3}, {0x1, 1}, {0x2, 3}, {0x2, 4}, {0x2, 5}, - {0x6, 7}, {0xa, 8}, {0x8, 8}, {0x6, 8}, {0x16, 10}, {0x14, 10}, {0x12, 10}, + {0x6, 7}, {0xa, 8}, {0x8, 8}, {0x6, 8}, {0x16, 10}, {0x14, 10}, {0x12, 10}, {0x22, 11}, {0x20, 11}, {0x1e, 11}, {0x1c, 11}, {0x1a, 11}, {0x18, 11} }; diff --git a/converter/other/fiasco/lib/rpf.c b/converter/other/fiasco/lib/rpf.c index e6ff6e09..61e2f953 100644 --- a/converter/other/fiasco/lib/rpf.c +++ b/converter/other/fiasco/lib/rpf.c @@ -4,7 +4,7 @@ * Written by: Stefan Frank * Richard Krampfl * 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> */ @@ -32,7 +32,7 @@ int const RPF_ZERO = -1; /***************************************************************************** private code - + *****************************************************************************/ @@ -62,25 +62,25 @@ rtob (real_t const f, * Convert real number 'f' into fixed point format. * The real number in [-'range'; +'range'] is scaled to [-1 ; +1]. * Sign and the first 'precision' - 1 bits of the mantissa are - * packed into one integer. + * packed into one integer. * * Return value: * real value in reduced precision format */ -{ +{ /* * Extract mantissa (23 Bits), exponent (8 Bits) and sign (1 Bit) */ double const normalized = f / rpfP->range; - /* 'f' scaled to [-1,+1] */ + /* 'f' scaled to [-1,+1] */ FracExp const fracExp = fracExpFromDouble(normalized); unsigned int const signedMantissa = (unsigned int) (fracExp.fraction * (1<<23)); unsigned int mantissa; unsigned int sign; /* 0 for positive; 1 for negative */ - + if (signedMantissa < 0) { mantissa = -signedMantissa; sign = 1; @@ -92,16 +92,16 @@ rtob (real_t const f, /* * Generate reduced precision mantissa. */ - if (fracExp.exponent > 0) + if (fracExp.exponent > 0) mantissa <<= fracExp.exponent; else - mantissa >>= -fracExp.exponent; - + mantissa >>= -fracExp.exponent; + mantissa >>= (23 - rpfP->mantissa_bits - 1); mantissa += 1; /* Round last bit. */ mantissa >>= 1; - + if (mantissa == 0) /* close to zero */ return RPF_ZERO; else if (mantissa >= (1U << rpfP->mantissa_bits)) /* overflow */ @@ -126,7 +126,7 @@ btor (int const binary, unsigned int mantissa; float sign; float f; - + if (binary == RPF_ZERO) return 0; @@ -137,16 +137,16 @@ btor (int const binary, * Restore IEEE float format: * mantissa (23 Bits), exponent (8 Bits) and sign (1 Bit) */ - + sign = (binary & 0x1) == 0 ? 1.0 : -1.0; - mantissa = (binary & ((0x1 << (rpfP->mantissa_bits + 1)) - 1)) >> 1; + mantissa = (binary & ((0x1 << (rpfP->mantissa_bits + 1)) - 1)) >> 1; mantissa <<= (23 - rpfP->mantissa_bits); - if (mantissa == 0) + if (mantissa == 0) f = sign; else f = sign * (float) mantissa / 8388608; - + return f * rpfP->range; /* expand [ -1 ; +1 ] to [ -range ; +range ] */ } @@ -163,7 +163,7 @@ alloc_rpf (unsigned const mantissa, * Number of mantissa bits is given by `mantissa'. * The range of the real values is in the interval [-`range', +`range']. * In case of invalid parameters, a structure with default values is - * returned. + * returned. * * Return value * pointer to the new rpf structure @@ -172,7 +172,7 @@ alloc_rpf (unsigned const mantissa, rpf_t * rpfP; MALLOCVAR(rpfP); - + if (mantissa < 2) { warning (_("Size of RPF mantissa has to be in the interval [2,8]. " "Using minimum value 2.\n")); diff --git a/converter/other/fiasco/lib/rpf.h b/converter/other/fiasco/lib/rpf.h index e543f855..19e330fb 100644 --- a/converter/other/fiasco/lib/rpf.h +++ b/converter/other/fiasco/lib/rpf.h @@ -1,10 +1,10 @@ /* * rpf.h * - * Written by: Stefan Frank - * Richard Krampfl - * Ullrich Hafner - * + * Written by: Stefan Frank + * Richard Krampfl + * Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -24,14 +24,14 @@ typedef struct rpf { - unsigned mantissa_bits; /* number of bits used for mantissa */ - real_t range; /* scale value to [-range, +range] */ + unsigned mantissa_bits; /* number of bits used for mantissa */ + real_t range; /* scale value to [-range, +range] */ fiasco_rpf_range_e range_e; } rpf_t; int rtob (real_t real, const rpf_t *rpf); -real_t +real_t btor (int b, const rpf_t *rpf); rpf_t * alloc_rpf (unsigned mantissa, fiasco_rpf_range_e range); diff --git a/converter/other/fiasco/lib/types.h b/converter/other/fiasco/lib/types.h index 02e40a90..ce216ce5 100644 --- a/converter/other/fiasco/lib/types.h +++ b/converter/other/fiasco/lib/types.h @@ -2,7 +2,7 @@ * types.h * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ diff --git a/converter/other/fiasco/output/matrices.c b/converter/other/fiasco/output/matrices.c index 7dc0e6d9..32289dec 100644 --- a/converter/other/fiasco/output/matrices.c +++ b/converter/other/fiasco/output/matrices.c @@ -1,8 +1,8 @@ /* - * matrices.c: Output of transitions matrices + * matrices.c: Output of transitions matrices + * + * Written by: Ullrich Hafner * - * Written by: Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -38,13 +38,13 @@ /***************************************************************************** - prototypes - + prototypes + *****************************************************************************/ static unsigned delta_encoding (bool_t use_normal_domains, bool_t use_delta_domains, - const wfa_t *wfa, unsigned last_domain, bitfile_t *output); + const wfa_t *wfa, unsigned last_domain, bitfile_t *output); static unsigned column_0_encoding (const wfa_t *wfa, unsigned last_row, bitfile_t *output); static unsigned @@ -52,75 +52,75 @@ chroma_encoding (const wfa_t *wfa, bitfile_t *output); /***************************************************************************** - public code - + public code + *****************************************************************************/ unsigned write_matrices (bool_t use_normal_domains, bool_t use_delta_domains, - const wfa_t *wfa, bitfile_t *output) + const wfa_t *wfa, bitfile_t *output) /* * Write transition matrices of 'wfa' to stream 'output'. * * Return value: - * number of transitions encoded + * number of transitions encoded */ { - unsigned root_state; /* root of luminance */ - unsigned total = 0; /* number of transitions */ - + unsigned root_state; /* root of luminance */ + unsigned total = 0; /* number of transitions */ + root_state = wfa->wfainfo->color - ? wfa->tree [wfa->tree [wfa->root_state][0]][0] - : wfa->root_state; - + ? wfa->tree [wfa->tree [wfa->root_state][0]][0] + : wfa->root_state; + total = column_0_encoding (wfa, root_state, output); total += delta_encoding (use_normal_domains, use_delta_domains, - wfa, root_state, output); - + wfa, root_state, output); + if (wfa->wfainfo->color) total += chroma_encoding (wfa, output); - + return total; } /***************************************************************************** - private code - + private code + *****************************************************************************/ static unsigned delta_encoding (bool_t use_normal_domains, bool_t use_delta_domains, - const wfa_t *wfa, unsigned last_domain, bitfile_t *output) + const wfa_t *wfa, unsigned last_domain, bitfile_t *output) /* * Write transition matrices with delta coding to stream 'input'. * 'last_domain' is the maximum state number used as domain image. * * Return value: - * number of non-zero matrix elements (WFA edges) + * number of non-zero matrix elements (WFA edges) */ { - range_sort_t rs; /* ranges are sorted as in the coder */ - unsigned max_domain; /* dummy used for recursion */ - unsigned total = 0; - + range_sort_t rs; /* ranges are sorted as in the coder */ + unsigned max_domain; /* dummy used for recursion */ + unsigned total = 0; + /* * Generate a list of range blocks. * The order is the same as in the coder. */ rs.range_state = Calloc ((last_domain + 1) * MAXLABELS, - sizeof (u_word_t)); + sizeof (u_word_t)); rs.range_label = Calloc ((last_domain + 1) * MAXLABELS, - sizeof (byte_t)); + sizeof (byte_t)); rs.range_max_domain = Calloc ((last_domain + 1) * MAXLABELS, - sizeof (u_word_t)); + sizeof (u_word_t)); rs.range_subdivided = Calloc ((last_domain + 1) * MAXLABELS, - sizeof (bool_t)); - rs.range_no = 0; - max_domain = wfa->basis_states - 1; + sizeof (bool_t)); + rs.range_no = 0; + max_domain = wfa->basis_states - 1; sort_ranges (last_domain, &max_domain, &rs, wfa); - + /* * Compute and write distribution of #edges */ @@ -132,138 +132,138 @@ delta_encoding (bool_t use_normal_domains, bool_t use_delta_domains, unsigned edges = 0; unsigned M = 0; unsigned bits = bits_processed (output); - + for (n = 0; n < MAXEDGES + 1; n++) - count [n] = 0; - + count [n] = 0; + for (state = wfa->basis_states; state <= last_domain; state++) - for (label = 0; label < MAXLABELS; label++) - if (isrange (wfa->tree [state][label])) - { - for (edge = 0; isedge (wfa->into [state][label][edge]); edge++) - ; - count [edge]++; - edges++; - M = MAX(edge, M); - } + for (label = 0; label < MAXLABELS; label++) + if (isrange (wfa->tree [state][label])) + { + for (edge = 0; isedge (wfa->into [state][label][edge]); edge++) + ; + count [edge]++; + edges++; + M = MAX(edge, M); + } write_rice_code (M, 3, output); for (n = 0; n <= M; n++) /* NETPBM: The following causes a crash when last_domain < 4, because it requests writing of a negative number of bits. And we have seen - last_domain = 3. But we have no clue what last_domain means, or + last_domain = 3. But we have no clue what last_domain means, or even what a rice code is, so we don't know where the error lies. - -Bryan 2001.02.09 + -Bryan 2001.02.09 */ - write_rice_code (count [n], (int) log2 (last_domain) - 2, output); + write_rice_code (count [n], (int) log2 (last_domain) - 2, output); /* * Arithmetic coding of values */ { - unsigned range; - model_t *elements = alloc_model (M + 1, 0, 0, count); - arith_t *encoder = alloc_encoder (output); - - for (range = 0; range < rs.range_no; range++) - if (!rs.range_subdivided [range]) - { - state = rs.range_state [range]; - label = rs.range_label [range]; - for (edge = 0; isedge (wfa->into [state][label][edge]); edge++) - ; - - encode_symbol (edge, encoder, elements); - } - free_encoder (encoder); - free_model (elements); + unsigned range; + model_t *elements = alloc_model (M + 1, 0, 0, count); + arith_t *encoder = alloc_encoder (output); + + for (range = 0; range < rs.range_no; range++) + if (!rs.range_subdivided [range]) + { + state = rs.range_state [range]; + label = rs.range_label [range]; + for (edge = 0; isedge (wfa->into [state][label][edge]); edge++) + ; + + encode_symbol (edge, encoder, elements); + } + free_encoder (encoder); + free_model (elements); } debug_message ("delta-#edges: %5d bits. (%5d symbols => %5.2f bps)", - bits_processed (output) - bits, edges, - edges > 0 ? ((bits_processed (output) - bits) / - (double) edges) : 0); + bits_processed (output) - bits, edges, + edges > 0 ? ((bits_processed (output) - bits) / + (double) edges) : 0); } /* * Write matrix elements */ { - unsigned bits = bits_processed (output); + unsigned bits = bits_processed (output); u_word_t *mapping1 = Calloc (wfa->states, sizeof (u_word_t)); u_word_t *mapping2 = Calloc (wfa->states, sizeof (u_word_t)); - unsigned range; + unsigned range; put_bit (output, use_normal_domains); put_bit (output, use_delta_domains); - + /* * Generate array of states which are admitted domains. * When coding intra frames 'mapping1' == 'mapping2' otherwise - * 'mapping1' is a list of 'normal' domains which are admitted for + * 'mapping1' is a list of 'normal' domains which are admitted for * coding intra blocks * 'mapping2' is a list of 'delta' domains which are admitted for - * coding the motion compensated prediction error + * coding the motion compensated prediction error */ { - unsigned n1, n2, state; - - for (n1 = n2 = state = 0; state < wfa->states; state++) - { - mapping1 [state] = n1; - if (usedomain (state, wfa) - && (state < wfa->basis_states || use_delta_domains - || !wfa->delta_state [state])) - n1++; - - mapping2 [state] = n2; - if (usedomain (state, wfa) - && (state < wfa->basis_states || use_normal_domains - || wfa->delta_state [state])) - n2++; - } - debug_message ("# normal states = %d, # delta states = %d," - " # WFA states = %d", n1, n2, wfa->states); + unsigned n1, n2, state; + + for (n1 = n2 = state = 0; state < wfa->states; state++) + { + mapping1 [state] = n1; + if (usedomain (state, wfa) + && (state < wfa->basis_states || use_delta_domains + || !wfa->delta_state [state])) + n1++; + + mapping2 [state] = n2; + if (usedomain (state, wfa) + && (state < wfa->basis_states || use_normal_domains + || wfa->delta_state [state])) + n2++; + } + debug_message ("# normal states = %d, # delta states = %d," + " # WFA states = %d", n1, n2, wfa->states); } - + for (range = 0; range < rs.range_no; range++) - if (!rs.range_subdivided [range]) - { - unsigned state = rs.range_state [range]; - unsigned label = rs.range_label [range]; - unsigned last = 1; - u_word_t *mapping; - unsigned max_value; - unsigned edge; - word_t domain; - - if (wfa->delta_state [state] || - wfa->mv_tree [state][label].type != NONE) - mapping = mapping2; - else - mapping = mapping1; - - max_value = mapping [rs.range_max_domain [range]]; - - for (edge = 0; isedge (domain = wfa->into [state][label][edge]); - edge++) - if (domain > 0) - { - total++; - if (max_value - last) - { - write_bin_code (mapping [domain] - last, - max_value - last, output); - last = mapping [domain] + 1; - } - } - } + if (!rs.range_subdivided [range]) + { + unsigned state = rs.range_state [range]; + unsigned label = rs.range_label [range]; + unsigned last = 1; + u_word_t *mapping; + unsigned max_value; + unsigned edge; + word_t domain; + + if (wfa->delta_state [state] || + wfa->mv_tree [state][label].type != NONE) + mapping = mapping2; + else + mapping = mapping1; + + max_value = mapping [rs.range_max_domain [range]]; + + for (edge = 0; isedge (domain = wfa->into [state][label][edge]); + edge++) + if (domain > 0) + { + total++; + if (max_value - last) + { + write_bin_code (mapping [domain] - last, + max_value - last, output); + last = mapping [domain] + 1; + } + } + } debug_message ("delta-index: %5d bits. (%5d symbols => %5.2f bps)", - bits_processed (output) - bits, total, - total > 0 ? ((bits_processed (output) - bits) / - (double) total) : 0); + bits_processed (output) - bits, total, + total > 0 ? ((bits_processed (output) - bits) / + (double) total) : 0); Free (mapping1); Free (mapping2); } - + Free (rs.range_state); Free (rs.range_label); Free (rs.range_max_domain); @@ -280,17 +280,17 @@ column_0_encoding (const wfa_t *wfa, unsigned last_row, bitfile_t *output) * All rows from 'wfa->basis_states' up to 'last_row' are decoded. * * Return value: - * number of non-zero matrix elements (WFA edges) + * number of non-zero matrix elements (WFA edges) */ { - u_word_t high; /* Start of the current code range */ - u_word_t low; /* End of the current code range */ - unsigned *prob; /* probability array */ - unsigned row; /* current matrix row */ - unsigned label; /* current matrix label */ - unsigned underflow; /* Underflow bits */ - unsigned index; /* probability index */ - unsigned total = 0; /* Number of '1' elements */ + u_word_t high; /* Start of the current code range */ + u_word_t low; /* End of the current code range */ + unsigned *prob; /* probability array */ + unsigned row; /* current matrix row */ + unsigned label; /* current matrix label */ + unsigned underflow; /* Underflow bits */ + unsigned index; /* probability index */ + unsigned total = 0; /* Number of '1' elements */ unsigned bits = bits_processed (output); /* @@ -300,18 +300,18 @@ column_0_encoding (const wfa_t *wfa, unsigned last_row, bitfile_t *output) */ { unsigned n; - unsigned exp; /* current exponent */ - + unsigned exp; /* current exponent */ + prob = Calloc (1 << (MAX_PROB + 1), sizeof (unsigned)); - + for (index = 0, n = MIN_PROB; n <= MAX_PROB; n++) - for (exp = 0; exp < 1U << n; exp++, index++) - prob [index] = n; + for (exp = 0; exp < 1U << n; exp++, index++) + prob [index] = n; } - - high = HIGH; /* 1.0 */ - low = LOW; /* 0.0 */ - underflow = 0; /* no underflow bits */ + + high = HIGH; /* 1.0 */ + low = LOW; /* 0.0 */ + underflow = 0; /* no underflow bits */ index = 0; @@ -325,50 +325,50 @@ column_0_encoding (const wfa_t *wfa, unsigned last_row, bitfile_t *output) */ for (row = wfa->basis_states; row <= last_row; row++) for (label = 0; label < MAXLABELS; label++) - if (isrange (wfa->tree [row][label])) - { - if (wfa->into [row][label][0] != 0) - { - /* - * encode the MPS '0' - */ - high = high - ((high - low) >> prob [index]) - 1; - RESCALE_OUTPUT_INTERVAL; - - if (index < 1020) - index++; - } - else - { - /* - * encode the LPS '1' - */ - low = high - ((high - low) >> prob [index]); - - RESCALE_OUTPUT_INTERVAL; - - total++; - index >>= 1; - } - } + if (isrange (wfa->tree [row][label])) + { + if (wfa->into [row][label][0] != 0) + { + /* + * encode the MPS '0' + */ + high = high - ((high - low) >> prob [index]) - 1; + RESCALE_OUTPUT_INTERVAL; + + if (index < 1020) + index++; + } + else + { + /* + * encode the LPS '1' + */ + low = high - ((high - low) >> prob [index]); + + RESCALE_OUTPUT_INTERVAL; + + total++; + index >>= 1; + } + } /* * Flush the quasi-arithmetic encoder */ low = high; RESCALE_OUTPUT_INTERVAL; - + OUTPUT_BYTE_ALIGN (output); Free (prob); debug_message ("delta-state0: %5d bits. (%5d symbols => %5.2f bps)", - bits_processed (output) - bits, total, - total > 0 ? ((bits_processed (output) - bits) / - (double) total) : 0); + bits_processed (output) - bits, total, + total > 0 ? ((bits_processed (output) - bits) / + (double) total) : 0); return total; -} +} static unsigned chroma_encoding (const wfa_t *wfa, bitfile_t *output) @@ -377,24 +377,24 @@ chroma_encoding (const wfa_t *wfa, bitfile_t *output) * chroma channels Cb and Cr to stream 'output'. * * Return value: - * number of non-zero matrix elements (WFA edges) + * number of non-zero matrix elements (WFA edges) */ { - unsigned domain; /* current domain, counter */ - unsigned label; /* current label */ - unsigned total = 0; /* number of '1' elements */ - u_word_t high; /* Start of the current code range */ - u_word_t low; /* End of the current code range */ - unsigned underflow; /* underflow bits */ - unsigned *prob; /* probability array */ - unsigned index; /* probability index, counter */ - unsigned next_index; /* probability of last domain */ - unsigned row; /* current matrix row */ + unsigned domain; /* current domain, counter */ + unsigned label; /* current label */ + unsigned total = 0; /* number of '1' elements */ + u_word_t high; /* Start of the current code range */ + u_word_t low; /* End of the current code range */ + unsigned underflow; /* underflow bits */ + unsigned *prob; /* probability array */ + unsigned index; /* probability index, counter */ + unsigned next_index; /* probability of last domain */ + unsigned row; /* current matrix row */ word_t *y_domains; - unsigned count = 0; /* number of transitions for part 1 */ + unsigned count = 0; /* number of transitions for part 1 */ unsigned bits = bits_processed (output); - + /* * Compute the asymmetric probability array * prob[] = { 1/2, 1/2, 1/4, 1/4, 1/4, 1/4, @@ -402,24 +402,24 @@ chroma_encoding (const wfa_t *wfa, bitfile_t *output) */ { unsigned n; - unsigned exp; /* current exponent */ - + unsigned exp; /* current exponent */ + prob = Calloc (1 << (MAX_PROB + 1), sizeof (unsigned)); - + for (index = 0, n = MIN_PROB; n <= MAX_PROB; n++) - for (exp = 0; exp < 1U << n; exp++, index++) - prob [index] = n; + for (exp = 0; exp < 1U << n; exp++, index++) + prob [index] = n; } - - high = HIGH; /* 1.0 */ - low = LOW; /* 0.0 */ - underflow = 0; /* no underflow bits */ + + high = HIGH; /* 1.0 */ + low = LOW; /* 0.0 */ + underflow = 0; /* no underflow bits */ next_index = index = 0; y_domains = compute_hits (wfa->basis_states, - wfa->tree [wfa->tree [wfa->root_state][0]][0], - wfa->wfainfo->chroma_max_states, wfa); + wfa->tree [wfa->tree [wfa->root_state][0]][0], + wfa->wfainfo->chroma_max_states, wfa); /* * First of all, read all matrix columns given in the list 'y_domains' @@ -428,67 +428,67 @@ chroma_encoding (const wfa_t *wfa, bitfile_t *output) */ for (domain = 0; y_domains [domain] != -1; domain++) { - bool_t save_index = YES; /* YES: store current prob. index */ - + bool_t save_index = YES; /* YES: store current prob. index */ + row = wfa->tree [wfa->tree [wfa->root_state][0]][0] + 1; index = next_index; - + for (; row < wfa->states; row++) { - for (label = 0; label < MAXLABELS; label++) - if (isrange (wfa->tree [row][label])) - { - unsigned edge; - int into; - bool_t match; /* approx with current domain found */ - - for (match = NO, edge = 0; - isedge (into = wfa->into [row][label][edge]) - && (unsigned) into < row; - edge++) - if (into == y_domains [domain] - && into != wfa->y_state [row][label]) - match = YES; - if (!match) - { - /* - * encode the MPS '0' - */ - high = high - ((high - low) >> prob [index]) - 1; - - RESCALE_OUTPUT_INTERVAL; - - if (index < 1020) - index++; - } - else - { - /* - * encode the LPS '1' - */ - low = high - ((high - low) >> prob [index]); - - RESCALE_OUTPUT_INTERVAL; - - total++; - index >>= 1; - } - } - if (save_index) - { - next_index = index; - save_index = NO; - } + for (label = 0; label < MAXLABELS; label++) + if (isrange (wfa->tree [row][label])) + { + unsigned edge; + int into; + bool_t match; /* approx with current domain found */ + + for (match = NO, edge = 0; + isedge (into = wfa->into [row][label][edge]) + && (unsigned) into < row; + edge++) + if (into == y_domains [domain] + && into != wfa->y_state [row][label]) + match = YES; + if (!match) + { + /* + * encode the MPS '0' + */ + high = high - ((high - low) >> prob [index]) - 1; + + RESCALE_OUTPUT_INTERVAL; + + if (index < 1020) + index++; + } + else + { + /* + * encode the LPS '1' + */ + low = high - ((high - low) >> prob [index]); + + RESCALE_OUTPUT_INTERVAL; + + total++; + index >>= 1; + } + } + if (save_index) + { + next_index = index; + save_index = NO; + } } } debug_message ("CbCr_matrix: %5d bits. (%5d symbols => %5.2f bps)", - bits_processed (output) - bits, total, - total > 0 ? ((bits_processed (output) - bits) / - (double) total) : 0); + bits_processed (output) - bits, total, + total > 0 ? ((bits_processed (output) - bits) / + (double) total) : 0); count = total; bits = bits_processed (output); - + /* * Encode the additional column which indicates whether there * are transitions to a state with same spatial coordinates @@ -500,32 +500,32 @@ chroma_encoding (const wfa_t *wfa, bitfile_t *output) next_index = index = 0; for (row = wfa->tree [wfa->tree [wfa->root_state][0]][0] + 1; - row < wfa->states; row++) + row < wfa->states; row++) for (label = 0; label < MAXLABELS; label++) - if (!wfa->y_column [row][label]) - { - /* - * encode the MPS '0' - */ - high = high - ((high - low) >> prob [index]) - 1; - - RESCALE_OUTPUT_INTERVAL; - - if (index < 1020) - index++; - } - else - { - /* - * encode the LPS '1' - */ - low = high - ((high - low) >> prob [index]); - - RESCALE_OUTPUT_INTERVAL; - - index >>= 1; - total++; - } + if (!wfa->y_column [row][label]) + { + /* + * encode the MPS '0' + */ + high = high - ((high - low) >> prob [index]) - 1; + + RESCALE_OUTPUT_INTERVAL; + + if (index < 1020) + index++; + } + else + { + /* + * encode the LPS '1' + */ + low = high - ((high - low) >> prob [index]); + + RESCALE_OUTPUT_INTERVAL; + + index >>= 1; + total++; + } /* * Flush the quasi-arithmetic encoder @@ -536,12 +536,12 @@ chroma_encoding (const wfa_t *wfa, bitfile_t *output) OUTPUT_BYTE_ALIGN (output); debug_message ("Yreferences: %5d bits. (%5d symbols => %5.2f bps)", - bits_processed (output) - bits, total - count, - total - count > 0 ? ((bits_processed (output) - bits) / - (double) (total - count)) : 0); + bits_processed (output) - bits, total - count, + total - count > 0 ? ((bits_processed (output) - bits) / + (double) (total - count)) : 0); Free (prob); Free (y_domains); - + return total; } diff --git a/converter/other/fiasco/output/matrices.h b/converter/other/fiasco/output/matrices.h index 44671496..6e6ec8a5 100644 --- a/converter/other/fiasco/output/matrices.h +++ b/converter/other/fiasco/output/matrices.h @@ -1,8 +1,8 @@ /* * matrices.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -22,7 +22,7 @@ unsigned write_matrices (bool_t use_normal_domains, bool_t use_delta_domains, - const wfa_t *wfa, bitfile_t *output); + const wfa_t *wfa, bitfile_t *output); #endif /* _MATRICES_H */ diff --git a/converter/other/fiasco/output/mc.c b/converter/other/fiasco/output/mc.c index 170a2648..06ed0524 100644 --- a/converter/other/fiasco/output/mc.c +++ b/converter/other/fiasco/output/mc.c @@ -1,8 +1,8 @@ /* - * mc.c: Output of motion compensation + * mc.c: Output of motion compensation * - * Written by: Michael Unger - * Ullrich Hafner + * Written by: Michael Unger + * Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -29,7 +29,7 @@ /***************************************************************************** - local variables + local variables *****************************************************************************/ @@ -55,19 +55,19 @@ enum vlc_e {CODE = 0, BITS = 1}; /***************************************************************************** - prototypes + prototypes *****************************************************************************/ static void encode_mc_tree (unsigned max_state, frame_type_e frame_type, const wfa_t *wfa, - bitfile_t *output); + bitfile_t *output); static void encode_mc_coords (unsigned max_state, const wfa_t *wfa, bitfile_t *output); /***************************************************************************** - public code + public code *****************************************************************************/ @@ -75,8 +75,8 @@ void write_mc (frame_type_e frame_type, const wfa_t *wfa, bitfile_t *output) { unsigned max_state = wfa->wfainfo->color - ? wfa->tree[wfa->tree[wfa->root_state][0]][0] - : wfa->states; + ? wfa->tree[wfa->tree[wfa->root_state][0]][0] + : wfa->states; encode_mc_tree (max_state, frame_type, wfa, output); encode_mc_coords (max_state, wfa, output); @@ -84,13 +84,13 @@ write_mc (frame_type_e frame_type, const wfa_t *wfa, bitfile_t *output) /***************************************************************************** - private code + private code *****************************************************************************/ static void encode_mc_tree (unsigned max_state, frame_type_e frame_type, const wfa_t *wfa, - bitfile_t *output) + bitfile_t *output) /* * Write tree of motion compensation decisions to the 'output' stream. * Depending on 'frame_type' different decoding methods are used. @@ -99,20 +99,20 @@ encode_mc_tree (unsigned max_state, frame_type_e frame_type, const wfa_t *wfa, * No return value. */ { - unsigned label; /* current label */ - unsigned state; /* current state */ - unsigned total = 0; /* number of motion tree decisions */ - unsigned queue [MAXSTATES]; /* state numbers in BFO */ - unsigned current; /* current node to process */ - unsigned last; /* last node (update every new node) */ - mc_type_e type; /* type of motion compensation */ - unsigned (*mc_tree_codes)[2]; /* pointer to VLC table */ + unsigned label; /* current label */ + unsigned state; /* current state */ + unsigned total = 0; /* number of motion tree decisions */ + unsigned queue [MAXSTATES]; /* state numbers in BFO */ + unsigned current; /* current node to process */ + unsigned last; /* last node (update every new node) */ + mc_type_e type; /* type of motion compensation */ + unsigned (*mc_tree_codes)[2]; /* pointer to VLC table */ unsigned bits = bits_processed (output); /* number of bits used */ if (frame_type == P_FRAME) - mc_tree_codes = p_frame_codes; /* binary code */ + mc_tree_codes = p_frame_codes; /* binary code */ else - mc_tree_codes = b_frame_codes; /* variable length code */ + mc_tree_codes = b_frame_codes; /* variable length code */ /* * Traverse tree in breadth first order (starting at @@ -122,37 +122,37 @@ encode_mc_tree (unsigned max_state, frame_type_e frame_type, const wfa_t *wfa, for (last = 0, state = wfa->basis_states; state < max_state; state++) if (wfa->level_of_state [state] - 1 == (int) wfa->wfainfo->p_max_level) - queue [last++] = state; /* init level = 'mc_max_level' */ + queue [last++] = state; /* init level = 'mc_max_level' */ for (current = 0; current < last; current++) for (label = 0; label < MAXLABELS; label++) { - state = queue [current]; - type = wfa->mv_tree [state][label].type; - if (wfa->x [state][label] - + width_of_level (wfa->level_of_state [state] - 1) - <= wfa->wfainfo->width - && - wfa->y [state][label] - + height_of_level (wfa->level_of_state [state] - 1) - <= wfa->wfainfo->height) - { - put_bits (output, mc_tree_codes [type][CODE], - mc_tree_codes [type][BITS]); - total++; - } - if (type == NONE && !isrange (wfa->tree [state][label]) && - wfa->level_of_state [state] - 1 >= - (int) wfa->wfainfo->p_min_level) - queue [last++] = wfa->tree [state][label]; /* append child */ + state = queue [current]; + type = wfa->mv_tree [state][label].type; + if (wfa->x [state][label] + + width_of_level (wfa->level_of_state [state] - 1) + <= wfa->wfainfo->width + && + wfa->y [state][label] + + height_of_level (wfa->level_of_state [state] - 1) + <= wfa->wfainfo->height) + { + put_bits (output, mc_tree_codes [type][CODE], + mc_tree_codes [type][BITS]); + total++; + } + if (type == NONE && !isrange (wfa->tree [state][label]) && + wfa->level_of_state [state] - 1 >= + (int) wfa->wfainfo->p_min_level) + queue [last++] = wfa->tree [state][label]; /* append child */ } OUTPUT_BYTE_ALIGN (output); debug_message ("mc-tree: %5d bits. (%5d symbols => %5.2f bps)", - bits_processed (output) - bits, total, - total > 0 ? ((bits_processed (output) - bits) / - (double) total) : 0); + bits_processed (output) - bits, total, + total > 0 ? ((bits_processed (output) - bits) / + (double) total) : 0); } static void @@ -165,85 +165,85 @@ encode_mc_coords (unsigned max_state, const wfa_t *wfa, bitfile_t *output) * No return value. */ { - unsigned state; /* current state */ - unsigned label; /* current label */ - unsigned level_count [MAXLEVEL]; /* number of mv per level */ - unsigned level; /* counter */ - unsigned ftotal = 0; /* #forward motion tree decisions */ - unsigned btotal = 0; /* #backward decisions */ - unsigned itotal = 0; /* #interpolated decisions */ + unsigned state; /* current state */ + unsigned label; /* current label */ + unsigned level_count [MAXLEVEL]; /* number of mv per level */ + unsigned level; /* counter */ + unsigned ftotal = 0; /* #forward motion tree decisions */ + unsigned btotal = 0; /* #backward decisions */ + unsigned itotal = 0; /* #interpolated decisions */ unsigned bits = bits_processed (output); /* number of bits used */ unsigned sr = wfa->wfainfo->search_range; /* search range */ for (level = wfa->wfainfo->p_max_level; - level >= wfa->wfainfo->p_min_level; level--) + level >= wfa->wfainfo->p_min_level; level--) level_count [level] = 0; for (state = wfa->basis_states; state < max_state; state++) for (label = 0; label < MAXLABELS; label++) { - mv_t *mv = &wfa->mv_tree[state][label]; /* motion vector info */ - - if (mv->type != NONE) - { - level_count [wfa->level_of_state [state] - 1]++; - switch (mv->type) - { - case FORWARD: - put_bits (output, - mv_code_table[(mv->fx + sr)][CODE], - mv_code_table[(mv->fx + sr)][BITS]); - put_bits (output, - mv_code_table[(mv->fy + sr)][CODE], - mv_code_table[(mv->fy + sr)][BITS]); - ftotal++; - break; - case BACKWARD: - put_bits (output, - mv_code_table[(mv->bx + sr)][CODE], - mv_code_table[(mv->bx + sr)][BITS]); - put_bits (output, - mv_code_table[(mv->by + sr)][CODE], - mv_code_table[(mv->by + sr)][BITS]); - btotal++; - break; - case INTERPOLATED: - put_bits (output, - mv_code_table[(mv->fx + sr)][CODE], - mv_code_table[(mv->fx + sr)][BITS]); - put_bits (output, - mv_code_table[(mv->fy + sr)][CODE], - mv_code_table[(mv->fy + sr)][BITS]); - put_bits (output, - mv_code_table[(mv->bx + sr)][CODE], - mv_code_table[(mv->bx + sr)][BITS]); - put_bits (output, - mv_code_table[(mv->by + sr)][CODE], - mv_code_table[(mv->by + sr)][BITS]); - itotal++; - break; - default: - break; - } - } + mv_t *mv = &wfa->mv_tree[state][label]; /* motion vector info */ + + if (mv->type != NONE) + { + level_count [wfa->level_of_state [state] - 1]++; + switch (mv->type) + { + case FORWARD: + put_bits (output, + mv_code_table[(mv->fx + sr)][CODE], + mv_code_table[(mv->fx + sr)][BITS]); + put_bits (output, + mv_code_table[(mv->fy + sr)][CODE], + mv_code_table[(mv->fy + sr)][BITS]); + ftotal++; + break; + case BACKWARD: + put_bits (output, + mv_code_table[(mv->bx + sr)][CODE], + mv_code_table[(mv->bx + sr)][BITS]); + put_bits (output, + mv_code_table[(mv->by + sr)][CODE], + mv_code_table[(mv->by + sr)][BITS]); + btotal++; + break; + case INTERPOLATED: + put_bits (output, + mv_code_table[(mv->fx + sr)][CODE], + mv_code_table[(mv->fx + sr)][BITS]); + put_bits (output, + mv_code_table[(mv->fy + sr)][CODE], + mv_code_table[(mv->fy + sr)][BITS]); + put_bits (output, + mv_code_table[(mv->bx + sr)][CODE], + mv_code_table[(mv->bx + sr)][BITS]); + put_bits (output, + mv_code_table[(mv->by + sr)][CODE], + mv_code_table[(mv->by + sr)][BITS]); + itotal++; + break; + default: + break; + } + } } OUTPUT_BYTE_ALIGN (output); debug_message ("Motion compensation: %d forward, %d backward, " - "%d interpolated", ftotal, btotal, itotal); + "%d interpolated", ftotal, btotal, itotal); for (level = wfa->wfainfo->p_max_level; - level >= wfa->wfainfo->p_min_level; level--) + level >= wfa->wfainfo->p_min_level; level--) debug_message ("Level %d: %d motion vectors", level, level_count[level]); { unsigned total = ftotal * 2 + btotal * 2 + itotal * 4; debug_message ("mv-coord: %5d bits. (%5d symbols => %5.2f bps)", - bits_processed (output) - bits, total, - total > 0 ? ((bits_processed (output) - bits) / - (double) total) : 0); + bits_processed (output) - bits, total, + total > 0 ? ((bits_processed (output) - bits) / + (double) total) : 0); } return; diff --git a/converter/other/fiasco/output/mc.h b/converter/other/fiasco/output/mc.h index cacddfe7..9e15ae3d 100644 --- a/converter/other/fiasco/output/mc.h +++ b/converter/other/fiasco/output/mc.h @@ -1,9 +1,9 @@ /* * mc.h * - * Written by: Michael Unger - * Ullrich Hafner - * + * Written by: Michael Unger + * Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ diff --git a/converter/other/fiasco/output/nd.c b/converter/other/fiasco/output/nd.c index b1dd6746..67b8b106 100644 --- a/converter/other/fiasco/output/nd.c +++ b/converter/other/fiasco/output/nd.c @@ -1,7 +1,7 @@ /* - * nd.c: Output of prediction tree + * nd.c: Output of prediction tree * - * Written by: Ullrich Hafner + * Written by: Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -31,7 +31,7 @@ /***************************************************************************** - prototypes + prototypes *****************************************************************************/ @@ -42,7 +42,7 @@ encode_nd_coefficients (unsigned total, const wfa_t *wfa, bitfile_t *output); /***************************************************************************** - public code + public code *****************************************************************************/ @@ -63,7 +63,7 @@ write_nd (const wfa_t *wfa, bitfile_t *output) /***************************************************************************** - private code + private code *****************************************************************************/ @@ -75,13 +75,13 @@ encode_nd_tree (const wfa_t *wfa, bitfile_t *output) * No return value. */ { - lqueue_t *queue; /* queue of states */ - int state, next; /* state and its current child */ - unsigned used, not_used; /* counter ND used/not used */ - u_word_t low; /* Start of the current code range */ - u_word_t high; /* End of the current code range */ - u_word_t underflow; /* Number of underflow bits pending */ - u_word_t sum0, sum1; /* Probability model */ + lqueue_t *queue; /* queue of states */ + int state, next; /* state and its current child */ + unsigned used, not_used; /* counter ND used/not used */ + u_word_t low; /* Start of the current code range */ + u_word_t high; /* End of the current code range */ + u_word_t underflow; /* Number of underflow bits pending */ + u_word_t sum0, sum1; /* Probability model */ unsigned bits = bits_processed (output); used = not_used = 0; @@ -108,60 +108,60 @@ encode_nd_tree (const wfa_t *wfa, bitfile_t *output) if (wfa->level_of_state [next] > wfa->wfainfo->p_max_level + 1) { - /* - * Nondetermismn is not allowed at levels larger than - * 'wfa->wfainfo->p_max_level'. - */ - for (label = 0; label < MAXLABELS; label++) - if (ischild (state = wfa->tree [next][label])) - queue_append (queue, &state); /* continue with children */ + /* + * Nondetermismn is not allowed at levels larger than + * 'wfa->wfainfo->p_max_level'. + */ + for (label = 0; label < MAXLABELS; label++) + if (ischild (state = wfa->tree [next][label])) + queue_append (queue, &state); /* continue with children */ } else if (wfa->level_of_state [next] > wfa->wfainfo->p_min_level) { - for (label = 0; label < MAXLABELS; label++) - if (ischild (state = wfa->tree [next][label])) - { - unsigned range; /* Current interval range */ - - if (isedge (wfa->into [next][label][0])) /* prediction used */ - { - used++; - - /* - * Encode a '1' symbol - */ - range = (high - low) + 1; - low = low + (u_word_t) ((range * sum0) / sum1); - RESCALE_OUTPUT_INTERVAL; - } - else /* no predict., continue with children */ - { - not_used++; - if (wfa->level_of_state [state] > wfa->wfainfo->p_min_level) - queue_append (queue, &state); - - /* - * Encode a '0' symbol - */ - range = (high - low) + 1; - high = low + (u_word_t) ((range * sum0) / sum1 - 1); - RESCALE_OUTPUT_INTERVAL; - sum0++; - } - /* - * Update the frequency counts - */ - sum1++; - if (sum1 > 50) /* Scale the symbol frequencies */ - { - sum0 >>= 1; - sum1 >>= 1; - if (!sum0) - sum0 = 1; - if (sum0 >= sum1) - sum1 = sum0 + 1; - } - } + for (label = 0; label < MAXLABELS; label++) + if (ischild (state = wfa->tree [next][label])) + { + unsigned range; /* Current interval range */ + + if (isedge (wfa->into [next][label][0])) /* prediction used */ + { + used++; + + /* + * Encode a '1' symbol + */ + range = (high - low) + 1; + low = low + (u_word_t) ((range * sum0) / sum1); + RESCALE_OUTPUT_INTERVAL; + } + else /* no predict., continue with children */ + { + not_used++; + if (wfa->level_of_state [state] > wfa->wfainfo->p_min_level) + queue_append (queue, &state); + + /* + * Encode a '0' symbol + */ + range = (high - low) + 1; + high = low + (u_word_t) ((range * sum0) / sum1 - 1); + RESCALE_OUTPUT_INTERVAL; + sum0++; + } + /* + * Update the frequency counts + */ + sum1++; + if (sum1 > 50) /* Scale the symbol frequencies */ + { + sum0 >>= 1; + sum1 >>= 1; + if (!sum0) + sum0 = 1; + if (sum0 >= sum1) + sum1 = sum0 + 1; + } + } } } @@ -175,14 +175,14 @@ encode_nd_tree (const wfa_t *wfa, bitfile_t *output) OUTPUT_BYTE_ALIGN (output); debug_message ("%d nd fields: %d used nd, %d used not nd", used + not_used, - used, not_used); + used, not_used); { unsigned total = used + not_used; debug_message ("nd-tree: %5d bits. (%5d symbols => %5.2f bps)", - bits_processed (output) - bits, total, - total > 0 ? ((bits_processed (output) - bits) / - (double) total) : 0); + bits_processed (output) - bits, total, + total > 0 ? ((bits_processed (output) - bits) / + (double) total) : 0); } return used; @@ -201,42 +201,42 @@ encode_nd_coefficients (unsigned total, const wfa_t *wfa, bitfile_t *output) unsigned bits = bits_processed (output); { - unsigned *coefficients; /* array of factors to encode */ - unsigned *ptr; /* pointer to current factor */ - unsigned state, label, edge; - word_t domain; + unsigned *coefficients; /* array of factors to encode */ + unsigned *ptr; /* pointer to current factor */ + unsigned state, label, edge; + word_t domain; ptr = coefficients = Calloc (total, sizeof (unsigned)); for (state = wfa->basis_states; state < wfa->states; state++) - for (label = 0; label < MAXLABELS; label++) - if (ischild (wfa->tree [state][label]) - && isedge (wfa->into [state][label][0])) - for (edge = 0; isedge (domain = wfa->into [state][label][edge]); - edge++) - { - if (ptr - coefficients >= (int) total) - error ("Can't write more than %d coefficients.", total); - - *ptr++ = rtob (wfa->weight [state][label][edge], - wfa->wfainfo->dc_rpf); - } + for (label = 0; label < MAXLABELS; label++) + if (ischild (wfa->tree [state][label]) + && isedge (wfa->into [state][label][0])) + for (edge = 0; isedge (domain = wfa->into [state][label][edge]); + edge++) + { + if (ptr - coefficients >= (int) total) + error ("Can't write more than %d coefficients.", total); + + *ptr++ = rtob (wfa->weight [state][label][edge], + wfa->wfainfo->dc_rpf); + } /* * Encode array of coefficients with arithmetic coding */ { - const int scaling = 50; /* scaling factor of prob. model */ - unsigned c_symbols = 1 << (wfa->wfainfo->dc_rpf->mantissa_bits + 1); + const int scaling = 50; /* scaling factor of prob. model */ + unsigned c_symbols = 1 << (wfa->wfainfo->dc_rpf->mantissa_bits + 1); - encode_array (output, coefficients, NULL, &c_symbols, 1, - total, scaling); + encode_array (output, coefficients, NULL, &c_symbols, 1, + total, scaling); } debug_message ("nd-factors: %5d bits. (%5d symbols => %5.2f bps)", - bits_processed (output) - bits, total, - total ? ((bits_processed (output) - bits) - / (double) total) : 0); + bits_processed (output) - bits, total, + total ? ((bits_processed (output) - bits) + / (double) total) : 0); Free (coefficients); } } diff --git a/converter/other/fiasco/output/nd.h b/converter/other/fiasco/output/nd.h index 01a37838..7b8ea9fe 100644 --- a/converter/other/fiasco/output/nd.h +++ b/converter/other/fiasco/output/nd.h @@ -1,8 +1,8 @@ /* * nd.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ diff --git a/converter/other/fiasco/output/tree.c b/converter/other/fiasco/output/tree.c index 55080a51..02afec50 100644 --- a/converter/other/fiasco/output/tree.c +++ b/converter/other/fiasco/output/tree.c @@ -1,7 +1,7 @@ /* - * tree.c: Output of bintree partitioning + * tree.c: Output of bintree partitioning * - * Written by: Ullrich Hafner + * Written by: Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -29,17 +29,17 @@ /***************************************************************************** - prototypes + prototypes *****************************************************************************/ static void encode_tree (bitfile_t *output, const byte_t *data, unsigned n_data, - unsigned scaling, u_word_t sum0, u_word_t sum1); + unsigned scaling, u_word_t sum0, u_word_t sum1); /***************************************************************************** - public code + public code *****************************************************************************/ @@ -53,13 +53,13 @@ write_tree (const wfa_t *wfa, bitfile_t *output) * No return value. */ { - unsigned queue [MAXSTATES]; /* state numbers in BFO */ - unsigned current; /* current node to process */ - unsigned last; /* last node (update every new node) */ - unsigned label; /* current label */ - int into; /* next child */ - byte_t *tree_string; /* bitstring to encode */ - unsigned total = 0; /* number of ranges */ + unsigned queue [MAXSTATES]; /* state numbers in BFO */ + unsigned current; /* current node to process */ + unsigned last; /* last node (update every new node) */ + unsigned label; /* current label */ + int into; /* next child */ + byte_t *tree_string; /* bitstring to encode */ + unsigned total = 0; /* number of ranges */ unsigned bits = bits_processed (output); /* number of bits */ /* @@ -72,17 +72,17 @@ write_tree (const wfa_t *wfa, bitfile_t *output) queue [0] = wfa->root_state; for (last = 1, current = 0; current < last; current++) for (label = 0; label < MAXLABELS; label++) - if (!isrange (into = wfa->tree [queue[current]][label])) /* child ? */ - { - queue [last++] = into; - tree_string [total++] = 1; - } - else /* or range ? */ - tree_string [total++] = 0; + if (!isrange (into = wfa->tree [queue[current]][label])) /* child ? */ + { + queue [last++] = into; + tree_string [total++] = 1; + } + else /* or range ? */ + tree_string [total++] = 0; if (total != (wfa->states - wfa->basis_states) * MAXLABELS) error ("total [%d] != (states - basis_states) * 2 [%d]", total, - (wfa->states - wfa->basis_states) * MAXLABELS); + (wfa->states - wfa->basis_states) * MAXLABELS); { unsigned scale = total / 20 ; @@ -93,20 +93,20 @@ write_tree (const wfa_t *wfa, bitfile_t *output) Free (tree_string); debug_message ("tree: %5d bits. (%5d symbols => %5.2f bps)", - bits_processed (output) - bits, total, - total > 0 ? ((bits_processed (output) - bits) - / (double) total) : 0); + bits_processed (output) - bits, total, + total > 0 ? ((bits_processed (output) - bits) + / (double) total) : 0); } /***************************************************************************** - private code + private code *****************************************************************************/ static void encode_tree (bitfile_t *output, const byte_t *data, unsigned n_data, - unsigned scaling, u_word_t sum0, u_word_t sum1) + unsigned scaling, u_word_t sum0, u_word_t sum1) /* * Encode bintree data with adaptive binary arithmetic coding. * Write 'n_data' output symbols stored in 'data' to stream 'output'. @@ -116,10 +116,10 @@ encode_tree (bitfile_t *output, const byte_t *data, unsigned n_data, * No return value. */ { - u_word_t low; /* Start of the current code range */ - u_word_t high; /* End of the current code range */ - u_word_t underflow; /* Number of underflow bits pending */ - unsigned n; /* Data counter */ + u_word_t low; /* Start of the current code range */ + u_word_t high; /* End of the current code range */ + u_word_t underflow; /* Number of underflow bits pending */ + unsigned n; /* Data counter */ low = 0; high = 0xffff; @@ -127,29 +127,29 @@ encode_tree (bitfile_t *output, const byte_t *data, unsigned n_data, for (n = n_data; n; n--) { - unsigned range; /* Current interval range */ + unsigned range; /* Current interval range */ if (!*data++) { - /* - * encode a '0' - */ - range = (high - low) + 1; - high = low + (u_word_t) ((range * sum0) / sum1 - 1); + /* + * encode a '0' + */ + range = (high - low) + 1; + high = low + (u_word_t) ((range * sum0) / sum1 - 1); - RESCALE_OUTPUT_INTERVAL; + RESCALE_OUTPUT_INTERVAL; - sum0++; + sum0++; } else { - /* - * encode a '1' - */ - range = (high - low) + 1; - low = low + (u_word_t) ((range * sum0) / sum1); + /* + * encode a '1' + */ + range = (high - low) + 1; + low = low + (u_word_t) ((range * sum0) / sum1); - RESCALE_OUTPUT_INTERVAL; + RESCALE_OUTPUT_INTERVAL; } /* * Update the frequency counts @@ -157,12 +157,12 @@ encode_tree (bitfile_t *output, const byte_t *data, unsigned n_data, sum1++; if (sum1 > scaling) /* Scale the symbol frequencies */ { - sum0 >>= 1; - sum1 >>= 1; - if (!sum0) - sum0 = 1; - if (sum0 >= sum1) - sum1 = sum0 + 1; + sum0 >>= 1; + sum1 >>= 1; + if (!sum0) + sum0 = 1; + if (sum0 >= sum1) + sum1 = sum0 + 1; } } /* diff --git a/converter/other/fiasco/output/tree.h b/converter/other/fiasco/output/tree.h index 50fe2279..bcf50ec1 100644 --- a/converter/other/fiasco/output/tree.h +++ b/converter/other/fiasco/output/tree.h @@ -1,8 +1,8 @@ /* * tree.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ diff --git a/converter/other/fiasco/output/weights.c b/converter/other/fiasco/output/weights.c index 0203fef0..4eb068ac 100644 --- a/converter/other/fiasco/output/weights.c +++ b/converter/other/fiasco/output/weights.c @@ -1,8 +1,8 @@ /* - * weights.c: Output of weights + * weights.c: Output of weights + * + * Written by: Ullrich Hafner * - * Written by: Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -32,8 +32,8 @@ /***************************************************************************** - public code - + public code + *****************************************************************************/ void @@ -45,20 +45,20 @@ 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 */ @@ -68,14 +68,14 @@ write_weights (unsigned total, const wfa_t *wfa, bitfile_t *output) 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; - + 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])) @@ -95,24 +95,24 @@ write_weights (unsigned total, const wfa_t *wfa, bitfile_t *output) dc = YES; } } - if (min_level > max_level) /* no lc found */ + 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 + * 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 @@ -127,15 +127,15 @@ write_weights (unsigned total, const wfa_t *wfa, bitfile_t *output) for (label = 0; label < MAXLABELS; label++) if (isrange (wfa->tree [state][label])) { - int edge; /* current edge */ - int domain; /* current domain (context of model) */ - + 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 (domain) /* not DC component */ { if (delta_approx && wfa->delta_state [state]) /* delta */ { @@ -153,7 +153,7 @@ write_weights (unsigned total, const wfa_t *wfa, bitfile_t *output) + wfa->level_of_state [state] - 1 - min_level; } } - else /* DC component */ + else /* DC component */ { if (delta_approx && wfa->delta_state [state]) /* delta */ { @@ -172,9 +172,9 @@ write_weights (unsigned total, const wfa_t *wfa, bitfile_t *output) } { - unsigned i; - unsigned *c_symbols = Calloc (offset4, sizeof (int)); - const int scale = 500; /* scaling of probability model */ + 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) @@ -184,12 +184,12 @@ write_weights (unsigned total, const wfa_t *wfa, bitfile_t *output) 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); } - + 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, diff --git a/converter/other/fiasco/output/weights.h b/converter/other/fiasco/output/weights.h index f22bd9f8..505918ad 100644 --- a/converter/other/fiasco/output/weights.h +++ b/converter/other/fiasco/output/weights.h @@ -1,8 +1,8 @@ /* * weights.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ diff --git a/converter/other/fiasco/output/write.c b/converter/other/fiasco/output/write.c index d6faee26..8c825a12 100644 --- a/converter/other/fiasco/output/write.c +++ b/converter/other/fiasco/output/write.c @@ -2,7 +2,7 @@ * write.c: Output of WFA files * * Written by: Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -32,11 +32,11 @@ #include "mc.h" #include "nd.h" #include "write.h" - + /***************************************************************************** prototypes - + *****************************************************************************/ static void @@ -46,7 +46,7 @@ write_tiling (const tiling_t *tiling, bitfile_t *output); public code - + *****************************************************************************/ @@ -61,26 +61,26 @@ write_next_wfa (const wfa_t *wfa, const coding_t *c, bitfile_t *output) { unsigned edges = 0; /* number of transitions */ unsigned bits; - + debug_message ("--------------------------------------" "--------------------------------------"); if (c->mt->number == 0) /* first WFA */ write_header (wfa->wfainfo, output); - + bits = bits_processed (output); - + /* * Frame header information */ { const int rice_k = 8; /* parameter of Rice Code */ - write_rice_code (wfa->states, rice_k, output); - write_rice_code (c->mt->frame_type, rice_k, output); - write_rice_code (c->mt->number, rice_k, output); + write_rice_code (wfa->states, rice_k, output); + write_rice_code (c->mt->frame_type, rice_k, output); + write_rice_code (c->mt->number, rice_k, output); } - + OUTPUT_BYTE_ALIGN (output); debug_message ("frame-header: %5d bits.", bits_processed (output) - bits); @@ -99,7 +99,7 @@ write_next_wfa (const wfa_t *wfa, const coding_t *c, bitfile_t *output) if (c->options.prediction) /* write nondeterministic approx. */ { - put_bit (output, 1); + put_bit (output, 1); write_nd (wfa, output); } else @@ -107,7 +107,7 @@ write_next_wfa (const wfa_t *wfa, const coding_t *c, bitfile_t *output) if (c->mt->frame_type != I_FRAME) /* write motion compensation info */ write_mc (c->mt->frame_type, wfa, output); - + edges = write_matrices (c->options.normal_domains, c->options.delta_domains, wfa, output); @@ -140,7 +140,7 @@ write_header (const wfa_info_t *wi, bitfile_t *output) for (text = wi->basis_name; *text; text++) put_bits (output, *text, 8); put_bits (output, *text, 8); - + write_rice_code (FIASCO_BINFILE_RELEASE, rice_k, output); write_rice_code (HEADER_TITLE, rice_k, output); @@ -149,24 +149,24 @@ write_header (const wfa_info_t *wi, bitfile_t *output) text++) put_bits (output, *text, 8); put_bits (output, 0, 8); - + write_rice_code (HEADER_COMMENT, rice_k, output); for (text = wi->comment; text && *text && text - wi->comment < MAXSTRLEN - 2; text++) put_bits (output, *text, 8); put_bits (output, 0, 8); - + write_rice_code (HEADER_END, rice_k, output); - - write_rice_code (wi->max_states, rice_k, output); - put_bit (output, wi->color ? 1 : 0); + + write_rice_code (wi->max_states, rice_k, output); + put_bit (output, wi->color ? 1 : 0); write_rice_code (wi->width, rice_k, output); write_rice_code (wi->height, rice_k, output); if (wi->color) - write_rice_code (wi->chroma_max_states, rice_k, output); - write_rice_code (wi->p_min_level, rice_k, output); - write_rice_code (wi->p_max_level, rice_k, output); + write_rice_code (wi->chroma_max_states, rice_k, output); + write_rice_code (wi->p_min_level, rice_k, output); + write_rice_code (wi->p_max_level, rice_k, output); write_rice_code (wi->frames, rice_k, output); write_rice_code (wi->smoothing, rice_k, output); @@ -202,9 +202,9 @@ write_header (const wfa_info_t *wi, bitfile_t *output) if (wi->frames > 1) /* motion compensation stuff */ { - write_rice_code (wi->fps, rice_k, output); - write_rice_code (wi->search_range, rice_k, output); - put_bit (output, wi->half_pixel ? 1 : 0); + write_rice_code (wi->fps, rice_k, output); + write_rice_code (wi->search_range, rice_k, output); + put_bit (output, wi->half_pixel ? 1 : 0); put_bit (output, wi->B_as_past_ref ? 1 : 0); } @@ -215,7 +215,7 @@ write_header (const wfa_info_t *wi, bitfile_t *output) /***************************************************************************** private code - + *****************************************************************************/ static void @@ -228,21 +228,21 @@ write_tiling (const tiling_t *tiling, bitfile_t *output) { const unsigned rice_k = 8; /* parameter of Rice Code */ unsigned bits = bits_processed (output); - + write_rice_code (tiling->exponent, rice_k, output); if (tiling->method == FIASCO_TILING_VARIANCE_ASC || tiling->method == FIASCO_TILING_VARIANCE_DSC) { unsigned tile; /* current image tile */ - put_bit (output, 1); + put_bit (output, 1); for (tile = 0; tile < 1U << tiling->exponent; tile++) if (tiling->vorder [tile] != -1) /* image tile is visible */ put_bits (output, tiling->vorder [tile], tiling->exponent); } else { - put_bit (output, 0); + put_bit (output, 0); put_bit (output, tiling->method == FIASCO_TILING_SPIRAL_ASC); } diff --git a/converter/other/fiasco/output/write.h b/converter/other/fiasco/output/write.h index 6bdc2f1b..1fb3393c 100644 --- a/converter/other/fiasco/output/write.h +++ b/converter/other/fiasco/output/write.h @@ -1,8 +1,8 @@ /* * write.h * - * Written by: Ullrich Hafner - * + * Written by: Ullrich Hafner + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ diff --git a/converter/other/fiasco/params.c b/converter/other/fiasco/params.c index 29f52afc..32145fc3 100644 --- a/converter/other/fiasco/params.c +++ b/converter/other/fiasco/params.c @@ -1,8 +1,8 @@ /* - * params.c: Parameter file and command line parsing + * params.c: Parameter file and command line parsing * - * Written by: Stefan Frank - * Ullrich Hafner + * Written by: Stefan Frank + * Ullrich Hafner * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner @@ -24,12 +24,12 @@ #include <stdio.h> #include <ctype.h> -#include <math.h> /* strtod() on SUN sparc */ +#include <math.h> /* strtod() on SUN sparc */ #include <stdlib.h> #include <string.h> -#include <getopt.h> /* system or ../lib */ +#include <getopt.h> /* system or ../lib */ #include "pm_c_util.h" #include "nstring.h" @@ -46,7 +46,7 @@ /***************************************************************************** - prototypes + prototypes *****************************************************************************/ @@ -64,7 +64,7 @@ usage (const param_t *params, const char *progname, const char *synopsis, /***************************************************************************** - public code + public code *****************************************************************************/ @@ -84,29 +84,29 @@ parseargs (param_t *usr_params, * 'synopsis' contains a brief description of the program and * 'comment' may contain some additional advice. * Initialization order of parameters: - * 1.) Default values given by the param_t struct - * 2.) System parameter-file ('path'/'sys_file_name') - * 3.) User parameter-file ($HOME/'usr_file_name') - * 4.) Command line parameters - * 5.) Parameter-file forced by option -f (--config-file) + * 1.) Default values given by the param_t struct + * 2.) System parameter-file ('path'/'sys_file_name') + * 3.) User parameter-file ($HOME/'usr_file_name') + * 4.) Command line parameters + * 5.) Parameter-file forced by option -f (--config-file) * * Return value: - * index in ARGV of the first ARGV-element that is not an option. + * index in ARGV of the first ARGV-element that is not an option. * * Side effects: - * the elements of ARGV are permuted + * the elements of ARGV are permuted * usr_params [].value is modified */ { - extern int optind; /* index in ARGV of the 1st element - that is not an option */ - bool_t detailed_help = NO; /* NO if all parameters can be modified - with short options too */ - unsigned n1; /* number of user parameters */ - unsigned n2; /* number of system parameters */ - bool_t read_config_file = NO; /* will override command line */ - param_t *params; /* array of user and system params */ - param_t *sys_params; /* array of system parameters */ + extern int optind; /* index in ARGV of the 1st element + that is not an option */ + bool_t detailed_help = NO; /* NO if all parameters can be modified + with short options too */ + unsigned n1; /* number of user parameters */ + unsigned n2; /* number of system parameters */ + bool_t read_config_file = NO; /* will override command line */ + param_t *params; /* array of user and system params */ + param_t *sys_params; /* array of system parameters */ param_t detailed_sys_params [] = /* detailed system parameters */ { {"version", NULL, 'v', PFLAG, {0}, NULL, @@ -121,7 +121,7 @@ parseargs (param_t *usr_params, "Print detailed help, then exit."}, {NULL, NULL, 0, PSTR, {0}, NULL, NULL } }; - param_t short_sys_params [] = /* short system parameters */ + param_t short_sys_params [] = /* short system parameters */ { {"version", NULL, 'v', PFLAG, {0}, NULL, "Print program version number, then exit."}, @@ -133,10 +133,10 @@ parseargs (param_t *usr_params, "Print this help, then exit."}, {NULL, NULL, 0, PSTR, {0}, NULL, NULL } }; - char *sys_path; /* path to system config file */ + char *sys_path; /* path to system config file */ sys_path = calloc (strlen (path) + strlen (sys_file_name) + 2, - sizeof (char)); + sizeof (char)); if (!sys_path) error ("Out of memory."); sprintf (sys_path, "%s/%s", path, sys_file_name); @@ -179,12 +179,12 @@ parseargs (param_t *usr_params, FILE *parameter_file = open_file (sys_path, NULL, READ_ACCESS); if (parameter_file == NULL) /* - warning ("No system resource file found."); + warning ("No system resource file found."); */ {} else { - read_parameter_file (params, parameter_file); - fclose (parameter_file); + read_parameter_file (params, parameter_file); + fclose (parameter_file); } } /* @@ -194,138 +194,138 @@ parseargs (param_t *usr_params, FILE *parameter_file = open_file (usr_file_name, "HOME", READ_ACCESS); if (parameter_file != NULL) { - read_parameter_file (params, parameter_file); - fclose (parameter_file); + read_parameter_file (params, parameter_file); + fclose (parameter_file); } } /* * Parse command line options */ { - extern char *optarg; /* argument of current option */ - struct option *long_options; /* array of long options */ - int option_index = 0; - char optstr [MAXSTRLEN]; /* string containing the legitimate - option characters */ - int optchar; /* found option character */ + extern char *optarg; /* argument of current option */ + struct option *long_options; /* array of long options */ + int option_index = 0; + char optstr [MAXSTRLEN]; /* string containing the legitimate + option characters */ + int optchar; /* found option character */ /* * Build short option string for getopt_long (). */ { - param_t *p; /* counter */ - char *ptr_optstr; /* pointer to position in string */ - - ptr_optstr = optstr; - for (p = params; p->name != NULL; p++) - if (p->optchar != '\0') - { - *ptr_optstr++ = p->optchar; - if (p->type == POSTR) - { - *ptr_optstr++ = ':'; - *ptr_optstr++ = ':'; - } - else if (p->type != PFLAG) - *ptr_optstr++ = ':'; - } - *ptr_optstr = '\0'; + param_t *p; /* counter */ + char *ptr_optstr; /* pointer to position in string */ + + ptr_optstr = optstr; + for (p = params; p->name != NULL; p++) + if (p->optchar != '\0') + { + *ptr_optstr++ = p->optchar; + if (p->type == POSTR) + { + *ptr_optstr++ = ':'; + *ptr_optstr++ = ':'; + } + else if (p->type != PFLAG) + *ptr_optstr++ = ':'; + } + *ptr_optstr = '\0'; } /* * Build long option string for getopt_long (). */ { - int i; - - long_options = calloc (n1 + n2 + 1, sizeof (struct option)); - if (!long_options) - error ("Out of memory."); - for (i = 0; params [i].name != NULL; i++) - { - long_options [i].name = params [i].name; - switch (params [i].type) - { - case PFLAG: - long_options [i].has_arg = 0; - break; - case POSTR: - long_options [i].has_arg = 2; - break; - case PINT: - case PSTR: - case PFLOAT: - default: - long_options [i].has_arg = 1; - break; - } - long_options [i].has_arg = params [i].type != PFLAG; - long_options [i].flag = NULL; - long_options [i].val = 0; - } + int i; + + long_options = calloc (n1 + n2 + 1, sizeof (struct option)); + if (!long_options) + error ("Out of memory."); + for (i = 0; params [i].name != NULL; i++) + { + long_options [i].name = params [i].name; + switch (params [i].type) + { + case PFLAG: + long_options [i].has_arg = 0; + break; + case POSTR: + long_options [i].has_arg = 2; + break; + case PINT: + case PSTR: + case PFLOAT: + default: + long_options [i].has_arg = 1; + break; + } + long_options [i].has_arg = params [i].type != PFLAG; + long_options [i].flag = NULL; + long_options [i].val = 0; + } } /* * Parse command line */ while ((optchar = getopt_long (argc, argv, optstr, long_options, - &option_index)) != EOF) + &option_index)) != EOF) { - int param_index = -1; - - switch (optchar) - { - case 0: - param_index = option_index; - break; - case ':': - if (detailed_help) - fprintf (stderr, - "Try `%s -h' or `%s --help' for " - "more information.\n", - argv [0], argv [0]); - else - fprintf (stderr, "Try `%s --help' for more information.\n", - argv [0]); - exit (2); - break; - case '?': - if (detailed_help) - fprintf (stderr, - "Try `%s -h' or `%s --help' " - "for more information.\n", - argv [0], argv [0]); - else - fprintf (stderr, "Try `%s --help' for more information.\n", - argv [0]); - exit (2); - break; - default: - { - int i; - - for (i = 0; params [i].name != NULL; i++) - if (params [i].optchar == optchar) - { - param_index = i; - break; - } - } - } - /* - * Check for system options - */ - if (param_index >= 0) - { - set_parameter (params + param_index, optarg ? optarg : ""); - if (streq (params [param_index].name, "help")) - usage (params, argv [0], synopsis, comment, non_opt_string, - YES, sys_path, usr_file_name); - else if (streq (params [param_index].name, "info")) - usage (params, argv [0], synopsis, comment, non_opt_string, - NO, sys_path, usr_file_name); - else if (streq (params [param_index].name, "version")) - { + int param_index = -1; + + switch (optchar) + { + case 0: + param_index = option_index; + break; + case ':': + if (detailed_help) + fprintf (stderr, + "Try `%s -h' or `%s --help' for " + "more information.\n", + argv [0], argv [0]); + else + fprintf (stderr, "Try `%s --help' for more information.\n", + argv [0]); + exit (2); + break; + case '?': + if (detailed_help) + fprintf (stderr, + "Try `%s -h' or `%s --help' " + "for more information.\n", + argv [0], argv [0]); + else + fprintf (stderr, "Try `%s --help' for more information.\n", + argv [0]); + exit (2); + break; + default: + { + int i; + + for (i = 0; params [i].name != NULL; i++) + if (params [i].optchar == optchar) + { + param_index = i; + break; + } + } + } + /* + * Check for system options + */ + if (param_index >= 0) + { + set_parameter (params + param_index, optarg ? optarg : ""); + if (streq (params [param_index].name, "help")) + usage (params, argv [0], synopsis, comment, non_opt_string, + YES, sys_path, usr_file_name); + else if (streq (params [param_index].name, "info")) + usage (params, argv [0], synopsis, comment, non_opt_string, + NO, sys_path, usr_file_name); + else if (streq (params [param_index].name, "version")) + { fprintf (stderr, "%s " VERSION "\n", argv [0]); { /* Kludge for standard Netpbm version announcement */ @@ -337,15 +337,15 @@ parseargs (param_t *usr_params, pm_proginit(&argc, (const char **) modified_argv); } exit (2); - } - else if (streq (params [param_index].name, "verbose")) - fiasco_set_verbosity ( + } + else if (streq (params [param_index].name, "verbose")) + fiasco_set_verbosity ( * (fiasco_verbosity_e *) parameter_value (params, "verbose")); - else if (streq (params [param_index].name, "config")) - read_config_file = YES; - param_index = -1; /* clear index flag */ - } + else if (streq (params [param_index].name, "config")) + read_config_file = YES; + param_index = -1; /* clear index flag */ + } } free (long_options); @@ -360,21 +360,21 @@ parseargs (param_t *usr_params, if ((filename = (char *) parameter_value (params, "config")) != NULL) { - FILE *parameter_file; /* input file */ - - warning ("Options set in file `%s' will override" - " command line options.", filename); - parameter_file = open_file (filename, NULL, READ_ACCESS); - if (parameter_file != NULL) - { - read_parameter_file (params, parameter_file); - fclose (parameter_file); - } - else - file_error (filename); + FILE *parameter_file; /* input file */ + + warning ("Options set in file `%s' will override" + " command line options.", filename); + parameter_file = open_file (filename, NULL, READ_ACCESS); + if (parameter_file != NULL) + { + read_parameter_file (params, parameter_file); + fclose (parameter_file); + } + else + file_error (filename); } else - error ("Invalid config filename."); + error ("Invalid config filename."); } memcpy (usr_params, params, n1 * sizeof (param_t)); /* fill user struct */ @@ -389,7 +389,7 @@ parameter_value (const param_t *params, const char *name) * Extract value of parameter 'name.' of the given parameters 'params'. * * Return value: - * value of given parameter + * value of given parameter */ { int pind = get_parameter_index (params, name); @@ -412,7 +412,7 @@ ask_and_set (param_t *params, const char *name, const char *msg) * No return value. * * Side effects: - * 'params ['name'].value' is changed + * 'params ['name'].value' is changed */ { char answer [MAXSTRLEN]; @@ -426,18 +426,18 @@ ask_and_set (param_t *params, const char *name, const char *msg) switch (params [index].type) { - case PFLAG: /* Unusual, at least. */ - warning ("Flags should be initialized and set on demand, " - "not request"); + case PFLAG: /* Unusual, at least. */ + warning ("Flags should be initialized and set on demand, " + "not request"); case PINT: case PSTR: case POSTR: case PFLOAT: - scanf (MAXSTRLEN_SCANF, answer); - set_parameter (¶ms [index], answer); - break; + scanf (MAXSTRLEN_SCANF, answer); + set_parameter (¶ms [index], answer); + break; default: - error ("Invalid parameter type for %s", name); + error ("Invalid parameter type for %s", name); } } @@ -459,22 +459,22 @@ write_parameters (const param_t *params, FILE *output) fprintf (output, "# %s = ", params [pind].name); switch (params [pind].type) { - case PFLAG: - fprintf (output, "%s\n", params [pind].value.b ? "TRUE" : "FALSE"); - break; - case PINT: - fprintf (output, "%d\n", params [pind].value.i); - break; - case PFLOAT: - fprintf (output, "%.4f\n", (double) params [pind].value.f); - break; - case PSTR: - case POSTR: - fprintf (output, "%s\n", params [pind].value.s); - break; - default: - error ("Invalid type %d for parameter %s", - params [pind].type, params [pind].name); + case PFLAG: + fprintf (output, "%s\n", params [pind].value.b ? "TRUE" : "FALSE"); + break; + case PINT: + fprintf (output, "%d\n", params [pind].value.i); + break; + case PFLOAT: + fprintf (output, "%.4f\n", (double) params [pind].value.f); + break; + case PSTR: + case POSTR: + fprintf (output, "%s\n", params [pind].value.s); + break; + default: + error ("Invalid type %d for parameter %s", + params [pind].type, params [pind].name); } } fputc ('\n', output); @@ -482,7 +482,7 @@ write_parameters (const param_t *params, FILE *output) /***************************************************************************** - private code + private code *****************************************************************************/ @@ -494,7 +494,7 @@ set_parameter (param_t *parameter, const char *value) * No return value. * * Side effects: - * 'parameter.value' is changed accordingly + * 'parameter.value' is changed accordingly */ { assert (parameter); @@ -502,61 +502,61 @@ set_parameter (param_t *parameter, const char *value) switch (parameter->type) { case PFLAG: - if (value != NULL && *value != '\0') - { - if (strcaseeq (value, "TRUE")) - parameter->value.b = YES; - else if (strcaseeq (value, "FALSE")) - parameter->value.b = NO; - else if (strcaseeq (value, "YES")) - parameter->value.b = YES; - else if (strcaseeq (value, "NO")) - parameter->value.b = NO; - else - { - long int data; - char *endptr; - - data = strtol (value, &endptr, 0); - if (*endptr != '\0' || endptr == value) - warning ("Invalid value `%s' converted to %d", - value, (int) data); - parameter->value.b = data ? YES : NO; - } - } - else - parameter->value.b = !parameter->value.b; - break; + if (value != NULL && *value != '\0') + { + if (strcaseeq (value, "TRUE")) + parameter->value.b = YES; + else if (strcaseeq (value, "FALSE")) + parameter->value.b = NO; + else if (strcaseeq (value, "YES")) + parameter->value.b = YES; + else if (strcaseeq (value, "NO")) + parameter->value.b = NO; + else + { + long int data; + char *endptr; + + data = strtol (value, &endptr, 0); + if (*endptr != '\0' || endptr == value) + warning ("Invalid value `%s' converted to %d", + value, (int) data); + parameter->value.b = data ? YES : NO; + } + } + else + parameter->value.b = !parameter->value.b; + break; case PINT: - { - long int data; - char *endptr; - - data = strtol (value, &endptr, 0); - if (*endptr != '\0' || endptr == value) - warning ("Invalid value `%s' converted to %d", - value, (int) data); - parameter->value.i = data; - } - break; + { + long int data; + char *endptr; + + data = strtol (value, &endptr, 0); + if (*endptr != '\0' || endptr == value) + warning ("Invalid value `%s' converted to %d", + value, (int) data); + parameter->value.i = data; + } + break; case PFLOAT: - { - double data; - char *endptr; - - data = strtod (value, &endptr); - if (*endptr != '\0' || endptr == value) - warning ("Invalid value `%s' converted to %f", - value, (double) data); - parameter->value.f = data; - } - break; + { + double data; + char *endptr; + + data = strtod (value, &endptr); + if (*endptr != '\0' || endptr == value) + warning ("Invalid value `%s' converted to %f", + value, (double) data); + parameter->value.f = data; + } + break; case PSTR: case POSTR: - parameter->value.s = value ? strdup (value) : NULL; - break; + parameter->value.s = value ? strdup (value) : NULL; + break; default: - error ("Invalid parameter type for %s", parameter->name); + error ("Invalid parameter type for %s", parameter->name); } } @@ -566,7 +566,7 @@ get_parameter_index (const param_t *params, const char *search_string) * Search for parameter with name 'search_string' in parameter struct. * * Return value: - * index of parameter or -1 if no matching parameter has been found + * index of parameter or -1 if no matching parameter has been found */ { int n; @@ -577,8 +577,8 @@ get_parameter_index (const param_t *params, const char *search_string) for (n = 0; params [n].name != NULL; n++) if (strcaseeq (params [n].name, search_string)) { - index = n; - break; + index = n; + break; } return index; @@ -592,7 +592,7 @@ read_parameter_file (param_t *params, FILE *file) * No return value. * * Side effects: - * 'params [].value' are changed if specified in 'file' + * 'params [].value' are changed if specified in 'file' */ { char buffer [MAXSTRLEN]; @@ -602,41 +602,41 @@ read_parameter_file (param_t *params, FILE *file) while (fgets (buffer, MAXSTRLEN, file) != NULL) { - char *b; /* temporary variable */ - char *name; /* parameter name */ - char *value; /* parameter value */ - int pind; /* current argument number */ + char *b; /* temporary variable */ + char *name; /* parameter name */ + char *value; /* parameter value */ + int pind; /* current argument number */ b = strchr (buffer, '#'); - if (b != NULL) /* Strip comments. */ - *b = '\0'; + if (b != NULL) /* Strip comments. */ + *b = '\0'; b = strchr (buffer, '='); - if (b == NULL) /* Strip lines that contain no '=' */ - continue; - *b = '\0'; /* Replace '=' by string terminator */ + if (b == NULL) /* Strip lines that contain no '=' */ + continue; + *b = '\0'; /* Replace '=' by string terminator */ /* * Extract value of parameter */ for (value = b + 1; ISSPACE (*value); value++) - ; /* Delete leading spaces */ + ; /* Delete leading spaces */ for (b = value + strlen (value) - 1; b >= value && ISSPACE (*b); b--) - *b = '\0'; /* Delete trailing spaces. */ + *b = '\0'; /* Delete trailing spaces. */ /* * Extract parameter name */ for (name = buffer; ISSPACE (*name); name++) - ; /* Delete leading spaces */ + ; /* Delete leading spaces */ for (b = name + strlen (name) - 1; b >= name && ISSPACE (*b); b--) - *b = '\0'; /* Delete trailing spaces. */ + *b = '\0'; /* Delete trailing spaces. */ pind = get_parameter_index (params, name); if (pind >= 0) - set_parameter (¶ms [pind], value); + set_parameter (¶ms [pind], value); n++; } @@ -660,7 +660,7 @@ usage (const param_t *params, const char *progname, const char *synopsis, * No return value. */ { - int i; + int i; size_t width = 0; fprintf (stderr, "Usage: %s [OPTION]...%s\n", progname, diff --git a/converter/other/fiasco/params.h b/converter/other/fiasco/params.h index a1164cf7..dd79d43d 100644 --- a/converter/other/fiasco/params.h +++ b/converter/other/fiasco/params.h @@ -3,7 +3,7 @@ * * Written by: Stefan Frank * Ullrich Hafner - * + * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -43,13 +43,13 @@ typedef struct param_t } param_t; int -parseargs (param_t *usr_params, - int argc, char **argv, +parseargs (param_t *usr_params, + int argc, char **argv, const char *synopsis, - const char *comment, - const char *non_opt_string, + const char *comment, + const char *non_opt_string, const char *path, - const char *sys_file_name, + const char *sys_file_name, const char *usr_file_name); void write_parameters (const param_t *params, FILE *output); diff --git a/converter/other/jbig/libjbig/include/jbig.h b/converter/other/jbig/libjbig/include/jbig.h index 67994107..3c991b08 100644 --- a/converter/other/jbig/libjbig/include/jbig.h +++ b/converter/other/jbig/libjbig/include/jbig.h @@ -39,7 +39,7 @@ struct jbg_buf { int len; /* length of the data in this block */ struct jbg_buf *next; /* pointer to next block */ struct jbg_buf *previous; /* pointer to previous block * - * (unused in freelist) */ + * (unused in freelist) */ struct jbg_buf *last; /* only used in list head: final block of list */ struct jbg_buf **free_list; /* pointer to pointer to head of free list */ }; @@ -70,12 +70,12 @@ struct jbg_buf { /* encoding options that will not be indicated in the header */ #define JBG_DELAY_AT 0x100 /* Delay ATMOVE until the first line of the next - * stripe. Option available for compatibility - * with conformance test example in clause 7.2. */ + * stripe. Option available for compatibility + * with conformance test example in clause 7.2. */ #define JBG_SDRST 0x200 /* Use SDRST instead of SDNORM. This option is - * there for anyone who needs to generate - * test data that covers the SDRST cases. */ + * there for anyone who needs to generate + * test data that covers the SDRST cases. */ /* * Possible error code return values @@ -115,7 +115,7 @@ struct jbg_enc_state { char *dppriv; /* optional private deterministic prediction table */ char *res_tab; /* table for the resolution reduction algorithm */ struct jbg_buf ****sde; /* array [stripe][layer][plane] pointers to * - * buffers for stored SDEs */ + * buffers for stored SDEs */ struct jbg_arenc_state *s; /* array [planes] for arithm. encoder status */ struct jbg_buf *free_list; /* list of currently unused SDE block buffers */ void (*data_out)(unsigned char *start, size_t len, void *file); @@ -140,7 +140,7 @@ struct jbg_dec_state { unsigned long xd, yd; /* size of the full image (resolution layer d) */ int planes; /* number of different bitmap planes */ unsigned long l0; /* number of lines per stripe at lowest * - * resolution layer 0 */ + * resolution layer 0 */ unsigned long stripes; /* number of stripes required (determ. by l0) */ int order; /* SDE ordering parameters */ int options; /* encoding parameters */ @@ -152,34 +152,34 @@ struct jbg_dec_state { /* * Pointers to array [planes] of lower/higher resolution images. - * lhp[d & 1] contains image of layer d. + * lhp[d & 1] contains image of layer d. */ unsigned char **lhp[2]; /* status information */ int **tx, **ty; /* array [plane][layer-dl] with x,y-offset of AT pixel */ struct jbg_ardec_state **s; /* array [plane][layer-dl] for arithmetic * - * decoder status */ + * decoder status */ int **reset; /* array [plane][layer-dl] remembers if previous stripe * - * in that plane/resolution ended with SDRST. */ + * in that plane/resolution ended with SDRST. */ unsigned long bie_len; /* number of bytes read so far */ unsigned char buffer[20]; /* used to store BIH or marker segments fragm. */ int buf_len; /* number of bytes in buffer */ unsigned long comment_skip; /* remaining bytes of a COMMENT segment */ unsigned long x; /* x position of next pixel in current SDE */ - unsigned long i; /* line in current SDE (first line of each stripe is 0) */ + unsigned long i; /* line in current SDE (first line of each stripe is 0) */ int at_moves; /* number of AT moves in the current stripe */ unsigned long at_line[JBG_ATMOVES_MAX]; /* lines at which an * - * AT move will happen */ + * AT move will happen */ int at_tx[JBG_ATMOVES_MAX], at_ty[JBG_ATMOVES_MAX]; /* ATMOVE offsets in * - * current stripe */ + * current stripe */ unsigned long line_h1, line_h2, line_h3; /* variables of decode_pscd */ unsigned long line_l1, line_l2, line_l3; int pseudo; /* flag for TPBON/TPDON: next pixel is pseudo pixel */ int **lntp; /* flag [plane][layer-dl] for TP: line is not typical */ unsigned long xmax, ymax; /* if possible abort before image gets * - * larger than this size */ + * larger than this size */ int dmax; /* abort after this layer */ }; @@ -192,31 +192,31 @@ struct jbg_dec_state { /* function prototypes */ void jbg_enc_init(struct jbg_enc_state *s, unsigned long x, unsigned long y, - int planes, unsigned char **p, - void (*data_out)(unsigned char *start, size_t len, - void *file), - void *file); + int planes, unsigned char **p, + void (*data_out)(unsigned char *start, size_t len, + void *file), + void *file); int jbg_enc_lrlmax(struct jbg_enc_state *s, unsigned long mwidth, - unsigned long mheight); + unsigned long mheight); void jbg_enc_layers(struct jbg_enc_state *s, int d); int jbg_enc_lrange(struct jbg_enc_state *s, int dl, int dh); void jbg_enc_options(struct jbg_enc_state *s, int order, int options, - unsigned long l0, int mx, int my); + unsigned long l0, int mx, int my); void jbg_enc_out(struct jbg_enc_state *s); void jbg_enc_free(struct jbg_enc_state *s); void jbg_dec_init(struct jbg_dec_state *s); void jbg_dec_maxsize(struct jbg_dec_state *s, unsigned long xmax, - unsigned long ymax); + unsigned long ymax); int jbg_dec_in(struct jbg_dec_state *s, unsigned char *data, size_t len, - size_t *cnt); + size_t *cnt); unsigned long jbg_dec_getwidth(const struct jbg_dec_state *s); unsigned long jbg_dec_getheight(const struct jbg_dec_state *s); unsigned char *jbg_dec_getimage(const struct jbg_dec_state *s, int plane); unsigned long jbg_dec_getsize(const struct jbg_dec_state *s); void jbg_dec_merge_planes(const struct jbg_dec_state *s, int use_graycode, - void (*data_out)(unsigned char *start, size_t len, - void *file), void *file); + void (*data_out)(unsigned char *start, size_t len, + void *file), void *file); unsigned long jbg_dec_getsize_merged(const struct jbg_dec_state *s); void jbg_dec_free(struct jbg_dec_state *s); @@ -225,9 +225,9 @@ void jbg_int2dppriv(unsigned char *dptable, const char *internal); void jbg_dppriv2int(char *internal, const unsigned char *dptable); unsigned long jbg_ceil_half(unsigned long x, int n); void jbg_split_planes(unsigned long x, unsigned long y, int has_planes, - int encode_planes, - const unsigned char *src, unsigned char **dest, - int use_graycode); + int encode_planes, + const unsigned char *src, unsigned char **dest, + int use_graycode); int jbg_newlen(unsigned char *bie, size_t len); #endif /* JBG_H */ diff --git a/converter/other/jbig/libjbig/include/jbig_ar.h b/converter/other/jbig/libjbig/include/jbig_ar.h index ed5f2f86..e3366aed 100644 --- a/converter/other/jbig/libjbig/include/jbig_ar.h +++ b/converter/other/jbig/libjbig/include/jbig_ar.h @@ -39,9 +39,9 @@ struct jbg_ardec_state { * special value -1 signals that zero-padding has started */ int startup; /* boolean flag that controls initial fill of s->c */ int nopadding; /* boolean flag that triggers return -2 between - * reaching PSCD end and decoding the first symbol - * that might never have been encoded in the first - * place */ + * reaching PSCD end and decoding the first symbol + * that might never have been encoded in the first + * place */ }; void arith_encode_init(struct jbg_arenc_state *s, int reuse_st); diff --git a/converter/other/jbig/libjbig/jbig.c b/converter/other/jbig/libjbig/jbig.c index cf24a93b..42932ca7 100644 --- a/converter/other/jbig/libjbig/jbig.c +++ b/converter/other/jbig/libjbig/jbig.c @@ -143,7 +143,7 @@ static void *checked_malloc(size_t nmemb, size_t size) #if 0 fprintf(stderr, "%p = malloc(%lu * %lu)\n", p, - (unsigned long) nmemb, (unsigned long) size); + (unsigned long) nmemb, (unsigned long) size); #endif return p; @@ -169,7 +169,7 @@ static void *checked_realloc(void *ptr, size_t nmemb, size_t size) #if 0 fprintf(stderr, "%p = realloc(%p, %lu * %lu)\n", p, ptr, - (unsigned long) nmemb, (unsigned long) size); + (unsigned long) nmemb, (unsigned long) size); #endif return p; @@ -334,9 +334,9 @@ static void jbg_buf_prefix(struct jbg_buf *new_prefix, struct jbg_buf **start) * After the call, *head == NULL. */ static void jbg_buf_output(struct jbg_buf **head, - void (*data_out)(unsigned char *start, - size_t len, void *file), - void *file) + void (*data_out)(unsigned char *start, + size_t len, void *file), + void *file) { struct jbg_buf *tmp; @@ -388,7 +388,7 @@ static void jbg_set_default_l0(struct jbg_enc_state *s) * Calculate the number of stripes, as defined in clause 6.2.3 of T.82. */ static unsigned long jbg_stripes(unsigned long l0, unsigned long yd, - unsigned long d) + unsigned long d) { unsigned long y0 = jbg_ceil_half(yd, d); @@ -767,8 +767,8 @@ static char jbg_dptable[256 + 512 + 2048 + 4096] = { void jbg_enc_init(struct jbg_enc_state *s, unsigned long x, unsigned long y, int planes, unsigned char **p, void (*data_out)(unsigned char *start, size_t len, - void *file), - void *file) + void *file), + void *file) { unsigned long l, lx; int i; @@ -831,7 +831,7 @@ void jbg_enc_init(struct jbg_enc_state *s, unsigned long x, unsigned long y, * is returned. */ int jbg_enc_lrlmax(struct jbg_enc_state *s, unsigned long x, - unsigned long y) + unsigned long y) { for (s->d = 0; s->d < 6; s->d++) if (jbg_ceil_half(s->xd, s->d) <= x && jbg_ceil_half(s->yd, s->d) <= y) @@ -882,7 +882,7 @@ int jbg_enc_lrange(struct jbg_enc_state *s, int dl, int dh) * number of layer 0 lines per stripes. */ void jbg_enc_options(struct jbg_enc_state *s, int order, int options, - unsigned long l0, int mx, int my) + unsigned long l0, int mx, int my) { if (order >= 0 && order <= 0x0f) s->order = order; if (options >= 0) s->options = options; @@ -900,7 +900,7 @@ void jbg_enc_options(struct jbg_enc_state *s, int order, int options, * for later output in the correct order. */ static void encode_sde(struct jbg_enc_state *s, - long stripe, int layer, int plane) + long stripe, int layer, int plane) { unsigned char *hp, *lp1, *lp2, *p0, *p1, *q1, *q2; unsigned long hl, ll, hx, hy, lx, ly, hbpl, lbpl; @@ -933,7 +933,7 @@ static void encode_sde(struct jbg_enc_state *s, if (stripe == 0) tp_lines = tp_exceptions = tp_pixels = dp_pixels = encoded_pixels = 0; fprintf(stderr, "encode_sde: s/d/p = %2ld/%2d/%2d\n", - stripe, layer, plane); + stripe, layer, plane); #endif /* number of lines per stripe in highres image */ @@ -1001,59 +1001,59 @@ static void encode_sde(struct jbg_enc_state *s, /* check whether it is worth to perform an ATMOVE */ if (!at_determined && c_all > 2048) { - cmin = clmin = 0xffffffffL; - cmax = clmax = 0; - tmax = 0; - for (t = (s->options & JBG_LRLTWO) ? 5 : 3; t <= s->mx; t++) { - if (c[t] > cmax) cmax = c[t]; - if (c[t] < cmin) cmin = c[t]; - if (c[t] > c[tmax]) tmax = t; - } - clmin = (c[0] < cmin) ? c[0] : cmin; - clmax = (c[0] > cmax) ? c[0] : cmax; - if (c_all - cmax < (c_all >> 3) && - cmax - c[s->tx[plane]] > c_all - cmax && - cmax - c[s->tx[plane]] > (c_all >> 4) && - /* ^ T.82 said < here, fixed in Cor.1/25 */ - cmax - (c_all - c[s->tx[plane]]) > c_all - cmax && - cmax - (c_all - c[s->tx[plane]]) > (c_all >> 4) && - cmax - cmin > (c_all >> 2) && - (s->tx[plane] || clmax - clmin > (c_all >> 3))) { - /* we have decided to perform an ATMOVE */ - new_tx = tmax; - if (!(s->options & JBG_DELAY_AT)) { - new_tx_line = i; - s->tx[plane] = new_tx; - } + cmin = clmin = 0xffffffffL; + cmax = clmax = 0; + tmax = 0; + for (t = (s->options & JBG_LRLTWO) ? 5 : 3; t <= s->mx; t++) { + if (c[t] > cmax) cmax = c[t]; + if (c[t] < cmin) cmin = c[t]; + if (c[t] > c[tmax]) tmax = t; + } + clmin = (c[0] < cmin) ? c[0] : cmin; + clmax = (c[0] > cmax) ? c[0] : cmax; + if (c_all - cmax < (c_all >> 3) && + cmax - c[s->tx[plane]] > c_all - cmax && + cmax - c[s->tx[plane]] > (c_all >> 4) && + /* ^ T.82 said < here, fixed in Cor.1/25 */ + cmax - (c_all - c[s->tx[plane]]) > c_all - cmax && + cmax - (c_all - c[s->tx[plane]]) > (c_all >> 4) && + cmax - cmin > (c_all >> 2) && + (s->tx[plane] || clmax - clmin > (c_all >> 3))) { + /* we have decided to perform an ATMOVE */ + new_tx = tmax; + if (!(s->options & JBG_DELAY_AT)) { + new_tx_line = i; + s->tx[plane] = new_tx; + } #ifdef DEBUG - fprintf(stderr, "ATMOVE: line=%ld, tx=%d, c_all=%ld\n", - i, new_tx, c_all); + fprintf(stderr, "ATMOVE: line=%ld, tx=%d, c_all=%ld\n", + i, new_tx, c_all); #endif - } - at_determined = 1; + } + at_determined = 1; } assert(s->tx[plane] >= 0); /* i.e., tx can safely be cast to unsigned */ /* typical prediction */ if (s->options & JBG_TPBON) { - ltp = 1; - p1 = hp; - if (i > 0 || !reset) { - q1 = hp - hbpl; - while (q1 < hp && (ltp = (*p1++ == *q1++)) != 0) ; - } else - while (p1 < hp + hbpl && (ltp = (*p1++ == 0)) != 0) ; - arith_encode(se, (s->options & JBG_LRLTWO) ? TPB2CX : TPB3CX, - ltp == ltp_old); + ltp = 1; + p1 = hp; + if (i > 0 || !reset) { + q1 = hp - hbpl; + while (q1 < hp && (ltp = (*p1++ == *q1++)) != 0) ; + } else + while (p1 < hp + hbpl && (ltp = (*p1++ == 0)) != 0) ; + arith_encode(se, (s->options & JBG_LRLTWO) ? TPB2CX : TPB3CX, + ltp == ltp_old); #ifdef DEBUG - tp_lines += ltp; + tp_lines += ltp; #endif - ltp_old = ltp; - if (ltp) { - /* skip next line */ - hp += hbpl; - continue; - } + ltp_old = ltp; + if (ltp) { + /* skip next line */ + hp += hbpl; + continue; + } } /* @@ -1071,102 +1071,102 @@ static void encode_sde(struct jbg_enc_state *s, /* encode line */ for (j = 0; j < hx; hp++) { - line_h1 |= *hp; - if (j < hbpl * 8 - 8 && (i > 0 || !reset)) { - line_h2 |= *(hp - hbpl + 1); - if (i > 1 || !reset) - line_h3 |= *(hp - hbpl - hbpl + 1); - } - if (s->options & JBG_LRLTWO) { - /* two line template */ - do { - line_h1 <<= 1; line_h2 <<= 1; line_h3 <<= 1; - if (s->tx[plane]) { - if ((unsigned) s->tx[plane] > j) - a = 0; - else { - o = (j - s->tx[plane]) - (j & ~7L); - a = (hp[o >> 3] >> (7 - (o & 7))) & 1; - a <<= 4; - } - assert(s->tx[plane] > 23 || - a == ((line_h1 >> (4 + s->tx[plane])) & 0x010)); - arith_encode(se, (((line_h2 >> 10) & 0x3e0) | a | - ((line_h1 >> 9) & 0x00f)), - (line_h1 >> 8) & 1); - } - else - arith_encode(se, (((line_h2 >> 10) & 0x3f0) | - ((line_h1 >> 9) & 0x00f)), - (line_h1 >> 8) & 1); + line_h1 |= *hp; + if (j < hbpl * 8 - 8 && (i > 0 || !reset)) { + line_h2 |= *(hp - hbpl + 1); + if (i > 1 || !reset) + line_h3 |= *(hp - hbpl - hbpl + 1); + } + if (s->options & JBG_LRLTWO) { + /* two line template */ + do { + line_h1 <<= 1; line_h2 <<= 1; line_h3 <<= 1; + if (s->tx[plane]) { + if ((unsigned) s->tx[plane] > j) + a = 0; + else { + o = (j - s->tx[plane]) - (j & ~7L); + a = (hp[o >> 3] >> (7 - (o & 7))) & 1; + a <<= 4; + } + assert(s->tx[plane] > 23 || + a == ((line_h1 >> (4 + s->tx[plane])) & 0x010)); + arith_encode(se, (((line_h2 >> 10) & 0x3e0) | a | + ((line_h1 >> 9) & 0x00f)), + (line_h1 >> 8) & 1); + } + else + arith_encode(se, (((line_h2 >> 10) & 0x3f0) | + ((line_h1 >> 9) & 0x00f)), + (line_h1 >> 8) & 1); #ifdef DEBUG - encoded_pixels++; + encoded_pixels++; #endif - /* statistics for adaptive template changes */ - if (!at_determined && j >= s->mx && j < hx-2) { - p = (line_h1 & 0x100) != 0; /* current pixel value */ - c[0] += ((line_h2 & 0x4000) != 0) == p; /* default position */ - assert((!(((line_h2 >> 6) ^ line_h1) & 0x100)) == - (((line_h2 & 0x4000) != 0) == p)); - for (t = 5; t <= s->mx && t <= j; t++) { - o = (j - t) - (j & ~7L); - a = (hp[o >> 3] >> (7 - (o & 7))) & 1; - assert(t > 23 || - (a == p) == !(((line_h1 >> t) ^ line_h1) & 0x100)); - c[t] += a == p; - } - for (; t <= s->mx; t++) { - c[t] += 0 == p; - } - ++c_all; - } - } while (++j & 7 && j < hx); - } else { - /* three line template */ - do { - line_h1 <<= 1; line_h2 <<= 1; line_h3 <<= 1; - if (s->tx[plane]) { - if ((unsigned) s->tx[plane] > j) - a = 0; - else { - o = (j - s->tx[plane]) - (j & ~7L); - a = (hp[o >> 3] >> (7 - (o & 7))) & 1; - a <<= 2; - } - assert(s->tx[plane] > 23 || - a == ((line_h1 >> (6 + s->tx[plane])) & 0x004)); - arith_encode(se, (((line_h3 >> 8) & 0x380) | - ((line_h2 >> 12) & 0x078) | a | - ((line_h1 >> 9) & 0x003)), - (line_h1 >> 8) & 1); - } else - arith_encode(se, (((line_h3 >> 8) & 0x380) | - ((line_h2 >> 12) & 0x07c) | - ((line_h1 >> 9) & 0x003)), - (line_h1 >> 8) & 1); + /* statistics for adaptive template changes */ + if (!at_determined && j >= s->mx && j < hx-2) { + p = (line_h1 & 0x100) != 0; /* current pixel value */ + c[0] += ((line_h2 & 0x4000) != 0) == p; /* default position */ + assert((!(((line_h2 >> 6) ^ line_h1) & 0x100)) == + (((line_h2 & 0x4000) != 0) == p)); + for (t = 5; t <= s->mx && t <= j; t++) { + o = (j - t) - (j & ~7L); + a = (hp[o >> 3] >> (7 - (o & 7))) & 1; + assert(t > 23 || + (a == p) == !(((line_h1 >> t) ^ line_h1) & 0x100)); + c[t] += a == p; + } + for (; t <= s->mx; t++) { + c[t] += 0 == p; + } + ++c_all; + } + } while (++j & 7 && j < hx); + } else { + /* three line template */ + do { + line_h1 <<= 1; line_h2 <<= 1; line_h3 <<= 1; + if (s->tx[plane]) { + if ((unsigned) s->tx[plane] > j) + a = 0; + else { + o = (j - s->tx[plane]) - (j & ~7L); + a = (hp[o >> 3] >> (7 - (o & 7))) & 1; + a <<= 2; + } + assert(s->tx[plane] > 23 || + a == ((line_h1 >> (6 + s->tx[plane])) & 0x004)); + arith_encode(se, (((line_h3 >> 8) & 0x380) | + ((line_h2 >> 12) & 0x078) | a | + ((line_h1 >> 9) & 0x003)), + (line_h1 >> 8) & 1); + } else + arith_encode(se, (((line_h3 >> 8) & 0x380) | + ((line_h2 >> 12) & 0x07c) | + ((line_h1 >> 9) & 0x003)), + (line_h1 >> 8) & 1); #ifdef DEBUG - encoded_pixels++; + encoded_pixels++; #endif - /* statistics for adaptive template changes */ - if (!at_determined && j >= s->mx && j < hx-2) { - p = (line_h1 & 0x100) != 0; /* current pixel value */ - c[0] += ((line_h2 & 0x4000) != 0) == p; /* default position */ - assert((!(((line_h2 >> 6) ^ line_h1) & 0x100)) == - (((line_h2 & 0x4000) != 0) == p)); - for (t = 3; t <= s->mx && t <= j; t++) { - o = (j - t) - (j & ~7L); - a = (hp[o >> 3] >> (7 - (o & 7))) & 1; - assert(t > 23 || - (a == p) == !(((line_h1 >> t) ^ line_h1) & 0x100)); - c[t] += a == p; - } - for (; t <= s->mx; t++) { - c[t] += 0 == p; - } - ++c_all; - } - } while (++j & 7 && j < hx); - } /* if (s->options & JBG_LRLTWO) */ + /* statistics for adaptive template changes */ + if (!at_determined && j >= s->mx && j < hx-2) { + p = (line_h1 & 0x100) != 0; /* current pixel value */ + c[0] += ((line_h2 & 0x4000) != 0) == p; /* default position */ + assert((!(((line_h2 >> 6) ^ line_h1) & 0x100)) == + (((line_h2 & 0x4000) != 0) == p)); + for (t = 3; t <= s->mx && t <= j; t++) { + o = (j - t) - (j & ~7L); + a = (hp[o >> 3] >> (7 - (o & 7))) & 1; + assert(t > 23 || + (a == p) == !(((line_h1 >> t) ^ line_h1) & 0x100)); + c[t] += a == p; + } + for (; t <= s->mx; t++) { + c[t] += 0 == p; + } + ++c_all; + } + } while (++j & 7 && j < hx); + } /* if (s->options & JBG_LRLTWO) */ } /* for (j = ...) */ } /* for (i = ...) */ @@ -1180,101 +1180,101 @@ static void encode_sde(struct jbg_enc_state *s, /* check whether it is worth to perform an ATMOVE */ if (!at_determined && c_all > 2048) { - cmin = clmin = 0xffffffffL; - cmax = clmax = 0; - tmax = 0; - for (t = 3; t <= s->mx; t++) { - if (c[t] > cmax) cmax = c[t]; - if (c[t] < cmin) cmin = c[t]; - if (c[t] > c[tmax]) tmax = t; - } - clmin = (c[0] < cmin) ? c[0] : cmin; - clmax = (c[0] > cmax) ? c[0] : cmax; - if (c_all - cmax < (c_all >> 3) && - cmax - c[s->tx[plane]] > c_all - cmax && - cmax - c[s->tx[plane]] > (c_all >> 4) && - /* ^ T.82 said < here, fixed in Cor.1/25 */ - cmax - (c_all - c[s->tx[plane]]) > c_all - cmax && - cmax - (c_all - c[s->tx[plane]]) > (c_all >> 4) && - cmax - cmin > (c_all >> 2) && - (s->tx[plane] || clmax - clmin > (c_all >> 3))) { - /* we have decided to perform an ATMOVE */ - new_tx = tmax; - if (!(s->options & JBG_DELAY_AT)) { - new_tx_line = i; - s->tx[plane] = new_tx; - } + cmin = clmin = 0xffffffffL; + cmax = clmax = 0; + tmax = 0; + for (t = 3; t <= s->mx; t++) { + if (c[t] > cmax) cmax = c[t]; + if (c[t] < cmin) cmin = c[t]; + if (c[t] > c[tmax]) tmax = t; + } + clmin = (c[0] < cmin) ? c[0] : cmin; + clmax = (c[0] > cmax) ? c[0] : cmax; + if (c_all - cmax < (c_all >> 3) && + cmax - c[s->tx[plane]] > c_all - cmax && + cmax - c[s->tx[plane]] > (c_all >> 4) && + /* ^ T.82 said < here, fixed in Cor.1/25 */ + cmax - (c_all - c[s->tx[plane]]) > c_all - cmax && + cmax - (c_all - c[s->tx[plane]]) > (c_all >> 4) && + cmax - cmin > (c_all >> 2) && + (s->tx[plane] || clmax - clmin > (c_all >> 3))) { + /* we have decided to perform an ATMOVE */ + new_tx = tmax; + if (!(s->options & JBG_DELAY_AT)) { + new_tx_line = i; + s->tx[plane] = new_tx; + } #ifdef DEBUG - fprintf(stderr, "ATMOVE: line=%ld, tx=%d, c_all=%ld\n", - i, new_tx, c_all); + fprintf(stderr, "ATMOVE: line=%ld, tx=%d, c_all=%ld\n", + i, new_tx, c_all); #endif - } - at_determined = 1; + } + at_determined = 1; } if ((i >> 1) >= ll - 1 || (y >> 1) >= ly - 1) - lp1 = lp2; + lp1 = lp2; /* typical prediction */ if (s->options & JBG_TPDON && (i & 1) == 0) { - q1 = lp1; q2 = lp2; - p0 = p1 = hp; - if (i < hl - 1 && y < hy - 1) - p0 = hp + hbpl; - if (i > 1 || !reset) - line_l3 = (long)*(q2 - lbpl) << 8; - else - line_l3 = 0; - line_l2 = (long)*q2 << 8; - line_l1 = (long)*q1 << 8; - ltp = 1; - for (j = 0; j < lx && ltp; q1++, q2++) { - if (j < lbpl * 8 - 8) { - if (i > 1 || !reset) - line_l3 |= *(q2 - lbpl + 1); - line_l2 |= *(q2 + 1); - line_l1 |= *(q1 + 1); - } - do { - if ((j >> 2) < hbpl) { - line_h1 = *(p1++); - line_h0 = *(p0++); - } - do { - line_l3 <<= 1; - line_l2 <<= 1; - line_l1 <<= 1; - line_h1 <<= 2; - line_h0 <<= 2; - cx = (((line_l3 >> 15) & 0x007) | - ((line_l2 >> 12) & 0x038) | - ((line_l1 >> 9) & 0x1c0)); - if (cx == 0x000) - if ((line_h1 & 0x300) == 0 && (line_h0 & 0x300) == 0) - s->tp[j] = 0; - else { - ltp = 0; + q1 = lp1; q2 = lp2; + p0 = p1 = hp; + if (i < hl - 1 && y < hy - 1) + p0 = hp + hbpl; + if (i > 1 || !reset) + line_l3 = (long)*(q2 - lbpl) << 8; + else + line_l3 = 0; + line_l2 = (long)*q2 << 8; + line_l1 = (long)*q1 << 8; + ltp = 1; + for (j = 0; j < lx && ltp; q1++, q2++) { + if (j < lbpl * 8 - 8) { + if (i > 1 || !reset) + line_l3 |= *(q2 - lbpl + 1); + line_l2 |= *(q2 + 1); + line_l1 |= *(q1 + 1); + } + do { + if ((j >> 2) < hbpl) { + line_h1 = *(p1++); + line_h0 = *(p0++); + } + do { + line_l3 <<= 1; + line_l2 <<= 1; + line_l1 <<= 1; + line_h1 <<= 2; + line_h0 <<= 2; + cx = (((line_l3 >> 15) & 0x007) | + ((line_l2 >> 12) & 0x038) | + ((line_l1 >> 9) & 0x1c0)); + if (cx == 0x000) + if ((line_h1 & 0x300) == 0 && (line_h0 & 0x300) == 0) + s->tp[j] = 0; + else { + ltp = 0; #ifdef DEBUG - tp_exceptions++; + tp_exceptions++; #endif - } - else if (cx == 0x1ff) - if ((line_h1 & 0x300) == 0x300 && (line_h0 & 0x300) == 0x300) - s->tp[j] = 1; - else { - ltp = 0; + } + else if (cx == 0x1ff) + if ((line_h1 & 0x300) == 0x300 && (line_h0 & 0x300) == 0x300) + s->tp[j] = 1; + else { + ltp = 0; #ifdef DEBUG - tp_exceptions++; + tp_exceptions++; #endif - } - else - s->tp[j] = 2; - } while (++j & 3 && j < lx); - } while (j & 7 && j < lx); - } /* for (j = ...) */ - arith_encode(se, TPDCX, !ltp); + } + else + s->tp[j] = 2; + } while (++j & 3 && j < lx); + } while (j & 7 && j < lx); + } /* for (j = ...) */ + arith_encode(se, TPDCX, !ltp); #ifdef DEBUG - tp_lines += ltp; + tp_lines += ltp; #endif } @@ -1302,158 +1302,158 @@ static void encode_sde(struct jbg_enc_state *s, line_h1 = line_h2 = line_h3 = line_l1 = line_l2 = line_l3 = 0; if (i > 0 || !reset) line_h2 = (long)*(hp - hbpl) << 8; if (i > 1 || !reset) { - line_h3 = (long)*(hp - hbpl - hbpl) << 8; - line_l3 = (long)*(lp2 - lbpl) << 8; + line_h3 = (long)*(hp - hbpl - hbpl) << 8; + line_l3 = (long)*(lp2 - lbpl) << 8; } line_l2 = (long)*lp2 << 8; line_l1 = (long)*lp1 << 8; /* encode line */ for (j = 0; j < hx; lp1++, lp2++) { - if ((j >> 1) < lbpl * 8 - 8) { - if (i > 1 || !reset) - line_l3 |= *(lp2 - lbpl + 1); - line_l2 |= *(lp2 + 1); - line_l1 |= *(lp1 + 1); - } - do { /* ... while (j & 15 && j < hx) */ - - assert(hp - (s->lhp[s->highres[plane]][plane] + - (stripe * hl + i) * hbpl) - == (ptrdiff_t) j >> 3); - - assert(lp2 - (s->lhp[1-s->highres[plane]][plane] + - (stripe * ll + (i>>1)) * lbpl) - == (ptrdiff_t) j >> 4); - - line_h1 |= *hp; - if (j < hbpl * 8 - 8) { - if (i > 0 || !reset) { - line_h2 |= *(hp - hbpl + 1); - if (i > 1 || !reset) - line_h3 |= *(hp - hbpl - hbpl + 1); - } - } - do { /* ... while (j & 7 && j < hx) */ - line_l1 <<= 1; line_l2 <<= 1; line_l3 <<= 1; - if (ltp && s->tp[j >> 1] < 2) { - /* pixel are typical and have not to be encoded */ - line_h1 <<= 2; line_h2 <<= 2; line_h3 <<= 2; + if ((j >> 1) < lbpl * 8 - 8) { + if (i > 1 || !reset) + line_l3 |= *(lp2 - lbpl + 1); + line_l2 |= *(lp2 + 1); + line_l1 |= *(lp1 + 1); + } + do { /* ... while (j & 15 && j < hx) */ + + assert(hp - (s->lhp[s->highres[plane]][plane] + + (stripe * hl + i) * hbpl) + == (ptrdiff_t) j >> 3); + + assert(lp2 - (s->lhp[1-s->highres[plane]][plane] + + (stripe * ll + (i>>1)) * lbpl) + == (ptrdiff_t) j >> 4); + + line_h1 |= *hp; + if (j < hbpl * 8 - 8) { + if (i > 0 || !reset) { + line_h2 |= *(hp - hbpl + 1); + if (i > 1 || !reset) + line_h3 |= *(hp - hbpl - hbpl + 1); + } + } + do { /* ... while (j & 7 && j < hx) */ + line_l1 <<= 1; line_l2 <<= 1; line_l3 <<= 1; + if (ltp && s->tp[j >> 1] < 2) { + /* pixel are typical and have not to be encoded */ + line_h1 <<= 2; line_h2 <<= 2; line_h3 <<= 2; #ifdef DEBUG - do { - ++tp_pixels; - } while (++j & 1 && j < hx); + do { + ++tp_pixels; + } while (++j & 1 && j < hx); #else - j += 2; + j += 2; #endif - } else - do { /* ... while (++j & 1 && j < hx) */ - line_h1 <<= 1; line_h2 <<= 1; line_h3 <<= 1; - - /* deterministic prediction */ - if (s->options & JBG_DPON) { - if ((y & 1) == 0) { - if ((j & 1) == 0) { - /* phase 0 */ - if (s->dppriv[((line_l3 >> 16) & 0x003) | - ((line_l2 >> 14) & 0x00c) | - ((line_h1 >> 5) & 0x010) | - ((line_h2 >> 10) & 0x0e0)] < 2) { + } else + do { /* ... while (++j & 1 && j < hx) */ + line_h1 <<= 1; line_h2 <<= 1; line_h3 <<= 1; + + /* deterministic prediction */ + if (s->options & JBG_DPON) { + if ((y & 1) == 0) { + if ((j & 1) == 0) { + /* phase 0 */ + if (s->dppriv[((line_l3 >> 16) & 0x003) | + ((line_l2 >> 14) & 0x00c) | + ((line_h1 >> 5) & 0x010) | + ((line_h2 >> 10) & 0x0e0)] < 2) { #ifdef DEBUG - ++dp_pixels; + ++dp_pixels; #endif - continue; - } - } else { - /* phase 1 */ - if (s->dppriv[(((line_l3 >> 16) & 0x003) | - ((line_l2 >> 14) & 0x00c) | - ((line_h1 >> 5) & 0x030) | - ((line_h2 >> 10) & 0x1c0)) + 256] < 2) { + continue; + } + } else { + /* phase 1 */ + if (s->dppriv[(((line_l3 >> 16) & 0x003) | + ((line_l2 >> 14) & 0x00c) | + ((line_h1 >> 5) & 0x030) | + ((line_h2 >> 10) & 0x1c0)) + 256] < 2) { #ifdef DEBUG - ++dp_pixels; + ++dp_pixels; #endif - continue; - } - } - } else { - if ((j & 1) == 0) { - /* phase 2 */ - if (s->dppriv[(((line_l3 >> 16) & 0x003) | - ((line_l2 >> 14) & 0x00c) | - ((line_h1 >> 5) & 0x010) | - ((line_h2 >> 10) & 0x0e0) | - ((line_h3 >> 7) & 0x700)) + 768] < 2) { + continue; + } + } + } else { + if ((j & 1) == 0) { + /* phase 2 */ + if (s->dppriv[(((line_l3 >> 16) & 0x003) | + ((line_l2 >> 14) & 0x00c) | + ((line_h1 >> 5) & 0x010) | + ((line_h2 >> 10) & 0x0e0) | + ((line_h3 >> 7) & 0x700)) + 768] < 2) { #ifdef DEBUG - ++dp_pixels; + ++dp_pixels; #endif - continue; - } - } else { - /* phase 3 */ - if (s->dppriv[(((line_l3 >> 16) & 0x003) | - ((line_l2 >> 14) & 0x00c) | - ((line_h1 >> 5) & 0x030) | - ((line_h2 >> 10) & 0x1c0) | - ((line_h3 >> 7) & 0xe00)) + 2816] < 2) { + continue; + } + } else { + /* phase 3 */ + if (s->dppriv[(((line_l3 >> 16) & 0x003) | + ((line_l2 >> 14) & 0x00c) | + ((line_h1 >> 5) & 0x030) | + ((line_h2 >> 10) & 0x1c0) | + ((line_h3 >> 7) & 0xe00)) + 2816] < 2) { #ifdef DEBUG - ++dp_pixels; + ++dp_pixels; #endif - continue; - } - } - } - } - - /* determine context */ - if (s->tx[plane]) { - if ((unsigned) s->tx[plane] > j) - a = 0; - else { - o = (j - s->tx[plane]) - (j & ~7L); - a = (hp[o >> 3] >> (7 - (o & 7))) & 1; - a <<= 4; - } - assert(s->tx[plane] > 23 || - a == ((line_h1 >> (4 + s->tx[plane])) & 0x010)); - cx = (((line_h1 >> 9) & 0x003) | a | - ((line_h2 >> 13) & 0x00c) | - ((line_h3 >> 11) & 0x020)); - } else - cx = (((line_h1 >> 9) & 0x003) | - ((line_h2 >> 13) & 0x01c) | - ((line_h3 >> 11) & 0x020)); - if (j & 1) - cx |= (((line_l2 >> 9) & 0x0c0) | - ((line_l1 >> 7) & 0x300)) | (1UL << 10); - else - cx |= (((line_l2 >> 10) & 0x0c0) | - ((line_l1 >> 8) & 0x300)); - cx |= (y & 1) << 11; - - arith_encode(se, cx, (line_h1 >> 8) & 1); + continue; + } + } + } + } + + /* determine context */ + if (s->tx[plane]) { + if ((unsigned) s->tx[plane] > j) + a = 0; + else { + o = (j - s->tx[plane]) - (j & ~7L); + a = (hp[o >> 3] >> (7 - (o & 7))) & 1; + a <<= 4; + } + assert(s->tx[plane] > 23 || + a == ((line_h1 >> (4 + s->tx[plane])) & 0x010)); + cx = (((line_h1 >> 9) & 0x003) | a | + ((line_h2 >> 13) & 0x00c) | + ((line_h3 >> 11) & 0x020)); + } else + cx = (((line_h1 >> 9) & 0x003) | + ((line_h2 >> 13) & 0x01c) | + ((line_h3 >> 11) & 0x020)); + if (j & 1) + cx |= (((line_l2 >> 9) & 0x0c0) | + ((line_l1 >> 7) & 0x300)) | (1UL << 10); + else + cx |= (((line_l2 >> 10) & 0x0c0) | + ((line_l1 >> 8) & 0x300)); + cx |= (y & 1) << 11; + + arith_encode(se, cx, (line_h1 >> 8) & 1); #ifdef DEBUG - encoded_pixels++; + encoded_pixels++; #endif - /* statistics for adaptive template changes */ - if (!at_determined && j >= s->mx) { - c[0] += !(((line_h2 >> 6) ^ line_h1) & 0x100); - for (t = 3; t <= s->mx; t++) - c[t] += !(((line_h1 >> t) ^ line_h1) & 0x100); - ++c_all; - } - - } while (++j & 1 && j < hx); - } while (j & 7 && j < hx); - hp++; - } while (j & 15 && j < hx); + /* statistics for adaptive template changes */ + if (!at_determined && j >= s->mx) { + c[0] += !(((line_h2 >> 6) ^ line_h1) & 0x100); + for (t = 3; t <= s->mx; t++) + c[t] += !(((line_h1 >> t) ^ line_h1) & 0x100); + ++c_all; + } + + } while (++j & 1 && j < hx); + } while (j & 7 && j < hx); + hp++; + } while (j & 15 && j < hx); } /* for (j = ...) */ /* low resolution pixels are used twice */ if ((i & 1) == 0) { - lp1 -= lbpl; - lp2 -= lbpl; + lp1 -= lbpl; + lp2 -= lbpl; } } /* for (i = ...) */ @@ -1463,7 +1463,7 @@ static void encode_sde(struct jbg_enc_state *s, jbg_buf_remove_zeros(s->sde[stripe][layer][plane]); jbg_buf_write(MARKER_ESC, s->sde[stripe][layer][plane]); jbg_buf_write((s->options & JBG_SDRST) ? MARKER_SDRST : MARKER_SDNORM, - s->sde[stripe][layer][plane]); + s->sde[stripe][layer][plane]); if (s->options & JBG_SDRST) s->tx[plane] = 0; @@ -1499,8 +1499,8 @@ static void encode_sde(struct jbg_enc_state *s, #if 0 if (stripe == s->stripes - 1) fprintf(stderr, "tp_lines = %ld, tp_exceptions = %ld, tp_pixels = %ld, " - "dp_pixels = %ld, encoded_pixels = %ld\n", - tp_lines, tp_exceptions, tp_pixels, dp_pixels, encoded_pixels); + "dp_pixels = %ld, encoded_pixels = %ld\n", + tp_lines, tp_exceptions, tp_pixels, dp_pixels, encoded_pixels); #endif return; @@ -1511,7 +1511,7 @@ static void encode_sde(struct jbg_enc_state *s, * Create the next lower resolution version of an image */ static void resolution_reduction(struct jbg_enc_state *s, int plane, - int higher_layer) + int higher_layer) { unsigned long hl, ll, hx, hy, lx, ly, hbpl, lbpl; unsigned char *hp1, *hp2, *hp3, *lp; @@ -1542,7 +1542,7 @@ static void resolution_reduction(struct jbg_enc_state *s, int plane, #ifdef DEBUG fprintf(stderr, "resolution_reduction: plane = %d, higher_layer = %d\n", - plane, higher_layer); + plane, higher_layer); #endif /* @@ -1566,34 +1566,34 @@ static void resolution_reduction(struct jbg_enc_state *s, int plane, for (y = 0; y < ly;) { for (i = 0; i < ll && y < ly; i++, y++) { if (2*y + 1 >= hy) - hp1 = hp2; + hp1 = hp2; pix = 0; line_h1 = line_h2 = line_h3 = line_l2 = 0; for (j = 0; j < lbpl * 8; j += 8) { - *lp = 0; - if (i > 0 || (y > 0 && !(s->options & JBG_SDRST))) - line_l2 |= *(lp-lbpl); - for (k = 0; k < 8 && j + k < lx; k += 4) { - if (((j + k) >> 2) < hbpl) { - if (i > 0 || (y > 0 && !(s->options & JBG_SDRST))) - line_h3 |= *hp3; - ++hp3; - line_h2 |= *(hp2++); - line_h1 |= *(hp1++); - } - for (l = 0; l < 4 && j + k + l < lx; l++) { - line_h3 <<= 2; - line_h2 <<= 2; - line_h1 <<= 2; - line_l2 <<= 1; - pix = s->res_tab[((line_h1 >> 8) & 0x007) | - ((line_h2 >> 5) & 0x038) | - ((line_h3 >> 2) & 0x1c0) | - (pix << 9) | ((line_l2 << 2) & 0xc00)]; - *lp = (*lp << 1) | pix; - } - } - ++lp; + *lp = 0; + if (i > 0 || (y > 0 && !(s->options & JBG_SDRST))) + line_l2 |= *(lp-lbpl); + for (k = 0; k < 8 && j + k < lx; k += 4) { + if (((j + k) >> 2) < hbpl) { + if (i > 0 || (y > 0 && !(s->options & JBG_SDRST))) + line_h3 |= *hp3; + ++hp3; + line_h2 |= *(hp2++); + line_h1 |= *(hp1++); + } + for (l = 0; l < 4 && j + k + l < lx; l++) { + line_h3 <<= 2; + line_h2 <<= 2; + line_h1 <<= 2; + line_l2 <<= 1; + pix = s->res_tab[((line_h1 >> 8) & 0x007) | + ((line_h2 >> 5) & 0x038) | + ((line_h3 >> 2) & 0x1c0) | + (pix << 9) | ((line_l2 << 2) & 0xc00)]; + *lp = (*lp << 1) | pix; + } + } + ++lp; } *(lp - 1) <<= lbpl * 8 - lx; hp1 += hbpl; @@ -1635,7 +1635,7 @@ static void resolution_reduction(struct jbg_enc_state *s, int plane, * of doing it, but it minimizes the amount of temporary memory used. */ static void output_sde(struct jbg_enc_state *s, - unsigned long stripe, int layer, int plane) + unsigned long stripe, int layer, int plane) { int lfcl; /* lowest fully coded layer */ long i; @@ -1646,7 +1646,7 @@ static void output_sde(struct jbg_enc_state *s, if (s->sde[stripe][layer][plane] != SDE_TODO) { #ifdef DEBUG fprintf(stderr, "writing SDE: s/d/p = %2lu/%2d/%2d\n", - stripe, layer, plane); + stripe, layer, plane); #endif jbg_buf_output(&s->sde[stripe][layer][plane], s->data_out, s->file); s->sde[stripe][layer][plane] = SDE_DONE; @@ -1822,7 +1822,7 @@ void jbg_enc_out(struct jbg_enc_state *s) bpl = jbg_ceil_half(s->xd, 3); /* bytes per line */ for (plane = 0; plane < s->planes; plane++) for (y = 0; y < s->yd; y++) - s->lhp[0][plane][y * bpl + bpl - 1] &= ~((1 << (8 - (s->xd & 7))) - 1); + s->lhp[0][plane][y * bpl + bpl - 1] &= ~((1 << (8 - (s->xd & 7))) - 1); } /* prepare BIH */ @@ -1864,12 +1864,12 @@ void jbg_enc_out(struct jbg_enc_state *s) checked_malloc(s->stripes, sizeof(struct jbg_buf ***)); for (stripe = 0; stripe < s->stripes; stripe++) { s->sde[stripe] = (struct jbg_buf ***) - checked_malloc(s->d + 1, sizeof(struct jbg_buf **)); + checked_malloc(s->d + 1, sizeof(struct jbg_buf **)); for (layer = 0; layer < s->d + 1; layer++) { - s->sde[stripe][layer] = (struct jbg_buf **) - checked_malloc(s->planes, sizeof(struct jbg_buf *)); - for (plane = 0; plane < s->planes; plane++) - s->sde[stripe][layer][plane] = SDE_TODO; + s->sde[stripe][layer] = (struct jbg_buf **) + checked_malloc(s->planes, sizeof(struct jbg_buf *)); + for (plane = 0; plane < s->planes; plane++) + s->sde[stripe][layer][plane] = SDE_TODO; } } } @@ -1892,9 +1892,9 @@ void jbg_enc_out(struct jbg_enc_state *s) for (layer = s->dh; layer >= s->dl; layer--) { for (plane = 0; plane < s->planes; plane++) { if (layer > 0) - resolution_reduction(s, plane, layer); + resolution_reduction(s, plane, layer); for (stripe = 0; stripe < s->stripes; stripe++) - encode_sde(s, stripe, layer, plane); + encode_sde(s, stripe, layer, plane); s->highres[plane] ^= 1; } } @@ -1917,55 +1917,55 @@ void jbg_enc_out(struct jbg_enc_state *s) for (ii[1] = is[1]; ii[1] <= ie[1]; ii[1]++) for (ii[2] = is[2]; ii[2] <= ie[2]; ii[2]++) { - stripe = ii[iindex[order][STRIPE]]; - if (s->order & JBG_HITOLO) - layer = s->dh - (ii[iindex[order][LAYER]] - s->dl); - else - layer = ii[iindex[order][LAYER]]; - plane = ii[iindex[order][PLANE]]; - - /* output comment marker segment if there is any pending */ - if (s->comment) { - buf[0] = MARKER_ESC; - buf[1] = MARKER_COMMENT; - buf[2] = s->comment_len >> 24; - buf[3] = (s->comment_len >> 16) & 0xff; - buf[4] = (s->comment_len >> 8) & 0xff; - buf[5] = s->comment_len & 0xff; - s->data_out(buf, 6, s->file); - s->data_out(s->comment, s->comment_len, s->file); - s->comment = NULL; - } - - output_sde(s, stripe, layer, plane); - - /* - * When we generate a NEWLEN test case (s->yd1 > s->yd), output - * NEWLEN after last stripe if we have only a single - * resolution layer or plane (see ITU-T T.85 profile), otherwise - * output NEWLEN before last stripe. - */ - if (s->yd1 > s->yd && - (stripe == s->stripes - 1 || - (stripe == s->stripes - 2 && - (s->dl != s->dh || s->planes > 1)))) { - s->yd1 = s->yd; - yd = jbg_ceil_half(s->yd, s->d - s->dh); - buf[0] = MARKER_ESC; - buf[1] = MARKER_NEWLEN; - buf[2] = yd >> 24; - buf[3] = (yd >> 16) & 0xff; - buf[4] = (yd >> 8) & 0xff; - buf[5] = yd & 0xff; - s->data_out(buf, 6, s->file); + stripe = ii[iindex[order][STRIPE]]; + if (s->order & JBG_HITOLO) + layer = s->dh - (ii[iindex[order][LAYER]] - s->dl); + else + layer = ii[iindex[order][LAYER]]; + plane = ii[iindex[order][PLANE]]; + + /* output comment marker segment if there is any pending */ + if (s->comment) { + buf[0] = MARKER_ESC; + buf[1] = MARKER_COMMENT; + buf[2] = s->comment_len >> 24; + buf[3] = (s->comment_len >> 16) & 0xff; + buf[4] = (s->comment_len >> 8) & 0xff; + buf[5] = s->comment_len & 0xff; + s->data_out(buf, 6, s->file); + s->data_out(s->comment, s->comment_len, s->file); + s->comment = NULL; + } + + output_sde(s, stripe, layer, plane); + + /* + * When we generate a NEWLEN test case (s->yd1 > s->yd), output + * NEWLEN after last stripe if we have only a single + * resolution layer or plane (see ITU-T T.85 profile), otherwise + * output NEWLEN before last stripe. + */ + if (s->yd1 > s->yd && + (stripe == s->stripes - 1 || + (stripe == s->stripes - 2 && + (s->dl != s->dh || s->planes > 1)))) { + s->yd1 = s->yd; + yd = jbg_ceil_half(s->yd, s->d - s->dh); + buf[0] = MARKER_ESC; + buf[1] = MARKER_NEWLEN; + buf[2] = yd >> 24; + buf[3] = (yd >> 16) & 0xff; + buf[4] = (yd >> 8) & 0xff; + buf[5] = yd & 0xff; + s->data_out(buf, 6, s->file); #ifdef DEBUG - fprintf(stderr, "NEWLEN: yd=%lu\n", yd); + fprintf(stderr, "NEWLEN: yd=%lu\n", yd); #endif - if (stripe == s->stripes - 1) { - buf[1] = MARKER_SDNORM; - s->data_out(buf, 2, s->file); - } - } + if (stripe == s->stripes - 1) { + buf[1] = MARKER_SDNORM; + s->data_out(buf, 2, s->file); + } + } } @@ -1986,11 +1986,11 @@ void jbg_enc_free(struct jbg_enc_state *s) if (s->sde) { for (stripe = 0; stripe < s->stripes; stripe++) { for (layer = 0; layer < s->d + 1; layer++) { - for (plane = 0; plane < s->planes; plane++) - if (s->sde[stripe][layer][plane] != SDE_DONE && - s->sde[stripe][layer][plane] != SDE_TODO) - jbg_buf_free(&s->sde[stripe][layer][plane]); - checked_free(s->sde[stripe][layer]); + for (plane = 0; plane < s->planes; plane++) + if (s->sde[stripe][layer][plane] != SDE_DONE && + s->sde[stripe][layer][plane] != SDE_TODO) + jbg_buf_free(&s->sde[stripe][layer][plane]); + checked_free(s->sde[stripe][layer]); } checked_free(s->sde[stripe]); } @@ -2063,7 +2063,7 @@ void jbg_dec_init(struct jbg_dec_state *s) * ymax. */ void jbg_dec_maxsize(struct jbg_dec_state *s, unsigned long xmax, - unsigned long ymax) + unsigned long ymax) { if (xmax > 0) s->xmax = xmax; if (ymax > 0) s->ymax = ymax; @@ -2080,7 +2080,7 @@ void jbg_dec_maxsize(struct jbg_dec_state *s, unsigned long xmax, * this code cannot determine whether we have a marker segment). */ static size_t decode_pscd(struct jbg_dec_state *s, unsigned char *data, - size_t len) + size_t len) { unsigned long stripe; unsigned int layer, plane; @@ -2139,7 +2139,7 @@ static size_t decode_pscd(struct jbg_dec_state *s, unsigned char *data, #ifdef DEBUG if (s->x == 0 && s->i == 0 && s->pseudo) fprintf(stderr, "decode_pscd(%p, %p, %ld): s/d/p = %2lu/%2u/%2u\n", - (void *) s, (void *) data, (long) len, stripe, layer, plane); + (void *) s, (void *) data, (long) len, stripe, layer, plane); #endif if (s->x == 0 && s->i == 0 && @@ -2158,38 +2158,38 @@ static size_t decode_pscd(struct jbg_dec_state *s, unsigned char *data, /* adaptive template changes */ if (x == 0 && s->pseudo) - for (n = 0; n < s->at_moves; n++) - if (s->at_line[n] == s->i) { - s->tx[plane][layer - s->dl] = s->at_tx[n]; - s->ty[plane][layer - s->dl] = s->at_ty[n]; + for (n = 0; n < s->at_moves; n++) + if (s->at_line[n] == s->i) { + s->tx[plane][layer - s->dl] = s->at_tx[n]; + s->ty[plane][layer - s->dl] = s->at_ty[n]; #ifdef DEBUG - fprintf(stderr, "ATMOVE: line=%lu, tx=%d, ty=%d.\n", s->i, - s->tx[plane][layer - s->dl], s->ty[plane][layer - s->dl]); + fprintf(stderr, "ATMOVE: line=%lu, tx=%d, ty=%d.\n", s->i, + s->tx[plane][layer - s->dl], s->ty[plane][layer - s->dl]); #endif - } + } tx = s->tx[plane][layer - s->dl]; assert(tx >= 0); /* i.e., tx can safely be cast to unsigned */ /* typical prediction */ if (s->options & JBG_TPBON && s->pseudo) { - slntp = arith_decode(se, (s->options & JBG_LRLTWO) ? TPB2CX : TPB3CX); - if (slntp < 0) - goto leave; - s->lntp[plane][layer - s->dl] = - !(slntp ^ s->lntp[plane][layer - s->dl]); - if (!s->lntp[plane][layer - s->dl]) { - /* this line is 'typical' (i.e. identical to the previous one) */ - p1 = hp; - if (s->i == 0 && (stripe == 0 || s->reset[plane][layer - s->dl])) - while (p1 < hp + hbpl) *p1++ = 0; - else { - q1 = hp - hbpl; - while (q1 < hp) *p1++ = *q1++; - } - hp += hbpl; - continue; - } - /* this line is 'not typical' and has to be coded completely */ + slntp = arith_decode(se, (s->options & JBG_LRLTWO) ? TPB2CX : TPB3CX); + if (slntp < 0) + goto leave; + s->lntp[plane][layer - s->dl] = + !(slntp ^ s->lntp[plane][layer - s->dl]); + if (!s->lntp[plane][layer - s->dl]) { + /* this line is 'typical' (i.e. identical to the previous one) */ + p1 = hp; + if (s->i == 0 && (stripe == 0 || s->reset[plane][layer - s->dl])) + while (p1 < hp + hbpl) *p1++ = 0; + else { + q1 = hp - hbpl; + while (q1 < hp) *p1++ = *q1++; + } + hp += hbpl; + continue; + } + /* this line is 'not typical' and has to be coded completely */ } s->pseudo = 0; @@ -2203,11 +2203,11 @@ static size_t decode_pscd(struct jbg_dec_state *s, unsigned char *data, */ if (x == 0) { - line_h1 = line_h2 = line_h3 = 0; - if (s->i > 0 || (y > 0 && !s->reset[plane][layer - s->dl])) - line_h2 = (long)*(hp - hbpl) << 8; - if (s->i > 1 || (y > 1 && !s->reset[plane][layer - s->dl])) - line_h3 = (long)*(hp - hbpl - hbpl) << 8; + line_h1 = line_h2 = line_h3 = 0; + if (s->i > 0 || (y > 0 && !s->reset[plane][layer - s->dl])) + line_h2 = (long)*(hp - hbpl) << 8; + if (s->i > 1 || (y > 1 && !s->reset[plane][layer - s->dl])) + line_h3 = (long)*(hp - hbpl - hbpl) << 8; } /* @@ -2256,70 +2256,70 @@ static size_t decode_pscd(struct jbg_dec_state *s, unsigned char *data, /* decode line */ while (x < hx) { - if ((x & 7) == 0) { - if (x < hbpl * 8 - 8 && - (s->i > 0 || (y > 0 && !s->reset[plane][layer - s->dl]))) { - line_h2 |= *(hp - hbpl + 1); - if (s->i > 1 || (y > 1 && !s->reset[plane][layer - s->dl])) - line_h3 |= *(hp - hbpl - hbpl + 1); - } - } - if (s->options & JBG_LRLTWO) { - /* two line template */ - do { - if (tx) { - if ((unsigned) tx > x) - a = 0; - else if (tx < 8) - a = ((line_h1 >> (tx - 5)) & 0x010); - else { - o = (x - tx) - (x & ~7L); - a = (hp[o >> 3] >> (7 - (o & 7))) & 1; - a <<= 4; - } - assert(tx > 31 || - a == ((line_h1 >> (tx - 5)) & 0x010)); - pix = arith_decode(se, (((line_h2 >> 9) & 0x3e0) | a | - (line_h1 & 0x00f))); - } else - pix = arith_decode(se, (((line_h2 >> 9) & 0x3f0) | - (line_h1 & 0x00f))); - if (pix < 0) - goto leave; - line_h1 = (line_h1 << 1) | pix; - line_h2 <<= 1; - } while ((++x & 7) && x < hx); - } else { - /* three line template */ - do { - if (tx) { - if ((unsigned) tx > x) - a = 0; - else if (tx < 8) - a = ((line_h1 >> (tx - 3)) & 0x004); - else { - o = (x - tx) - (x & ~7L); - a = (hp[o >> 3] >> (7 - (o & 7))) & 1; - a <<= 2; - } - assert(tx > 31 || - a == ((line_h1 >> (tx - 3)) & 0x004)); - pix = arith_decode(se, (((line_h3 >> 7) & 0x380) | - ((line_h2 >> 11) & 0x078) | a | - (line_h1 & 0x003))); - } else - pix = arith_decode(se, (((line_h3 >> 7) & 0x380) | - ((line_h2 >> 11) & 0x07c) | - (line_h1 & 0x003))); - if (pix < 0) - goto leave; - - line_h1 = (line_h1 << 1) | pix; - line_h2 <<= 1; - line_h3 <<= 1; - } while ((++x & 7) && x < hx); - } /* if (s->options & JBG_LRLTWO) */ - *hp++ = line_h1; + if ((x & 7) == 0) { + if (x < hbpl * 8 - 8 && + (s->i > 0 || (y > 0 && !s->reset[plane][layer - s->dl]))) { + line_h2 |= *(hp - hbpl + 1); + if (s->i > 1 || (y > 1 && !s->reset[plane][layer - s->dl])) + line_h3 |= *(hp - hbpl - hbpl + 1); + } + } + if (s->options & JBG_LRLTWO) { + /* two line template */ + do { + if (tx) { + if ((unsigned) tx > x) + a = 0; + else if (tx < 8) + a = ((line_h1 >> (tx - 5)) & 0x010); + else { + o = (x - tx) - (x & ~7L); + a = (hp[o >> 3] >> (7 - (o & 7))) & 1; + a <<= 4; + } + assert(tx > 31 || + a == ((line_h1 >> (tx - 5)) & 0x010)); + pix = arith_decode(se, (((line_h2 >> 9) & 0x3e0) | a | + (line_h1 & 0x00f))); + } else + pix = arith_decode(se, (((line_h2 >> 9) & 0x3f0) | + (line_h1 & 0x00f))); + if (pix < 0) + goto leave; + line_h1 = (line_h1 << 1) | pix; + line_h2 <<= 1; + } while ((++x & 7) && x < hx); + } else { + /* three line template */ + do { + if (tx) { + if ((unsigned) tx > x) + a = 0; + else if (tx < 8) + a = ((line_h1 >> (tx - 3)) & 0x004); + else { + o = (x - tx) - (x & ~7L); + a = (hp[o >> 3] >> (7 - (o & 7))) & 1; + a <<= 2; + } + assert(tx > 31 || + a == ((line_h1 >> (tx - 3)) & 0x004)); + pix = arith_decode(se, (((line_h3 >> 7) & 0x380) | + ((line_h2 >> 11) & 0x078) | a | + (line_h1 & 0x003))); + } else + pix = arith_decode(se, (((line_h3 >> 7) & 0x380) | + ((line_h2 >> 11) & 0x07c) | + (line_h1 & 0x003))); + if (pix < 0) + goto leave; + + line_h1 = (line_h1 << 1) | pix; + line_h2 <<= 1; + line_h3 <<= 1; + } while ((++x & 7) && x < hx); + } /* if (s->options & JBG_LRLTWO) */ + *hp++ = line_h1; } /* while */ *(hp - 1) <<= hbpl * 8 - hx; x = 0; @@ -2336,25 +2336,25 @@ static size_t decode_pscd(struct jbg_dec_state *s, unsigned char *data, /* adaptive template changes */ if (x == 0) - for (n = 0; n < s->at_moves; n++) - if (s->at_line[n] == s->i) { - s->tx[plane][layer - s->dl] = s->at_tx[n]; - s->ty[plane][layer - s->dl] = s->at_ty[n]; + for (n = 0; n < s->at_moves; n++) + if (s->at_line[n] == s->i) { + s->tx[plane][layer - s->dl] = s->at_tx[n]; + s->ty[plane][layer - s->dl] = s->at_ty[n]; #ifdef DEBUG - fprintf(stderr, "ATMOVE: line=%lu, tx=%d, ty=%d.\n", s->i, - s->tx[plane][layer - s->dl], s->ty[plane][layer - s->dl]); + fprintf(stderr, "ATMOVE: line=%lu, tx=%d, ty=%d.\n", s->i, + s->tx[plane][layer - s->dl], s->ty[plane][layer - s->dl]); #endif - } + } tx = s->tx[plane][layer - s->dl]; /* handle lower border of low-resolution image */ if ((s->i >> 1) >= ll - 1 || (y >> 1) >= ly - 1) - lp1 = lp2; + lp1 = lp2; /* typical prediction */ if ((s->options & JBG_TPDON) && s->pseudo) { - if ((s->lntp[plane][layer - s->dl] = arith_decode(se, TPDCX)) < 0) - goto leave; + if ((s->lntp[plane][layer - s->dl] = arith_decode(se, TPDCX)) < 0) + goto leave; } s->pseudo = 0; @@ -2379,135 +2379,135 @@ static size_t decode_pscd(struct jbg_dec_state *s, unsigned char *data, if (x == 0) { - line_h1 = line_h2 = line_h3 = line_l1 = line_l2 = line_l3 = 0; - if (s->i > 0 || (y > 0 && !s->reset[plane][layer - s->dl])) { - line_h2 = (long)*(hp - hbpl) << 8; - if (s->i > 1 || (y > 1 && !s->reset[plane][layer - s->dl])) - line_h3 = (long)*(hp - hbpl - hbpl) << 8; - } - if (s->i > 1 || (y > 1 && !s->reset[plane][layer-s->dl])) - line_l3 = (long)*(lp2 - lbpl) << 8; - line_l2 = (long)*lp2 << 8; - line_l1 = (long)*lp1 << 8; + line_h1 = line_h2 = line_h3 = line_l1 = line_l2 = line_l3 = 0; + if (s->i > 0 || (y > 0 && !s->reset[plane][layer - s->dl])) { + line_h2 = (long)*(hp - hbpl) << 8; + if (s->i > 1 || (y > 1 && !s->reset[plane][layer - s->dl])) + line_h3 = (long)*(hp - hbpl - hbpl) << 8; + } + if (s->i > 1 || (y > 1 && !s->reset[plane][layer-s->dl])) + line_l3 = (long)*(lp2 - lbpl) << 8; + line_l2 = (long)*lp2 << 8; + line_l1 = (long)*lp1 << 8; } /* decode line */ while (x < hx) { - if ((x & 15) == 0) - if ((x >> 1) < lbpl * 8 - 8) { - line_l1 |= *(lp1 + 1); - line_l2 |= *(lp2 + 1); - if (s->i > 1 || - (y > 1 && !s->reset[plane][layer - s->dl])) - line_l3 |= *(lp2 - lbpl + 1); - } - do { - - assert(hp - (s->lhp[ layer &1][plane] + (stripe * hl + s->i) - * hbpl) == (ptrdiff_t) x >> 3); - assert(lp2 - (s->lhp[(layer-1) &1][plane] + (stripe * ll + (s->i>>1)) - * lbpl) == (ptrdiff_t) x >> 4); - - if ((x & 7) == 0) - if (x < hbpl * 8 - 8) { - if (s->i > 0 || (y > 0 && !s->reset[plane][layer - s->dl])) { - line_h2 |= *(hp + 1 - hbpl); - if (s->i > 1 || (y > 1 && !s->reset[plane][layer - s->dl])) - line_h3 |= *(hp + 1 - hbpl - hbpl); - } - } - do { - if (!s->lntp[plane][layer - s->dl]) + if ((x & 15) == 0) + if ((x >> 1) < lbpl * 8 - 8) { + line_l1 |= *(lp1 + 1); + line_l2 |= *(lp2 + 1); + if (s->i > 1 || + (y > 1 && !s->reset[plane][layer - s->dl])) + line_l3 |= *(lp2 - lbpl + 1); + } + do { + + assert(hp - (s->lhp[ layer &1][plane] + (stripe * hl + s->i) + * hbpl) == (ptrdiff_t) x >> 3); + assert(lp2 - (s->lhp[(layer-1) &1][plane] + (stripe * ll + (s->i>>1)) + * lbpl) == (ptrdiff_t) x >> 4); + + if ((x & 7) == 0) + if (x < hbpl * 8 - 8) { + if (s->i > 0 || (y > 0 && !s->reset[plane][layer - s->dl])) { + line_h2 |= *(hp + 1 - hbpl); + if (s->i > 1 || (y > 1 && !s->reset[plane][layer - s->dl])) + line_h3 |= *(hp + 1 - hbpl - hbpl); + } + } + do { + if (!s->lntp[plane][layer - s->dl]) cx = (((line_l3 >> 14) & 0x007) | ((line_l2 >> 11) & 0x038) | ((line_l1 >> 8) & 0x1c0)); - if (!s->lntp[plane][layer - s->dl] && - (cx == 0x000 || cx == 0x1ff)) { - /* pixels are typical and have not to be decoded */ - do { - line_h1 = (line_h1 << 1) | (cx & 1); - } while ((++x & 1) && x < hx); - line_h2 <<= 2; line_h3 <<= 2; - } else - do { - - /* deterministic prediction */ - if (s->options & JBG_DPON) - if ((y & 1) == 0) - if ((x & 1) == 0) - /* phase 0 */ - pix = s->dppriv[((line_l3 >> 15) & 0x003) | - ((line_l2 >> 13) & 0x00c) | - ((line_h1 << 4) & 0x010) | - ((line_h2 >> 9) & 0x0e0)]; - else - /* phase 1 */ - pix = s->dppriv[(((line_l3 >> 15) & 0x003) | - ((line_l2 >> 13) & 0x00c) | - ((line_h1 << 4) & 0x030) | - ((line_h2 >> 9) & 0x1c0)) + 256]; - else - if ((x & 1) == 0) - /* phase 2 */ - pix = s->dppriv[(((line_l3 >> 15) & 0x003) | - ((line_l2 >> 13) & 0x00c) | - ((line_h1 << 4) & 0x010) | - ((line_h2 >> 9) & 0x0e0) | - ((line_h3 >> 6) & 0x700)) + 768]; - else - /* phase 3 */ - pix = s->dppriv[(((line_l3 >> 15) & 0x003) | - ((line_l2 >> 13) & 0x00c) | - ((line_h1 << 4) & 0x030) | - ((line_h2 >> 9) & 0x1c0) | - ((line_h3 >> 6) & 0xe00)) + 2816]; - else - pix = 2; - - if (pix & 2) { - if (tx) - cx = ((line_h1 & 0x003) | - (((line_h1 << 2) >> (tx - 3)) & 0x010) | - ((line_h2 >> 12) & 0x00c) | - ((line_h3 >> 10) & 0x020)); - else - cx = ((line_h1 & 0x003) | - ((line_h2 >> 12) & 0x01c) | - ((line_h3 >> 10) & 0x020)); - if (x & 1) - cx |= (((line_l2 >> 8) & 0x0c0) | - ((line_l1 >> 6) & 0x300)) | (1UL << 10); - else - cx |= (((line_l2 >> 9) & 0x0c0) | - ((line_l1 >> 7) & 0x300)); - cx |= (y & 1) << 11; - - pix = arith_decode(se, cx); - if (pix < 0) - goto leave; - } - - line_h1 = (line_h1 << 1) | pix; - line_h2 <<= 1; - line_h3 <<= 1; - - } while ((++x & 1) && x < hx); - line_l1 <<= 1; line_l2 <<= 1; line_l3 <<= 1; - } while ((x & 7) && x < hx); - *hp++ = line_h1; - } while ((x & 15) && x < hx); - ++lp1; - ++lp2; + if (!s->lntp[plane][layer - s->dl] && + (cx == 0x000 || cx == 0x1ff)) { + /* pixels are typical and have not to be decoded */ + do { + line_h1 = (line_h1 << 1) | (cx & 1); + } while ((++x & 1) && x < hx); + line_h2 <<= 2; line_h3 <<= 2; + } else + do { + + /* deterministic prediction */ + if (s->options & JBG_DPON) + if ((y & 1) == 0) + if ((x & 1) == 0) + /* phase 0 */ + pix = s->dppriv[((line_l3 >> 15) & 0x003) | + ((line_l2 >> 13) & 0x00c) | + ((line_h1 << 4) & 0x010) | + ((line_h2 >> 9) & 0x0e0)]; + else + /* phase 1 */ + pix = s->dppriv[(((line_l3 >> 15) & 0x003) | + ((line_l2 >> 13) & 0x00c) | + ((line_h1 << 4) & 0x030) | + ((line_h2 >> 9) & 0x1c0)) + 256]; + else + if ((x & 1) == 0) + /* phase 2 */ + pix = s->dppriv[(((line_l3 >> 15) & 0x003) | + ((line_l2 >> 13) & 0x00c) | + ((line_h1 << 4) & 0x010) | + ((line_h2 >> 9) & 0x0e0) | + ((line_h3 >> 6) & 0x700)) + 768]; + else + /* phase 3 */ + pix = s->dppriv[(((line_l3 >> 15) & 0x003) | + ((line_l2 >> 13) & 0x00c) | + ((line_h1 << 4) & 0x030) | + ((line_h2 >> 9) & 0x1c0) | + ((line_h3 >> 6) & 0xe00)) + 2816]; + else + pix = 2; + + if (pix & 2) { + if (tx) + cx = ((line_h1 & 0x003) | + (((line_h1 << 2) >> (tx - 3)) & 0x010) | + ((line_h2 >> 12) & 0x00c) | + ((line_h3 >> 10) & 0x020)); + else + cx = ((line_h1 & 0x003) | + ((line_h2 >> 12) & 0x01c) | + ((line_h3 >> 10) & 0x020)); + if (x & 1) + cx |= (((line_l2 >> 8) & 0x0c0) | + ((line_l1 >> 6) & 0x300)) | (1UL << 10); + else + cx |= (((line_l2 >> 9) & 0x0c0) | + ((line_l1 >> 7) & 0x300)); + cx |= (y & 1) << 11; + + pix = arith_decode(se, cx); + if (pix < 0) + goto leave; + } + + line_h1 = (line_h1 << 1) | pix; + line_h2 <<= 1; + line_h3 <<= 1; + + } while ((++x & 1) && x < hx); + line_l1 <<= 1; line_l2 <<= 1; line_l3 <<= 1; + } while ((x & 7) && x < hx); + *hp++ = line_h1; + } while ((x & 15) && x < hx); + ++lp1; + ++lp2; } /* while */ x = 0; *(hp - 1) <<= hbpl * 8 - hx; if ((s->i & 1) == 0) { - /* low resolution pixels are used twice */ - lp1 -= lbpl; - lp2 -= lbpl; + /* low resolution pixels are used twice */ + lp1 -= lbpl; + lp2 -= lbpl; } else - s->pseudo = 1; + s->pseudo = 1; } /* for (i = ...) */ @@ -2563,7 +2563,7 @@ static size_t decode_pscd(struct jbg_dec_state *s, unsigned char *data, * information by identifying which test exactly has failed.) */ int jbg_dec_in(struct jbg_dec_state *s, unsigned char *data, size_t len, - size_t *cnt) + size_t *cnt) { int i, j, required_length; unsigned long x, y; @@ -2595,18 +2595,18 @@ int jbg_dec_in(struct jbg_dec_state *s, unsigned char *data, size_t len, s->planes = s->buffer[2]; else if (s->planes != s->buffer[2]) - return JBG_ENOCONT | 2; + return JBG_ENOCONT | 2; x = (((long) s->buffer[ 4] << 24) | ((long) s->buffer[ 5] << 16) | - ((long) s->buffer[ 6] << 8) | (long) s->buffer[ 7]); + ((long) s->buffer[ 6] << 8) | (long) s->buffer[ 7]); y = (((long) s->buffer[ 8] << 24) | ((long) s->buffer[ 9] << 16) | - ((long) s->buffer[10] << 8) | (long) s->buffer[11]); + ((long) s->buffer[10] << 8) | (long) s->buffer[11]); if (s->dl != 0 && ((s->xd << (s->d - s->dl + 1)) != x && - (s->yd << (s->d - s->dl + 1)) != y)) + (s->yd << (s->d - s->dl + 1)) != y)) return JBG_ENOCONT | 3; s->xd = x; s->yd = y; s->l0 = (((long) s->buffer[12] << 24) | ((long) s->buffer[13] << 16) | - ((long) s->buffer[14] << 8) | (long) s->buffer[15]); + ((long) s->buffer[14] << 8) | (long) s->buffer[15]); /* ITU-T T.85 trick not directly implemented by decoder; for full * T.85 compatibility with respect to all NEWLEN marker scenarios, * preprocess BIE with jbg_newlen() before passing it to the decoder, @@ -2647,51 +2647,51 @@ int jbg_dec_in(struct jbg_dec_state *s, unsigned char *data, size_t len, s->ii[iindex[s->order & 7][PLANE]] = 0; if (s->dl == 0) { s->s = (struct jbg_ardec_state **) - checked_malloc(s->planes, sizeof(struct jbg_ardec_state *)); + checked_malloc(s->planes, sizeof(struct jbg_ardec_state *)); s->tx = (int **) checked_malloc(s->planes, sizeof(int *)); s->ty = (int **) checked_malloc(s->planes, sizeof(int *)); s->reset = (int **) checked_malloc(s->planes, sizeof(int *)); s->lntp = (int **) checked_malloc(s->planes, sizeof(int *)); s->lhp[0] = (unsigned char **) - checked_malloc(s->planes, sizeof(unsigned char *)); + checked_malloc(s->planes, sizeof(unsigned char *)); s->lhp[1] = (unsigned char **) - checked_malloc(s->planes, sizeof(unsigned char *)); + checked_malloc(s->planes, sizeof(unsigned char *)); for (i = 0; i < s->planes; i++) { - s->s[i] = (struct jbg_ardec_state *) - checked_malloc(s->d - s->dl + 1, sizeof(struct jbg_ardec_state)); - s->tx[i] = (int *) checked_malloc(s->d - s->dl + 1, sizeof(int)); - s->ty[i] = (int *) checked_malloc(s->d - s->dl + 1, sizeof(int)); - s->reset[i] = (int *) checked_malloc(s->d - s->dl + 1, sizeof(int)); - s->lntp[i] = (int *) checked_malloc(s->d - s->dl + 1, sizeof(int)); - s->lhp[ s->d & 1][i] = (unsigned char *) - checked_malloc(s->yd, jbg_ceil_half(s->xd, 3)); - s->lhp[(s->d-1) & 1][i] = (unsigned char *) - checked_malloc(jbg_ceil_half(s->yd, 1), jbg_ceil_half(s->xd, 1+3)); + s->s[i] = (struct jbg_ardec_state *) + checked_malloc(s->d - s->dl + 1, sizeof(struct jbg_ardec_state)); + s->tx[i] = (int *) checked_malloc(s->d - s->dl + 1, sizeof(int)); + s->ty[i] = (int *) checked_malloc(s->d - s->dl + 1, sizeof(int)); + s->reset[i] = (int *) checked_malloc(s->d - s->dl + 1, sizeof(int)); + s->lntp[i] = (int *) checked_malloc(s->d - s->dl + 1, sizeof(int)); + s->lhp[ s->d & 1][i] = (unsigned char *) + checked_malloc(s->yd, jbg_ceil_half(s->xd, 3)); + s->lhp[(s->d-1) & 1][i] = (unsigned char *) + checked_malloc(jbg_ceil_half(s->yd, 1), jbg_ceil_half(s->xd, 1+3)); } } else { for (i = 0; i < s->planes; i++) { - s->s[i] = (struct jbg_ardec_state *) - checked_realloc(s->s[i], s->d - s->dl + 1, - sizeof(struct jbg_ardec_state)); - s->tx[i] = (int *) checked_realloc(s->tx[i], - s->d - s->dl + 1, sizeof(int)); - s->ty[i] = (int *) checked_realloc(s->ty[i], - s->d - s->dl + 1, sizeof(int)); - s->reset[i] = (int *) checked_realloc(s->reset[i], - s->d - s->dl + 1, sizeof(int)); - s->lntp[i] = (int *) checked_realloc(s->lntp[i], - s->d - s->dl + 1, sizeof(int)); - s->lhp[ s->d & 1][i] = (unsigned char *) - checked_realloc(s->lhp[ s->d & 1][i], - s->yd, jbg_ceil_half(s->xd, 3)); - s->lhp[(s->d-1) & 1][i] = (unsigned char *) - checked_realloc(s->lhp[(s->d-1) & 1][i], - jbg_ceil_half(s->yd, 1), jbg_ceil_half(s->xd, 1+3)); + s->s[i] = (struct jbg_ardec_state *) + checked_realloc(s->s[i], s->d - s->dl + 1, + sizeof(struct jbg_ardec_state)); + s->tx[i] = (int *) checked_realloc(s->tx[i], + s->d - s->dl + 1, sizeof(int)); + s->ty[i] = (int *) checked_realloc(s->ty[i], + s->d - s->dl + 1, sizeof(int)); + s->reset[i] = (int *) checked_realloc(s->reset[i], + s->d - s->dl + 1, sizeof(int)); + s->lntp[i] = (int *) checked_realloc(s->lntp[i], + s->d - s->dl + 1, sizeof(int)); + s->lhp[ s->d & 1][i] = (unsigned char *) + checked_realloc(s->lhp[ s->d & 1][i], + s->yd, jbg_ceil_half(s->xd, 3)); + s->lhp[(s->d-1) & 1][i] = (unsigned char *) + checked_realloc(s->lhp[(s->d-1) & 1][i], + jbg_ceil_half(s->yd, 1), jbg_ceil_half(s->xd, 1+3)); } } for (i = 0; i < s->planes; i++) for (j = 0; j <= s->d - s->dl; j++) - arith_decode_init(s->s[i] + j, 0); + arith_decode_init(s->s[i] + j, 0); if (s->dl == 0 || (s->options & JBG_DPON && !(s->options & JBG_DPPRIV))) s->dppriv = jbg_dptable; s->comment_skip = 0; @@ -2730,11 +2730,11 @@ int jbg_dec_in(struct jbg_dec_state *s, unsigned char *data, size_t len, /* skip COMMENT contents */ if (s->comment_skip) { if (s->comment_skip <= len - *cnt) { - *cnt += s->comment_skip; - s->comment_skip = 0; + *cnt += s->comment_skip; + s->comment_skip = 0; } else { - s->comment_skip -= len - *cnt; - *cnt = len; + s->comment_skip -= len - *cnt; + *cnt = len; } continue; } @@ -2743,7 +2743,7 @@ int jbg_dec_in(struct jbg_dec_state *s, unsigned char *data, size_t len, if (s->buf_len > 0) { assert(s->buffer[0] == MARKER_ESC); while (s->buf_len < 2 && *cnt < len) - s->buffer[s->buf_len++] = data[(*cnt)++]; + s->buffer[s->buf_len++] = data[(*cnt)++]; if (s->buf_len < 2) continue; switch (s->buffer[1]) { case MARKER_COMMENT: required_length = 6; break; @@ -2753,120 +2753,120 @@ int jbg_dec_in(struct jbg_dec_state *s, unsigned char *data, size_t len, case MARKER_SDNORM: case MARKER_SDRST: required_length = 2; break; case MARKER_STUFF: - /* forward stuffed 0xff to arithmetic decoder */ - s->buf_len = 0; - decode_pscd(s, s->buffer, 2); - continue; + /* forward stuffed 0xff to arithmetic decoder */ + s->buf_len = 0; + decode_pscd(s, s->buffer, 2); + continue; default: - return JBG_EMARKER; + return JBG_EMARKER; } while (s->buf_len < required_length && *cnt < len) - s->buffer[s->buf_len++] = data[(*cnt)++]; + s->buffer[s->buf_len++] = data[(*cnt)++]; if (s->buf_len < required_length) continue; /* now the buffer is filled with exactly one marker segment */ switch (s->buffer[1]) { case MARKER_COMMENT: - s->comment_skip = - (((long) s->buffer[2] << 24) | ((long) s->buffer[3] << 16) | - ((long) s->buffer[4] << 8) | (long) s->buffer[5]); - break; + s->comment_skip = + (((long) s->buffer[2] << 24) | ((long) s->buffer[3] << 16) | + ((long) s->buffer[4] << 8) | (long) s->buffer[5]); + break; case MARKER_ATMOVE: - if (s->at_moves < JBG_ATMOVES_MAX) { - s->at_line[s->at_moves] = - (((long) s->buffer[2] << 24) | ((long) s->buffer[3] << 16) | - ((long) s->buffer[4] << 8) | (long) s->buffer[5]); - s->at_tx[s->at_moves] = (signed char) s->buffer[6]; - s->at_ty[s->at_moves] = s->buffer[7]; - if (s->at_tx[s->at_moves] < - (int) s->mx || - s->at_tx[s->at_moves] > (int) s->mx || - s->at_ty[s->at_moves] > (int) s->my || - (s->at_ty[s->at_moves] == 0 && s->at_tx[s->at_moves] < 0)) - return JBG_EINVAL | 11; - if (s->at_ty[s->at_moves] != 0) - return JBG_EIMPL | 6; - s->at_moves++; - } else - return JBG_EIMPL | 7; /* more than JBG_ATMOVES_MAX ATMOVES */ - break; + if (s->at_moves < JBG_ATMOVES_MAX) { + s->at_line[s->at_moves] = + (((long) s->buffer[2] << 24) | ((long) s->buffer[3] << 16) | + ((long) s->buffer[4] << 8) | (long) s->buffer[5]); + s->at_tx[s->at_moves] = (signed char) s->buffer[6]; + s->at_ty[s->at_moves] = s->buffer[7]; + if (s->at_tx[s->at_moves] < - (int) s->mx || + s->at_tx[s->at_moves] > (int) s->mx || + s->at_ty[s->at_moves] > (int) s->my || + (s->at_ty[s->at_moves] == 0 && s->at_tx[s->at_moves] < 0)) + return JBG_EINVAL | 11; + if (s->at_ty[s->at_moves] != 0) + return JBG_EIMPL | 6; + s->at_moves++; + } else + return JBG_EIMPL | 7; /* more than JBG_ATMOVES_MAX ATMOVES */ + break; case MARKER_NEWLEN: - y = (((long) s->buffer[2] << 24) | ((long) s->buffer[3] << 16) | - ((long) s->buffer[4] << 8) | (long) s->buffer[5]); - if (y > s->yd) return JBG_EINVAL | 12; - if (!(s->options & JBG_VLENGTH)) return JBG_EINVAL | 13; - s->yd = y; - /* calculate again number of stripes that will be required */ - s->stripes = jbg_stripes(s->l0, s->yd, s->d); - break; + y = (((long) s->buffer[2] << 24) | ((long) s->buffer[3] << 16) | + ((long) s->buffer[4] << 8) | (long) s->buffer[5]); + if (y > s->yd) return JBG_EINVAL | 12; + if (!(s->options & JBG_VLENGTH)) return JBG_EINVAL | 13; + s->yd = y; + /* calculate again number of stripes that will be required */ + s->stripes = jbg_stripes(s->l0, s->yd, s->d); + break; case MARKER_ABORT: - return JBG_EABORT; + return JBG_EABORT; case MARKER_SDNORM: case MARKER_SDRST: - /* decode final pixels based on trailing zero bytes */ - decode_pscd(s, s->buffer, 2); - - arith_decode_init(s->s[s->ii[iindex[s->order & 7][PLANE]]] + - s->ii[iindex[s->order & 7][LAYER]] - s->dl, - s->ii[iindex[s->order & 7][STRIPE]] != s->stripes - 1 - && s->buffer[1] != MARKER_SDRST); - - s->reset[s->ii[iindex[s->order & 7][PLANE]]] - [s->ii[iindex[s->order & 7][LAYER]] - s->dl] = - (s->buffer[1] == MARKER_SDRST); - - /* prepare for next SDE */ - s->x = 0; - s->i = 0; - s->pseudo = 1; - s->at_moves = 0; - - /* increment layer/stripe/plane loop variables */ - /* start and end value for each loop: */ - is[iindex[s->order & 7][STRIPE]] = 0; - ie[iindex[s->order & 7][STRIPE]] = s->stripes - 1; - is[iindex[s->order & 7][LAYER]] = s->dl; - ie[iindex[s->order & 7][LAYER]] = s->d; - is[iindex[s->order & 7][PLANE]] = 0; - ie[iindex[s->order & 7][PLANE]] = s->planes - 1; - i = 2; /* index to innermost loop */ - do { - j = 0; /* carry flag */ - if (++s->ii[i] > ie[i]) { - /* handling overflow of loop variable */ - j = 1; - if (i > 0) - s->ii[i] = is[i]; - } - } while (--i >= 0 && j); - - s->buf_len = 0; - - /* check whether this have been all SDEs */ - if (j) { + /* decode final pixels based on trailing zero bytes */ + decode_pscd(s, s->buffer, 2); + + arith_decode_init(s->s[s->ii[iindex[s->order & 7][PLANE]]] + + s->ii[iindex[s->order & 7][LAYER]] - s->dl, + s->ii[iindex[s->order & 7][STRIPE]] != s->stripes - 1 + && s->buffer[1] != MARKER_SDRST); + + s->reset[s->ii[iindex[s->order & 7][PLANE]]] + [s->ii[iindex[s->order & 7][LAYER]] - s->dl] = + (s->buffer[1] == MARKER_SDRST); + + /* prepare for next SDE */ + s->x = 0; + s->i = 0; + s->pseudo = 1; + s->at_moves = 0; + + /* increment layer/stripe/plane loop variables */ + /* start and end value for each loop: */ + is[iindex[s->order & 7][STRIPE]] = 0; + ie[iindex[s->order & 7][STRIPE]] = s->stripes - 1; + is[iindex[s->order & 7][LAYER]] = s->dl; + ie[iindex[s->order & 7][LAYER]] = s->d; + is[iindex[s->order & 7][PLANE]] = 0; + ie[iindex[s->order & 7][PLANE]] = s->planes - 1; + i = 2; /* index to innermost loop */ + do { + j = 0; /* carry flag */ + if (++s->ii[i] > ie[i]) { + /* handling overflow of loop variable */ + j = 1; + if (i > 0) + s->ii[i] = is[i]; + } + } while (--i >= 0 && j); + + s->buf_len = 0; + + /* check whether this have been all SDEs */ + if (j) { #ifdef DEBUG - fprintf(stderr, "This was the final SDE in this BIE, " - "%ld bytes left.\n", (long) (len - *cnt)); + fprintf(stderr, "This was the final SDE in this BIE, " + "%ld bytes left.\n", (long) (len - *cnt)); #endif - s->bie_len = 0; - return JBG_EOK; - } - - /* check whether we have to abort because of xmax/ymax */ - if (iindex[s->order & 7][LAYER] == 0 && i < 0) { - /* LAYER is the outermost loop and we have just gone to next layer */ - if (jbg_ceil_half(s->xd, s->d - s->ii[0]) > s->xmax || - jbg_ceil_half(s->yd, s->d - s->ii[0]) > s->ymax) { - s->xmax = 4294967295UL; - s->ymax = 4294967295UL; - return JBG_EOK_INTR; - } - if (s->ii[0] > (unsigned long) s->dmax) { - s->dmax = 256; - return JBG_EOK_INTR; - } - } - - break; + s->bie_len = 0; + return JBG_EOK; + } + + /* check whether we have to abort because of xmax/ymax */ + if (iindex[s->order & 7][LAYER] == 0 && i < 0) { + /* LAYER is the outermost loop and we have just gone to next layer */ + if (jbg_ceil_half(s->xd, s->d - s->ii[0]) > s->xmax || + jbg_ceil_half(s->yd, s->d - s->ii[0]) > s->ymax) { + s->xmax = 4294967295UL; + s->ymax = 4294967295UL; + return JBG_EOK_INTR; + } + if (s->ii[0] > (unsigned long) s->dmax) { + s->dmax = 256; + return JBG_EOK_INTR; + } + } + + break; } s->buf_len = 0; @@ -2879,11 +2879,11 @@ int jbg_dec_in(struct jbg_dec_state *s, unsigned char *data, size_t len, *cnt += decode_pscd(s, data + *cnt, len - *cnt); if (*cnt < len && data[*cnt] != 0xff) { #ifdef DEBUG - fprintf(stderr, "PSCD was longer than expected, unread bytes " - "%02x %02x %02x %02x ...\n", data[*cnt], data[*cnt+1], - data[*cnt+2], data[*cnt+3]); + fprintf(stderr, "PSCD was longer than expected, unread bytes " + "%02x %02x %02x %02x ...\n", data[*cnt], data[*cnt+1], + data[*cnt+2], data[*cnt+3]); #endif - return JBG_EINVAL | 14; + return JBG_EINVAL | 14; } } @@ -2967,8 +2967,8 @@ unsigned long jbg_dec_getsize(const struct jbg_dec_state *s) return 0; else return - jbg_ceil_half(s->xd, s->d - (s->ii[0] - 1) + 3) * /* overflow risk? */ - jbg_ceil_half(s->yd, s->d - (s->ii[0] - 1)); + jbg_ceil_half(s->xd, s->d - (s->ii[0] - 1) + 3) * /* overflow risk? */ + jbg_ceil_half(s->yd, s->d - (s->ii[0] - 1)); } return jbg_ceil_half(s->xd, 3) * s->yd; @@ -2989,9 +2989,9 @@ unsigned long jbg_dec_getsize_merged(const struct jbg_dec_state *s) return 0; else return - jbg_ceil_half(s->xd, s->d - (s->ii[0] - 1)) * /* overflow risk? */ - jbg_ceil_half(s->yd, s->d - (s->ii[0] - 1)) * - ((s->planes + 7) / 8); + jbg_ceil_half(s->xd, s->d - (s->ii[0] - 1)) * /* overflow risk? */ + jbg_ceil_half(s->yd, s->d - (s->ii[0] - 1)) * + ((s->planes + 7) / 8); } return s->xd * s->yd * ((s->planes + 7) / 8); @@ -3045,9 +3045,9 @@ void jbg_dec_free(struct jbg_dec_state *s) * actually transfer to dest. */ void jbg_split_planes(unsigned long x, unsigned long y, int has_planes, - int encode_planes, - const unsigned char *src, unsigned char **dest, - int use_graycode) + int encode_planes, + const unsigned char *src, unsigned char **dest, + int use_graycode) { unsigned long bpl = jbg_ceil_half(x, 3); /* bytes per line in dest plane */ unsigned long line, i; @@ -3068,29 +3068,29 @@ void jbg_split_planes(unsigned long x, unsigned long y, int has_planes, for (line = 0; line < y; line++) { /* lines loop */ for (i = 0; i * 8 < x; i++) { /* dest bytes loop */ for (k = 0; k < 8 && i * 8 + k < x; k++) { /* pixel loop */ - prev = 0; - for (p = 0; p < encode_planes; p++) { /* bit planes loop */ - /* calculate which bit in *src do we want */ - bitno = (msb - p) & 7; - /* put this bit with its left neighbor right adjusted into bits */ - bits = (prev | *src) >> bitno; - /* go to next *src byte, but keep old */ - if (bitno == 0) - prev = *src++ << 8; - /* make space for inserting new bit */ - dest[p][bpl * line + i] <<= 1; - /* insert bit, if requested apply Gray encoding */ - dest[p][bpl * line + i] |= (bits ^ (use_graycode & (bits>>1))) & 1; - /* - * Theorem: Let b(n),...,b(1),b(0) be the digits of a - * binary word and let g(n),...,g(1),g(0) be the digits of the - * corresponding Gray code word, then g(i) = b(i) xor b(i+1). - */ - } - /* skip unused *src bytes */ - for (;p < has_planes; p++) - if (((msb - p) & 7) == 0) - src++; + prev = 0; + for (p = 0; p < encode_planes; p++) { /* bit planes loop */ + /* calculate which bit in *src do we want */ + bitno = (msb - p) & 7; + /* put this bit with its left neighbor right adjusted into bits */ + bits = (prev | *src) >> bitno; + /* go to next *src byte, but keep old */ + if (bitno == 0) + prev = *src++ << 8; + /* make space for inserting new bit */ + dest[p][bpl * line + i] <<= 1; + /* insert bit, if requested apply Gray encoding */ + dest[p][bpl * line + i] |= (bits ^ (use_graycode & (bits>>1))) & 1; + /* + * Theorem: Let b(n),...,b(1),b(0) be the digits of a + * binary word and let g(n),...,g(1),g(0) be the digits of the + * corresponding Gray code word, then g(i) = b(i) xor b(i+1). + */ + } + /* skip unused *src bytes */ + for (;p < has_planes; p++) + if (((msb - p) & 7) == 0) + src++; } } for (p = 0; p < encode_planes; p++) /* right padding loop */ @@ -3106,8 +3106,8 @@ void jbg_split_planes(unsigned long x, unsigned long y, int has_planes, * jbg_split_planes(). */ void jbg_dec_merge_planes(const struct jbg_dec_state *s, int use_graycode, - void (*data_out)(unsigned char *start, size_t len, - void *file), void *file) + void (*data_out)(unsigned char *start, size_t len, + void *file), void *file) { #define BUFLEN 4096 unsigned long bpl, line, i; @@ -3139,19 +3139,19 @@ void jbg_dec_merge_planes(const struct jbg_dec_state *s, int use_graycode, for (line = 0; line < y; line++) { /* lines loop */ for (i = 0; i * 8 < x; i++) { /* src bytes loop */ for (k = 0; k < 8 && i * 8 + k < x; k++) { /* pixel loop */ - v = 0; - for (p = 0; p < s->planes;) { /* dest bytes loop */ - do { - v = (v << 1) | - (((src[p][bpl * line + i] >> (7 - k)) & 1) ^ - (use_graycode & v)); - } while ((s->planes - ++p) & 7); - *bp++ = v; - if (bp - buf == BUFLEN) { - data_out(buf, BUFLEN, file); - bp = buf; - } - } + v = 0; + for (p = 0; p < s->planes;) { /* dest bytes loop */ + do { + v = (v << 1) | + (((src[p][bpl * line + i] >> (7 - k)) & 1) ^ + (use_graycode & v)); + } while ((s->planes - ++p) & 7); + *bp++ = v; + if (bp - buf == BUFLEN) { + data_out(buf, BUFLEN, file); + bp = buf; + } + } } } } @@ -3186,15 +3186,15 @@ static unsigned char *jbg_next_pscdms(unsigned char *p, size_t len) if (p[0] != MARKER_ESC || p[1] == MARKER_STUFF) { do { while (p[0] == MARKER_ESC && p[1] == MARKER_STUFF) { - p += 2; - len -= 2; - if (len < 2) - return NULL; /* not enough bytes left for complete marker segment */ + p += 2; + len -= 2; + if (len < 2) + return NULL; /* not enough bytes left for complete marker segment */ } assert(len >= 2); pp = (unsigned char *) memchr(p, MARKER_ESC, len - 1); if (!pp) - return NULL; /* no marker segment terminates the PSCD */ + return NULL; /* no marker segment terminates the PSCD */ l = pp - p; assert(l < len); p += l; @@ -3208,19 +3208,19 @@ static unsigned char *jbg_next_pscdms(unsigned char *p, size_t len) return p + 2; case MARKER_NEWLEN: if (len < 6) - return NULL; /* not enough bytes left for complete marker segment */ + return NULL; /* not enough bytes left for complete marker segment */ return p + 6; case MARKER_ATMOVE: if (len < 8) - return NULL; /* not enough bytes left for complete marker segment */ + return NULL; /* not enough bytes left for complete marker segment */ return p + 8; case MARKER_COMMENT: if (len < 6) - return NULL; /* not enough bytes left for complete marker segment */ + return NULL; /* not enough bytes left for complete marker segment */ l = (((long) p[2] << 24) | ((long) p[3] << 16) | - ((long) p[4] << 8) | (long) p[5]); + ((long) p[4] << 8) | (long) p[5]); if (len - 6 < l) - return NULL; /* not enough bytes left for complete marker segment */ + return NULL; /* not enough bytes left for complete marker segment */ return p + 6 + l; default: /* unknown marker sequence encountered */ @@ -3265,18 +3265,18 @@ int jbg_newlen(unsigned char *bie, size_t len) else if (p[0] == MARKER_ESC) switch (p[1]) { case MARKER_NEWLEN: - y = (((long) bie[ 8] << 24) | ((long) bie[ 9] << 16) | - ((long) bie[10] << 8) | (long) bie[11]); - yn = (((long) p[2] << 24) | ((long) p[3] << 16) | - ((long) p[4] << 8) | (long) p[5]); - if (yn > y) return JBG_EINVAL | 12; - /* overwrite YD in BIH with YD from NEWLEN */ - for (i = 0; i < 4; i++) { - bie[8+i] = p[2+i]; - } - return JBG_EOK; + y = (((long) bie[ 8] << 24) | ((long) bie[ 9] << 16) | + ((long) bie[10] << 8) | (long) bie[11]); + yn = (((long) p[2] << 24) | ((long) p[3] << 16) | + ((long) p[4] << 8) | (long) p[5]); + if (yn > y) return JBG_EINVAL | 12; + /* overwrite YD in BIH with YD from NEWLEN */ + for (i = 0; i < 4; i++) { + bie[8+i] = p[2+i]; + } + return JBG_EOK; case MARKER_ABORT: - return JBG_EABORT; + return JBG_EABORT; } } return JBG_EINVAL | 0; diff --git a/converter/other/jbig/libjbig/jbig_ar.c b/converter/other/jbig/libjbig/jbig_ar.c index d23a317d..194e13eb 100644 --- a/converter/other/jbig/libjbig/jbig_ar.c +++ b/converter/other/jbig/libjbig/jbig_ar.c @@ -22,7 +22,7 @@ * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - * + * * If you want to use this program under different license conditions, * then contact the author for an arrangement. */ @@ -106,7 +106,7 @@ static unsigned char nlpstab[113] = { void arith_encode_init(struct jbg_arenc_state *s, int reuse_st) { int i; - + if (!reuse_st) for (i = 0; i < 4096; s->st[i++] = 0) ; s->c = 0; @@ -114,7 +114,7 @@ void arith_encode_init(struct jbg_arenc_state *s, int reuse_st) s->sc = 0; s->ct = 11; s->buffer = -1; /* empty */ - + return; } @@ -136,15 +136,15 @@ void arith_encode_flush(struct jbg_arenc_state *s) if (s->buffer >= 0) { s->byte_out(s->buffer + 1, s->file); if (s->buffer + 1 == MARKER_ESC) - s->byte_out(MARKER_STUFF, s->file); + s->byte_out(MARKER_STUFF, s->file); } /* output 0x00 bytes only when more non-0x00 will follow */ if (s->c & 0x7fff800L) for (; s->sc; --s->sc) - s->byte_out(0x00, s->file); + s->byte_out(0x00, s->file); } else { if (s->buffer >= 0) - s->byte_out(s->buffer, s->file); + s->byte_out(s->buffer, s->file); /* T.82 figure 30 says buffer+1 for the above line! Typo? */ for (; s->sc; --s->sc) { s->byte_out(0xff, s->file); @@ -159,7 +159,7 @@ void arith_encode_flush(struct jbg_arenc_state *s) if (s->c & 0x7f800L) { s->byte_out((s->c >> 11) & 0xff, s->file); if (((s->c >> 11) & 0xff) == MARKER_ESC) - s->byte_out(MARKER_STUFF, s->file); + s->byte_out(MARKER_STUFF, s->file); } } @@ -167,7 +167,7 @@ void arith_encode_flush(struct jbg_arenc_state *s) } -void arith_encode(struct jbg_arenc_state *s, int cx, int pix) +void arith_encode(struct jbg_arenc_state *s, int cx, int pix) { register unsigned lsz, ss; register unsigned char *st; @@ -181,9 +181,9 @@ void arith_encode(struct jbg_arenc_state *s, int cx, int pix) #if 0 fprintf(stderr, "pix = %d, cx = %d, mps = %d, st = %3d, lsz = 0x%04x, " - "a = 0x%05lx, c = 0x%08lx, ct = %2d, buf = 0x%02x\n", - pix, cx, !!(s->st[cx] & 0x80), ss, lsz, s->a, s->c, s->ct, - s->buffer); + "a = 0x%05lx, c = 0x%08lx, ct = %2d, buf = 0x%02x\n", + pix, cx, !!(s->st[cx] & 0x80), ss, lsz, s->a, s->c, s->ct, + s->buffer); #endif if (((pix << 7) ^ s->st[cx]) & 0x80) { @@ -225,36 +225,36 @@ void arith_encode(struct jbg_arenc_state *s, int cx, int pix) /* another byte is ready for output */ temp = s->c >> 19; if (temp & 0xffffff00L) { - /* handle overflow over all buffered 0xff bytes */ - if (s->buffer >= 0) { - ++s->buffer; - s->byte_out(s->buffer, s->file); - if (s->buffer == MARKER_ESC) - s->byte_out(MARKER_STUFF, s->file); - } - for (; s->sc; --s->sc) - s->byte_out(0x00, s->file); - s->buffer = temp & 0xff; /* new output byte, might overflow later */ - assert(s->buffer != 0xff); - /* can s->buffer really never become 0xff here? */ + /* handle overflow over all buffered 0xff bytes */ + if (s->buffer >= 0) { + ++s->buffer; + s->byte_out(s->buffer, s->file); + if (s->buffer == MARKER_ESC) + s->byte_out(MARKER_STUFF, s->file); + } + for (; s->sc; --s->sc) + s->byte_out(0x00, s->file); + s->buffer = temp & 0xff; /* new output byte, might overflow later */ + assert(s->buffer != 0xff); + /* can s->buffer really never become 0xff here? */ } else if (temp == 0xff) { - /* buffer 0xff byte (which might overflow later) */ - ++s->sc; + /* buffer 0xff byte (which might overflow later) */ + ++s->sc; } else { - /* output all buffered 0xff bytes, they will not overflow any more */ - if (s->buffer >= 0) - s->byte_out(s->buffer, s->file); - for (; s->sc; --s->sc) { - s->byte_out(0xff, s->file); - s->byte_out(MARKER_STUFF, s->file); - } - s->buffer = temp; /* buffer new output byte (can still overflow) */ + /* output all buffered 0xff bytes, they will not overflow any more */ + if (s->buffer >= 0) + s->byte_out(s->buffer, s->file); + for (; s->sc; --s->sc) { + s->byte_out(0xff, s->file); + s->byte_out(MARKER_STUFF, s->file); + } + s->buffer = temp; /* buffer new output byte (can still overflow) */ } s->c &= 0x7ffffL; s->ct = 8; } } while (s->a < 0x8000); - + return; } @@ -262,7 +262,7 @@ void arith_encode(struct jbg_arenc_state *s, int cx, int pix) void arith_decode_init(struct jbg_ardec_state *s, int reuse_st) { int i; - + if (!reuse_st) for (i = 0; i < 4096; s->st[i++] = 0) ; s->c = 0; @@ -295,7 +295,7 @@ void arith_decode_init(struct jbg_ardec_state *s, int reuse_st) * decoded. * * s->pscd_ptr == s->pscd_end - 1: - * + * * The decoder has used up all provided PSCD bytes except for the * very last byte, because that has the value 0xff. The decoder can * at this point not yet tell whether this 0xff belongs to a @@ -336,27 +336,27 @@ int arith_decode(struct jbg_ardec_state *s, int cx) while (s->ct <= 8 && s->ct >= 0) { /* first we can move a new byte into s->c */ if (s->pscd_ptr >= s->pscd_end) { - return -1; /* more bytes needed */ + return -1; /* more bytes needed */ } - if (*s->pscd_ptr == 0xff) - if (s->pscd_ptr + 1 >= s->pscd_end) { - return -1; /* final 0xff byte not processed */ - } else { - if (*(s->pscd_ptr + 1) == MARKER_STUFF) { - s->c |= 0xffL << (8 - s->ct); - s->ct += 8; - s->pscd_ptr += 2; - } else { - s->ct = -1; /* start padding with zero bytes */ - if (s->nopadding) { - s->nopadding = 0; - return -2; /* subsequent symbols might depend on zero padding */ - } - } - } + if (*s->pscd_ptr == 0xff) + if (s->pscd_ptr + 1 >= s->pscd_end) { + return -1; /* final 0xff byte not processed */ + } else { + if (*(s->pscd_ptr + 1) == MARKER_STUFF) { + s->c |= 0xffL << (8 - s->ct); + s->ct += 8; + s->pscd_ptr += 2; + } else { + s->ct = -1; /* start padding with zero bytes */ + if (s->nopadding) { + s->nopadding = 0; + return -2; /* subsequent symbols might depend on zero padding */ + } + } + } else { - s->c |= (long)*(s->pscd_ptr++) << (8 - s->ct); - s->ct += 8; + s->c |= (long)*(s->pscd_ptr++) << (8 - s->ct); + s->ct += 8; } } s->c <<= 1; @@ -373,8 +373,8 @@ int arith_decode(struct jbg_ardec_state *s, int cx) #if 0 fprintf(stderr, "cx = %d, mps = %d, st = %3d, lsz = 0x%04x, a = 0x%05lx, " - "c = 0x%08lx, ct = %2d\n", - cx, !!(s->st[cx] & 0x80), ss, lsz, s->a, s->c, s->ct); + "c = 0x%08lx, ct = %2d\n", + cx, !!(s->st[cx] & 0x80), ss, lsz, s->a, s->c, s->ct); #endif if ((s->c >> 16) < (s->a -= lsz)) @@ -383,15 +383,15 @@ int arith_decode(struct jbg_ardec_state *s, int cx) else { /* MPS_EXCHANGE */ if (s->a < lsz) { - pix = 1 - (*st >> 7); - /* Check whether MPS/LPS exchange is necessary - * and chose next probability estimator status */ - *st &= 0x80; - *st ^= nlpstab[ss]; + pix = 1 - (*st >> 7); + /* Check whether MPS/LPS exchange is necessary + * and chose next probability estimator status */ + *st &= 0x80; + *st ^= nlpstab[ss]; } else { - pix = *st >> 7; - *st &= 0x80; - *st |= nmpstab[ss]; + pix = *st >> 7; + *st &= 0x80; + *st |= nmpstab[ss]; } } else { diff --git a/converter/other/jbig/pnmtojbig.c b/converter/other/jbig/pnmtojbig.c index f5188c7b..5757680e 100644 --- a/converter/other/jbig/pnmtojbig.c +++ b/converter/other/jbig/pnmtojbig.c @@ -1,6 +1,6 @@ /* pnmtojbig - PNM to JBIG converter - + This program was derived from pbmtojbg.c in Markus Kuhn's JBIG-KIT package by Bryan Henderson on 2000.05.11 @@ -34,7 +34,7 @@ bits in it. */ - + #include <stdio.h> #include <stdlib.h> #include <ctype.h> @@ -44,7 +44,7 @@ #include "mallocvar.h" #include "pnm.h" -static unsigned long total_length = 0; +static unsigned long total_length = 0; /* used for determining output file length */ /* @@ -54,12 +54,12 @@ static void *checkedmalloc(size_t n) { void *p; - + if ((p = malloc(n)) == NULL) { fprintf(stderr, "Sorry, not enough memory available!\n"); exit(1); } - + return p; } @@ -92,13 +92,13 @@ readPbm(FILE * const fin, int row; bitmap = (unsigned char **) checkedmalloc(sizeof(unsigned char *)); bitmap[0] = (unsigned char *) checkedmalloc(bytes_per_line * rows); - + for (row = 0; row < rows; row++) pbm_readpbmrow_packed(fin, &bitmap[0][row*bytes_per_line], cols, RPBM_FORMAT); *bitmapP = bitmap; -} +} @@ -121,7 +121,7 @@ readImage(FILE * const fin, pixel. The 'bpp' bytes for each pixel are arranged MSB first and its numerical value is the value from the PNM input. The pixels are laid out in row-major format in this rectangle. - + The point of this data structure is it is what jbg_split_planes() wants for input. */ @@ -130,7 +130,7 @@ readImage(FILE * const fin, pnm_row = pnm_allocrow(cols); /* row buffer */ MALLOCARRAY_NOFAIL(image, cols * rows * bpp); - + for (row = 0; row < rows; ++row) { unsigned int col; pnm_readpnmrow(fin, pnm_row, cols, maxval, format); @@ -145,7 +145,7 @@ readImage(FILE * const fin, pnm_freerow(pnm_row); *imageP = image; } - + static void @@ -154,12 +154,12 @@ convertImageToBitmap(unsigned char * const image, unsigned int const encode_planes, unsigned int const bytes_per_line, unsigned int const lines) { - + /* Convert image[] into bitmap[] */ - + unsigned char ** bitmap; unsigned int i; - + MALLOCARRAY_NOFAIL(bitmap, encode_planes); for (i = 0; i < encode_planes; ++i) MALLOCARRAY_NOFAIL(bitmap[i], bytes_per_line * lines); @@ -193,10 +193,10 @@ readPnm(FILE * const fin, jbg_split_planes(cols, rows, planes, encode_planes, image, bitmap, use_graycode); free(image); - + /* Invert the image if it is just one plane. See top of this file for an explanation why. Because of the separate handling of PBM, - this is for exceptional PGM files. + this is for exceptional PGM files. */ if (encode_planes == 1) { @@ -206,7 +206,7 @@ readPnm(FILE * const fin, for (i = 0; i < bytes_per_line; i++) bitmap[0][(row*bytes_per_line) + i] ^= 0xff; - if (cols % 8 > 0) { + if (cols % 8 > 0) { bitmap[0][ (row+1)*bytes_per_line -1] >>= 8-cols%8; bitmap[0][ (row+1)*bytes_per_line -1] <<= 8-cols%8; } @@ -230,7 +230,7 @@ main(int argc, char **argv) { unsigned char **bitmap; /* This is an array of the planes of the image. Each plane is a two-dimensional array of pixels laid out in row-major format. - format with each pixel being one bit. A byte in the array + format with each pixel being one bit. A byte in the array contains 8 pixels left to right, msb to lsb. */ @@ -372,8 +372,8 @@ main(int argc, char **argv) { /* In a JBIG file, maxvals are determined only by the number of planes, so must be a power of 2 minus 1 */ - - if ((1UL << planes)-1 != maxval) + + if ((1UL << planes)-1 != maxval) pm_error("Input image has unacceptable maxval: %d. JBIG files must " "have a maxval which is a power of 2 minus 1. Use " "Ppmdepth to adjust the image's maxval", maxval); @@ -386,8 +386,8 @@ main(int argc, char **argv) { if (bpp == 1 && PNM_FORMAT_TYPE(format) == PBM_TYPE) readPbm(fin, cols, rows, &bitmap); else - readPnm(fin, cols, rows, maxval, format, bpp, - planes, encode_planes, use_graycode, + readPnm(fin, cols, rows, maxval, format, bpp, + planes, encode_planes, use_graycode, &bitmap); /* Apply JBIG algorithm and write BIE to output file */ diff --git a/converter/other/jpeg2000/libjasper/base/jas_debug.c b/converter/other/jpeg2000/libjasper/base/jas_debug.c index 4248178f..1bfdef51 100644 --- a/converter/other/jpeg2000/libjasper/base/jas_debug.c +++ b/converter/other/jpeg2000/libjasper/base/jas_debug.c @@ -4,14 +4,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -19,22 +19,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -54,17 +54,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -104,7 +104,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -132,22 +132,22 @@ static int jas_dbglevel = 0; /* Set the library debug level. */ int jas_setdbglevel(int dbglevel) { - int olddbglevel; + int olddbglevel; - /* Save the old debug level. */ - olddbglevel = jas_dbglevel; + /* Save the old debug level. */ + olddbglevel = jas_dbglevel; - /* Change the debug level. */ - jas_dbglevel = dbglevel; + /* Change the debug level. */ + jas_dbglevel = dbglevel; - /* Return the old debug level. */ - return olddbglevel; + /* Return the old debug level. */ + return olddbglevel; } /* Get the library debug level. */ int jas_getdbglevel() { - return jas_dbglevel; + return jas_dbglevel; } /******************************************************************************\ @@ -157,30 +157,30 @@ int jas_getdbglevel() /* Perform formatted output to standard error. */ int jas_eprintf(const char *fmt, ...) { - int ret; - va_list ap; + int ret; + va_list ap; - va_start(ap, fmt); - ret = vfprintf(stderr, fmt, ap); - va_end(ap); - return ret; + va_start(ap, fmt); + ret = vfprintf(stderr, fmt, ap); + va_end(ap); + return ret; } /* Dump memory to a stream. */ int jas_memdump(FILE *out, void *data, size_t len) { - int i; - int j; - unsigned char *dp; - dp = data; - for (i = 0; i < len; i += 16) { - fprintf(out, "%04x:", i); - for (j = 0; j < 16; ++j) { - if (i + j < len) { - fprintf(out, " %02x", dp[i + j]); - } - } - fprintf(out, "\n"); - } - return 0; + int i; + int j; + unsigned char *dp; + dp = data; + for (i = 0; i < len; i += 16) { + fprintf(out, "%04x:", i); + for (j = 0; j < 16; ++j) { + if (i + j < len) { + fprintf(out, " %02x", dp[i + j]); + } + } + fprintf(out, "\n"); + } + return 0; } diff --git a/converter/other/jpeg2000/libjasper/base/jas_getopt.c b/converter/other/jpeg2000/libjasper/base/jas_getopt.c index 7f579b3e..e12340c2 100644 --- a/converter/other/jpeg2000/libjasper/base/jas_getopt.c +++ b/converter/other/jpeg2000/libjasper/base/jas_getopt.c @@ -2,18 +2,18 @@ * Copyright (c) 1999-2000, Image Power, Inc. and the University of * British Columbia. * Copyright (c) 2001-2002 Michael David Adams. - * All rights reserved. + * All rights reserved. */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -140,78 +140,78 @@ char *jas_optarg = 0; static jas_opt_t *jas_optlookup(jas_opt_t *opts, char *name) { - jas_opt_t *opt; + jas_opt_t *opt; - for (opt = opts; opt->id >= 0 && opt->name; ++opt) { - if (!strcmp(opt->name, name)) { - return opt; - } - } - return 0; + for (opt = opts; opt->id >= 0 && opt->name; ++opt) { + if (!strcmp(opt->name, name)) { + return opt; + } + } + return 0; } int jas_getopt(int argc, char **argv, jas_opt_t *opts) { - char *cp; - int id; - int hasarg; - jas_opt_t *opt; - char *s; + char *cp; + int id; + int hasarg; + jas_opt_t *opt; + char *s; - if (!jas_optind) { - jas_optind = JAS_MIN(1, argc); - } - while (jas_optind < argc) { - s = cp = argv[jas_optind]; - if (*cp == '-') { - /* We are processing an option. */ - ++jas_optind; - if (*++cp == '-') { - /* We are processing a long option. */ - ++cp; - if (*cp == '\0') { - /* This is the end of the options. */ - return JAS_GETOPT_EOF; - } - if (!(opt = jas_optlookup(opts, cp))) { - if (jas_opterr) { - fprintf(stderr, "unknown long option %s\n", s); - } - return JAS_GETOPT_ERR; - } - hasarg = (opt->flags & JAS_OPT_HASARG) != 0; - id = opt->id; - } else { - /* We are processing a short option. */ - if (strlen(cp) != 1 || - !(opt = jas_optlookup(opts, cp))) { - if (jas_opterr) { - fprintf(stderr, "unknown short option %s\n", s); - } - return JAS_GETOPT_ERR; - } - hasarg = (opt->flags & JAS_OPT_HASARG) != 0; - id = opt->id; - } - if (hasarg) { - /* The option has an argument. */ - if (jas_optind >= argc) { - if (jas_opterr) { - fprintf(stderr, "missing argument for option %s\n", s); - } - return JAS_GETOPT_ERR; - } - jas_optarg = argv[jas_optind]; - ++jas_optind; - } else { - /* The option does not have an argument. */ - jas_optarg = 0; - } - return id; - } else { - /* We are not processing an option. */ - return JAS_GETOPT_EOF; - } - } - return JAS_GETOPT_EOF; + if (!jas_optind) { + jas_optind = JAS_MIN(1, argc); + } + while (jas_optind < argc) { + s = cp = argv[jas_optind]; + if (*cp == '-') { + /* We are processing an option. */ + ++jas_optind; + if (*++cp == '-') { + /* We are processing a long option. */ + ++cp; + if (*cp == '\0') { + /* This is the end of the options. */ + return JAS_GETOPT_EOF; + } + if (!(opt = jas_optlookup(opts, cp))) { + if (jas_opterr) { + fprintf(stderr, "unknown long option %s\n", s); + } + return JAS_GETOPT_ERR; + } + hasarg = (opt->flags & JAS_OPT_HASARG) != 0; + id = opt->id; + } else { + /* We are processing a short option. */ + if (strlen(cp) != 1 || + !(opt = jas_optlookup(opts, cp))) { + if (jas_opterr) { + fprintf(stderr, "unknown short option %s\n", s); + } + return JAS_GETOPT_ERR; + } + hasarg = (opt->flags & JAS_OPT_HASARG) != 0; + id = opt->id; + } + if (hasarg) { + /* The option has an argument. */ + if (jas_optind >= argc) { + if (jas_opterr) { + fprintf(stderr, "missing argument for option %s\n", s); + } + return JAS_GETOPT_ERR; + } + jas_optarg = argv[jas_optind]; + ++jas_optind; + } else { + /* The option does not have an argument. */ + jas_optarg = 0; + } + return id; + } else { + /* We are not processing an option. */ + return JAS_GETOPT_EOF; + } + } + return JAS_GETOPT_EOF; } diff --git a/converter/other/jpeg2000/libjasper/base/jas_image.c b/converter/other/jpeg2000/libjasper/base/jas_image.c index c6f984c1..49a0db79 100644 --- a/converter/other/jpeg2000/libjasper/base/jas_image.c +++ b/converter/other/jpeg2000/libjasper/base/jas_image.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -166,215 +166,215 @@ static jas_image_fmtinfo_t jas_image_fmtinfos[JAS_IMAGE_MAXFMTS]; jas_image_t *jas_image_create(uint_fast16_t numcmpts, jas_image_cmptparm_t *cmptparms, int colorspace) { - jas_image_t *image; - uint_fast32_t rawsize; - uint_fast32_t inmem; - uint_fast16_t cmptno; - jas_image_cmptparm_t *cmptparm; - - if (!(image = jas_image_create0())) { - return 0; - } - - image->colorspace_ = colorspace; - image->maxcmpts_ = numcmpts; - image->inmem_ = true; - - /* Allocate memory for the per-component information. */ - if (!(image->cmpts_ = jas_malloc(image->maxcmpts_ * - sizeof(jas_image_cmpt_t *)))) { - jas_image_destroy(image); - return 0; - } - /* Initialize in case of failure. */ - for (cmptno = 0; cmptno < image->maxcmpts_; ++cmptno) { - image->cmpts_[cmptno] = 0; - } - - /* Compute the approximate raw size of the image. */ - rawsize = 0; - for (cmptno = 0, cmptparm = cmptparms; cmptno < numcmpts; ++cmptno, - ++cmptparm) { - rawsize += cmptparm->width * cmptparm->height * - (cmptparm->prec + 7) / 8; - } - /* Decide whether to buffer the image data in memory, based on the - raw size of the image. */ - inmem = (rawsize < JAS_IMAGE_INMEMTHRESH); - - /* Create the individual image components. */ - for (cmptno = 0, cmptparm = cmptparms; cmptno < numcmpts; ++cmptno, - ++cmptparm) { - if (!(image->cmpts_[cmptno] = jas_image_cmpt_create(cmptparm->tlx, - cmptparm->tly, cmptparm->hstep, cmptparm->vstep, - cmptparm->width, cmptparm->height, cmptparm->prec, - cmptparm->sgnd, inmem))) { - jas_image_destroy(image); - return 0; - } - ++image->numcmpts_; - } - - /* Determine the bounding box for all of the components on the - reference grid (i.e., the image area) */ - jas_image_setbbox(image); - - return image; + jas_image_t *image; + uint_fast32_t rawsize; + uint_fast32_t inmem; + uint_fast16_t cmptno; + jas_image_cmptparm_t *cmptparm; + + if (!(image = jas_image_create0())) { + return 0; + } + + image->colorspace_ = colorspace; + image->maxcmpts_ = numcmpts; + image->inmem_ = true; + + /* Allocate memory for the per-component information. */ + if (!(image->cmpts_ = jas_malloc(image->maxcmpts_ * + sizeof(jas_image_cmpt_t *)))) { + jas_image_destroy(image); + return 0; + } + /* Initialize in case of failure. */ + for (cmptno = 0; cmptno < image->maxcmpts_; ++cmptno) { + image->cmpts_[cmptno] = 0; + } + + /* Compute the approximate raw size of the image. */ + rawsize = 0; + for (cmptno = 0, cmptparm = cmptparms; cmptno < numcmpts; ++cmptno, + ++cmptparm) { + rawsize += cmptparm->width * cmptparm->height * + (cmptparm->prec + 7) / 8; + } + /* Decide whether to buffer the image data in memory, based on the + raw size of the image. */ + inmem = (rawsize < JAS_IMAGE_INMEMTHRESH); + + /* Create the individual image components. */ + for (cmptno = 0, cmptparm = cmptparms; cmptno < numcmpts; ++cmptno, + ++cmptparm) { + if (!(image->cmpts_[cmptno] = jas_image_cmpt_create(cmptparm->tlx, + cmptparm->tly, cmptparm->hstep, cmptparm->vstep, + cmptparm->width, cmptparm->height, cmptparm->prec, + cmptparm->sgnd, inmem))) { + jas_image_destroy(image); + return 0; + } + ++image->numcmpts_; + } + + /* Determine the bounding box for all of the components on the + reference grid (i.e., the image area) */ + jas_image_setbbox(image); + + return image; } jas_image_t *jas_image_create0() { - jas_image_t *image; + jas_image_t *image; - if (!(image = jas_malloc(sizeof(jas_image_t)))) { - return 0; - } + if (!(image = jas_malloc(sizeof(jas_image_t)))) { + return 0; + } - image->tlx_ = 0; - image->tly_ = 0; - image->brx_ = 0; - image->bry_ = 0; - image->colorspace_ = JAS_IMAGE_CS_UNKNOWN; - image->numcmpts_ = 0; - image->maxcmpts_ = 0; - image->cmpts_ = 0; - image->inmem_ = true; - image->iccp_ = 0; - image->iccplen_ = 0; + image->tlx_ = 0; + image->tly_ = 0; + image->brx_ = 0; + image->bry_ = 0; + image->colorspace_ = JAS_IMAGE_CS_UNKNOWN; + image->numcmpts_ = 0; + image->maxcmpts_ = 0; + image->cmpts_ = 0; + image->inmem_ = true; + image->iccp_ = 0; + image->iccplen_ = 0; - return image; + return image; } jas_image_t *jas_image_copy(jas_image_t *image) { - jas_image_t *newimage; - int cmptno; + jas_image_t *newimage; + int cmptno; - newimage = jas_image_create0(); - if (jas_image_growcmpts(newimage, image->numcmpts_)) { - goto error; - } - for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) { - if (!(newimage->cmpts_[cmptno] = jas_image_cmpt_copy(image->cmpts_[cmptno]))) { - goto error; - } - ++newimage->numcmpts_; - } + newimage = jas_image_create0(); + if (jas_image_growcmpts(newimage, image->numcmpts_)) { + goto error; + } + for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) { + if (!(newimage->cmpts_[cmptno] = jas_image_cmpt_copy(image->cmpts_[cmptno]))) { + goto error; + } + ++newimage->numcmpts_; + } - jas_image_setbbox(newimage); + jas_image_setbbox(newimage); - return newimage; + return newimage; error: - if (newimage) { - jas_image_destroy(newimage); - } - return 0; + if (newimage) { + jas_image_destroy(newimage); + } + return 0; } static jas_image_cmpt_t *jas_image_cmpt_create0() { - jas_image_cmpt_t *cmpt; - if (!(cmpt = jas_malloc(sizeof(jas_image_cmpt_t)))) { - return 0; - } - memset(cmpt, 0, sizeof(jas_image_cmpt_t)); - cmpt->type_ = JAS_IMAGE_CT_UNKNOWN; - return cmpt; + jas_image_cmpt_t *cmpt; + if (!(cmpt = jas_malloc(sizeof(jas_image_cmpt_t)))) { + return 0; + } + memset(cmpt, 0, sizeof(jas_image_cmpt_t)); + cmpt->type_ = JAS_IMAGE_CT_UNKNOWN; + return cmpt; } static jas_image_cmpt_t *jas_image_cmpt_copy(jas_image_cmpt_t *cmpt) { - jas_image_cmpt_t *newcmpt; - - if (!(newcmpt = jas_image_cmpt_create0())) { - return 0; - } - newcmpt->tlx_ = cmpt->tlx_; - newcmpt->tly_ = cmpt->tly_; - newcmpt->hstep_ = cmpt->hstep_; - newcmpt->vstep_ = cmpt->vstep_; - newcmpt->width_ = cmpt->width_; - newcmpt->height_ = cmpt->height_; - newcmpt->prec_ = cmpt->prec_; - newcmpt->sgnd_ = cmpt->sgnd_; - newcmpt->cps_ = cmpt->cps_; - newcmpt->type_ = cmpt->type_; - if (!(newcmpt->stream_ = jas_stream_memopen(0, 0))) { - return 0; - } - if (jas_stream_seek(cmpt->stream_, 0, SEEK_SET)) { - return 0; - } - if (jas_stream_copy(newcmpt->stream_, cmpt->stream_, -1)) { - return 0; - } - if (jas_stream_seek(newcmpt->stream_, 0, SEEK_SET)) { - return 0; - } - return newcmpt; + jas_image_cmpt_t *newcmpt; + + if (!(newcmpt = jas_image_cmpt_create0())) { + return 0; + } + newcmpt->tlx_ = cmpt->tlx_; + newcmpt->tly_ = cmpt->tly_; + newcmpt->hstep_ = cmpt->hstep_; + newcmpt->vstep_ = cmpt->vstep_; + newcmpt->width_ = cmpt->width_; + newcmpt->height_ = cmpt->height_; + newcmpt->prec_ = cmpt->prec_; + newcmpt->sgnd_ = cmpt->sgnd_; + newcmpt->cps_ = cmpt->cps_; + newcmpt->type_ = cmpt->type_; + if (!(newcmpt->stream_ = jas_stream_memopen(0, 0))) { + return 0; + } + if (jas_stream_seek(cmpt->stream_, 0, SEEK_SET)) { + return 0; + } + if (jas_stream_copy(newcmpt->stream_, cmpt->stream_, -1)) { + return 0; + } + if (jas_stream_seek(newcmpt->stream_, 0, SEEK_SET)) { + return 0; + } + return newcmpt; } void jas_image_destroy(jas_image_t *image) { - int i; + int i; - if (image->cmpts_) { - for (i = 0; i < image->numcmpts_; ++i) { - jas_image_cmpt_destroy(image->cmpts_[i]); - image->cmpts_[i] = 0; - } - jas_free(image->cmpts_); - } - jas_free(image); + if (image->cmpts_) { + for (i = 0; i < image->numcmpts_; ++i) { + jas_image_cmpt_destroy(image->cmpts_[i]); + image->cmpts_[i] = 0; + } + jas_free(image->cmpts_); + } + jas_free(image); } static jas_image_cmpt_t *jas_image_cmpt_create(uint_fast32_t tlx, uint_fast32_t tly, uint_fast32_t hstep, uint_fast32_t vstep, uint_fast32_t width, uint_fast32_t height, uint_fast16_t depth, bool sgnd, uint_fast32_t inmem) { - jas_image_cmpt_t *cmpt; - long size; - - if (!(cmpt = jas_malloc(sizeof(jas_image_cmpt_t)))) { - return 0; - } - - cmpt->tlx_ = tlx; - cmpt->tly_ = tly; - cmpt->hstep_ = hstep; - cmpt->vstep_ = vstep; - cmpt->width_ = width; - cmpt->height_ = height; - cmpt->prec_ = depth; - cmpt->sgnd_ = sgnd; - cmpt->stream_ = 0; - cmpt->cps_ = (depth + 7) / 8; - - size = cmpt->width_ * cmpt->height_ * cmpt->cps_; - cmpt->stream_ = (inmem) ? jas_stream_memopen(0, size) : jas_stream_tmpfile(); - if (!cmpt->stream_) { - jas_image_cmpt_destroy(cmpt); - return 0; - } - - /* Zero the component data. This isn't necessary, but it is - convenient for debugging purposes. */ - if (jas_stream_seek(cmpt->stream_, size - 1, SEEK_SET) < 0 || - jas_stream_putc(cmpt->stream_, 0) == EOF || - jas_stream_seek(cmpt->stream_, 0, SEEK_SET) < 0) { - jas_image_cmpt_destroy(cmpt); - return 0; - } - - return cmpt; + jas_image_cmpt_t *cmpt; + long size; + + if (!(cmpt = jas_malloc(sizeof(jas_image_cmpt_t)))) { + return 0; + } + + cmpt->tlx_ = tlx; + cmpt->tly_ = tly; + cmpt->hstep_ = hstep; + cmpt->vstep_ = vstep; + cmpt->width_ = width; + cmpt->height_ = height; + cmpt->prec_ = depth; + cmpt->sgnd_ = sgnd; + cmpt->stream_ = 0; + cmpt->cps_ = (depth + 7) / 8; + + size = cmpt->width_ * cmpt->height_ * cmpt->cps_; + cmpt->stream_ = (inmem) ? jas_stream_memopen(0, size) : jas_stream_tmpfile(); + if (!cmpt->stream_) { + jas_image_cmpt_destroy(cmpt); + return 0; + } + + /* Zero the component data. This isn't necessary, but it is + convenient for debugging purposes. */ + if (jas_stream_seek(cmpt->stream_, size - 1, SEEK_SET) < 0 || + jas_stream_putc(cmpt->stream_, 0) == EOF || + jas_stream_seek(cmpt->stream_, 0, SEEK_SET) < 0) { + jas_image_cmpt_destroy(cmpt); + return 0; + } + + return cmpt; } static void jas_image_cmpt_destroy(jas_image_cmpt_t *cmpt) { - if (cmpt->stream_) { - jas_stream_close(cmpt->stream_); - } - jas_free(cmpt); + if (cmpt->stream_) { + jas_stream_close(cmpt->stream_); + } + jas_free(cmpt); } /*****************************************************************************\ @@ -383,53 +383,53 @@ static void jas_image_cmpt_destroy(jas_image_cmpt_t *cmpt) void pmjas_image_decode(jas_stream_t * const in, - int const fmtArg, - const char * const optstr, - jas_image_t ** const imagePP, - const char ** const errorP) { + int const fmtArg, + const char * const optstr, + jas_image_t ** const imagePP, + const char ** const errorP) { /*---------------------------------------------------------------------------- Create an image from a stream in some specified format -----------------------------------------------------------------------------*/ - jas_image_fmtinfo_t *fmtinfo; - int fmt; - - /* If possible, try to determine the format of the input data. */ - if (fmtArg < 0) { - if ((fmt = jas_image_getfmt(in)) < 0) { - pm_asprintf(errorP, "jas_image_getfmt failed"); - return; - } - } else - fmt = fmtArg; - - if (!(fmtinfo = jas_image_lookupfmtbyid(fmt))) { - pm_asprintf(errorP, "jas_image_lookupfmtbyid of format %d failed", - fmt); - return; - } - { - const char * error; - - (*fmtinfo->ops.decode)(in, optstr, imagePP, &error); - if (error) { - pm_asprintf(errorP, "decoder failed. %s", error); - pm_strfree(error); - } else { - *errorP = NULL; - } - } + jas_image_fmtinfo_t *fmtinfo; + int fmt; + + /* If possible, try to determine the format of the input data. */ + if (fmtArg < 0) { + if ((fmt = jas_image_getfmt(in)) < 0) { + pm_asprintf(errorP, "jas_image_getfmt failed"); + return; + } + } else + fmt = fmtArg; + + if (!(fmtinfo = jas_image_lookupfmtbyid(fmt))) { + pm_asprintf(errorP, "jas_image_lookupfmtbyid of format %d failed", + fmt); + return; + } + { + const char * error; + + (*fmtinfo->ops.decode)(in, optstr, imagePP, &error); + if (error) { + pm_asprintf(errorP, "decoder failed. %s", error); + pm_strfree(error); + } else { + *errorP = NULL; + } + } } int jas_image_encode(jas_image_t *image, jas_stream_t *out, int fmt, char *optstr) { - jas_image_fmtinfo_t *fmtinfo; - if (!(fmtinfo = jas_image_lookupfmtbyid(fmt))) { - return -1; - } - return (fmtinfo->ops.encode) ? (*fmtinfo->ops.encode)(image, out, - optstr) : (-1); + jas_image_fmtinfo_t *fmtinfo; + if (!(fmtinfo = jas_image_lookupfmtbyid(fmt))) { + return -1; + } + return (fmtinfo->ops.encode) ? (*fmtinfo->ops.encode)(image, out, + optstr) : (-1); } /******************************************************************************\ @@ -439,137 +439,137 @@ int jas_image_encode(jas_image_t *image, jas_stream_t *out, int fmt, char *optst int jas_image_readcmpt(jas_image_t *image, uint_fast16_t cmptno, uint_fast32_t x, uint_fast32_t y, uint_fast32_t width, uint_fast32_t height, jas_matrix_t *data) { - jas_image_cmpt_t *cmpt; - uint_fast32_t i; - uint_fast32_t j; - int k; - jas_seqent_t v; - int c; - jas_seqent_t *dr; - jas_seqent_t *d; - int drs; - - if (cmptno >= image->numcmpts_) { - return -1; - } - - cmpt = image->cmpts_[cmptno]; - if (x >= cmpt->width_ || y >= cmpt->height_ || - x + width > cmpt->width_ || - y + height > cmpt->height_) { - return -1; - } - - if (jas_matrix_numrows(data) != height || jas_matrix_numcols(data) != width) { - if (jas_matrix_resize(data, height, width)) { - return -1; - } - } - - dr = jas_matrix_getref(data, 0, 0); - drs = jas_matrix_rowstep(data); - for (i = 0; i < height; ++i, dr += drs) { - d = dr; - if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x) - * cmpt->cps_, SEEK_SET) < 0) { - return -1; - } - for (j = width; j > 0; --j, ++d) { - v = 0; - for (k = cmpt->cps_; k > 0; --k) { - if ((c = jas_stream_getc(cmpt->stream_)) == EOF) { - return -1; - } - v = (v << 8) | (c & 0xff); - } - *d = bitstoint(v, cmpt->prec_, cmpt->sgnd_); - } - } - - return 0; + jas_image_cmpt_t *cmpt; + uint_fast32_t i; + uint_fast32_t j; + int k; + jas_seqent_t v; + int c; + jas_seqent_t *dr; + jas_seqent_t *d; + int drs; + + if (cmptno >= image->numcmpts_) { + return -1; + } + + cmpt = image->cmpts_[cmptno]; + if (x >= cmpt->width_ || y >= cmpt->height_ || + x + width > cmpt->width_ || + y + height > cmpt->height_) { + return -1; + } + + if (jas_matrix_numrows(data) != height || jas_matrix_numcols(data) != width) { + if (jas_matrix_resize(data, height, width)) { + return -1; + } + } + + dr = jas_matrix_getref(data, 0, 0); + drs = jas_matrix_rowstep(data); + for (i = 0; i < height; ++i, dr += drs) { + d = dr; + if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x) + * cmpt->cps_, SEEK_SET) < 0) { + return -1; + } + for (j = width; j > 0; --j, ++d) { + v = 0; + for (k = cmpt->cps_; k > 0; --k) { + if ((c = jas_stream_getc(cmpt->stream_)) == EOF) { + return -1; + } + v = (v << 8) | (c & 0xff); + } + *d = bitstoint(v, cmpt->prec_, cmpt->sgnd_); + } + } + + return 0; } #if 0 int_fast64_t jas_image_readcmpt1(jas_image_t *image, uint_fast16_t cmptno, uint_fast32_t x, uint_fast32_t y) { - jas_image_cmpt_t *cmpt; - int k; - int c; - int_fast64_t v; - cmpt = image->cmpts_[cmptno]; - if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * y + x) * cmpt->cps_, - SEEK_SET) < 0) { - goto error; - } - v = 0; - for (k = cmpt->cps_; k > 0; --k) { - if ((c = jas_stream_getc(cmpt->stream_)) == EOF) { - goto error; - } - v = (v << 8) | (c & 0xff); - } + jas_image_cmpt_t *cmpt; + int k; + int c; + int_fast64_t v; + cmpt = image->cmpts_[cmptno]; + if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * y + x) * cmpt->cps_, + SEEK_SET) < 0) { + goto error; + } + v = 0; + for (k = cmpt->cps_; k > 0; --k) { + if ((c = jas_stream_getc(cmpt->stream_)) == EOF) { + goto error; + } + v = (v << 8) | (c & 0xff); + } if (cmpt->sgnd_) { - abort(); + abort(); } - return v; + return v; error: - return 0; + return 0; } #endif int jas_image_writecmpt(jas_image_t *image, uint_fast16_t cmptno, uint_fast32_t x, uint_fast32_t y, uint_fast32_t width, uint_fast32_t height, jas_matrix_t *data) { - jas_image_cmpt_t *cmpt; - uint_fast32_t i; - uint_fast32_t j; - jas_seqent_t *d; - jas_seqent_t *dr; - int drs; - jas_seqent_t v; - int k; - int c; - - if (cmptno >= image->numcmpts_) { - return -1; - } - - cmpt = image->cmpts_[cmptno]; - if (x >= cmpt->width_ || y >= cmpt->height_ || - x + width > cmpt->width_ || - y + height > cmpt->height_) { - return -1; - } - - if (jas_matrix_numrows(data) != height || jas_matrix_numcols(data) != width) { - return -1; - } - - dr = jas_matrix_getref(data, 0, 0); - drs = jas_matrix_rowstep(data); - for (i = 0; i < height; ++i, dr += drs) { - d = dr; - if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x) - * cmpt->cps_, SEEK_SET) < 0) { - return -1; - } - for (j = width; j > 0; --j, ++d) { - v = inttobits(*d, cmpt->prec_, cmpt->sgnd_); - for (k = cmpt->cps_; k > 0; --k) { - c = (v >> (8 * (cmpt->cps_ - 1))) & 0xff; - if (jas_stream_putc(cmpt->stream_, - (unsigned char) c) == EOF) { - return -1; - } - v <<= 8; - } - } - } - - return 0; + jas_image_cmpt_t *cmpt; + uint_fast32_t i; + uint_fast32_t j; + jas_seqent_t *d; + jas_seqent_t *dr; + int drs; + jas_seqent_t v; + int k; + int c; + + if (cmptno >= image->numcmpts_) { + return -1; + } + + cmpt = image->cmpts_[cmptno]; + if (x >= cmpt->width_ || y >= cmpt->height_ || + x + width > cmpt->width_ || + y + height > cmpt->height_) { + return -1; + } + + if (jas_matrix_numrows(data) != height || jas_matrix_numcols(data) != width) { + return -1; + } + + dr = jas_matrix_getref(data, 0, 0); + drs = jas_matrix_rowstep(data); + for (i = 0; i < height; ++i, dr += drs) { + d = dr; + if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x) + * cmpt->cps_, SEEK_SET) < 0) { + return -1; + } + for (j = width; j > 0; --j, ++d) { + v = inttobits(*d, cmpt->prec_, cmpt->sgnd_); + for (k = cmpt->cps_; k > 0; --k) { + c = (v >> (8 * (cmpt->cps_ - 1))) & 0xff; + if (jas_stream_putc(cmpt->stream_, + (unsigned char) c) == EOF) { + return -1; + } + v <<= 8; + } + } + } + + return 0; } /******************************************************************************\ @@ -578,112 +578,112 @@ int jas_image_writecmpt(jas_image_t *image, uint_fast16_t cmptno, uint_fast32_t void jas_image_clearfmts() { - int i; - jas_image_fmtinfo_t *fmtinfo; - for (i = 0; i < jas_image_numfmts; ++i) { - fmtinfo = &jas_image_fmtinfos[i]; - if (fmtinfo->name) { - jas_free(fmtinfo->name); - fmtinfo->name = 0; - } - if (fmtinfo->ext) { - jas_free(fmtinfo->ext); - fmtinfo->ext = 0; - } - if (fmtinfo->desc) { - jas_free(fmtinfo->desc); - fmtinfo->desc = 0; - } - } - jas_image_numfmts = 0; -} - -int jas_image_addfmt(int id, const char *name, const char *ext, + int i; + jas_image_fmtinfo_t *fmtinfo; + for (i = 0; i < jas_image_numfmts; ++i) { + fmtinfo = &jas_image_fmtinfos[i]; + if (fmtinfo->name) { + jas_free(fmtinfo->name); + fmtinfo->name = 0; + } + if (fmtinfo->ext) { + jas_free(fmtinfo->ext); + fmtinfo->ext = 0; + } + if (fmtinfo->desc) { + jas_free(fmtinfo->desc); + fmtinfo->desc = 0; + } + } + jas_image_numfmts = 0; +} + +int jas_image_addfmt(int id, const char *name, const char *ext, const char *desc, jas_image_fmtops_t *ops) { - jas_image_fmtinfo_t *fmtinfo; - assert(id >= 0 && name && ext && ops); - if (jas_image_numfmts >= JAS_IMAGE_MAXFMTS) { - return -1; - } - fmtinfo = &jas_image_fmtinfos[jas_image_numfmts]; - fmtinfo->id = id; - if (!(fmtinfo->name = jas_strdup(name))) { - return -1; - } - if (!(fmtinfo->ext = jas_strdup(ext))) { - jas_free(fmtinfo->name); - return -1; - } - if (!(fmtinfo->desc = jas_strdup(desc))) { - jas_free(fmtinfo->name); - jas_free(fmtinfo->ext); - return -1; - } - fmtinfo->ops = *ops; - ++jas_image_numfmts; - return 0; + jas_image_fmtinfo_t *fmtinfo; + assert(id >= 0 && name && ext && ops); + if (jas_image_numfmts >= JAS_IMAGE_MAXFMTS) { + return -1; + } + fmtinfo = &jas_image_fmtinfos[jas_image_numfmts]; + fmtinfo->id = id; + if (!(fmtinfo->name = jas_strdup(name))) { + return -1; + } + if (!(fmtinfo->ext = jas_strdup(ext))) { + jas_free(fmtinfo->name); + return -1; + } + if (!(fmtinfo->desc = jas_strdup(desc))) { + jas_free(fmtinfo->name); + jas_free(fmtinfo->ext); + return -1; + } + fmtinfo->ops = *ops; + ++jas_image_numfmts; + return 0; } int jas_image_strtofmt(char *name) { - jas_image_fmtinfo_t *fmtinfo; - if (!(fmtinfo = jas_image_lookupfmtbyname(name))) { - return -1; - } - return fmtinfo->id; + jas_image_fmtinfo_t *fmtinfo; + if (!(fmtinfo = jas_image_lookupfmtbyname(name))) { + return -1; + } + return fmtinfo->id; } char *jas_image_fmttostr(int fmt) { - jas_image_fmtinfo_t *fmtinfo; - if (!(fmtinfo = jas_image_lookupfmtbyid(fmt))) { - return 0; - } - return fmtinfo->name; + jas_image_fmtinfo_t *fmtinfo; + if (!(fmtinfo = jas_image_lookupfmtbyid(fmt))) { + return 0; + } + return fmtinfo->name; } int jas_image_getfmt(jas_stream_t *in) { - jas_image_fmtinfo_t *fmtinfo; - int found; - int i; - - /* Check for data in each of the formats we know. */ - found = 0; - for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i, - ++fmtinfo) { - if (fmtinfo->ops.validate) { - /* Is the input data valid for this format? */ - if (!(*fmtinfo->ops.validate)(in)) { - found = 1; - break; - } - } - } - return found ? fmtinfo->id : (-1); + jas_image_fmtinfo_t *fmtinfo; + int found; + int i; + + /* Check for data in each of the formats we know. */ + found = 0; + for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i, + ++fmtinfo) { + if (fmtinfo->ops.validate) { + /* Is the input data valid for this format? */ + if (!(*fmtinfo->ops.validate)(in)) { + found = 1; + break; + } + } + } + return found ? fmtinfo->id : (-1); } int jas_image_fmtfromname(char *name) { - int i; - char *ext; - jas_image_fmtinfo_t *fmtinfo; - /* Get the file name extension. */ - if (!(ext = strrchr(name, '.'))) { - return -1; - } - ++ext; - /* Try to find a format that uses this extension. */ - for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i, - ++fmtinfo) { - /* Do we have a match? */ - if (!strcmp(ext, fmtinfo->ext)) { - return fmtinfo->id; - } - } - return -1; + int i; + char *ext; + jas_image_fmtinfo_t *fmtinfo; + /* Get the file name extension. */ + if (!(ext = strrchr(name, '.'))) { + return -1; + } + ++ext; + /* Try to find a format that uses this extension. */ + for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i, + ++fmtinfo) { + /* Do we have a match? */ + if (!strcmp(ext, fmtinfo->ext)) { + return fmtinfo->id; + } + } + return -1; } /*****************************************************************************\ @@ -710,71 +710,71 @@ jas_image_rawsize(jas_image_t * const imageP) { void jas_image_delcmpt(jas_image_t *image, uint_fast16_t cmptno) { - if (cmptno >= image->numcmpts_) { - return; - } - jas_image_cmpt_destroy(image->cmpts_[cmptno]); - if (cmptno < image->numcmpts_) { - memmove(&image->cmpts_[cmptno], &image->cmpts_[cmptno + 1], - (image->numcmpts_ - 1 - cmptno) * sizeof(jas_image_cmpt_t *)); - } - --image->numcmpts_; + if (cmptno >= image->numcmpts_) { + return; + } + jas_image_cmpt_destroy(image->cmpts_[cmptno]); + if (cmptno < image->numcmpts_) { + memmove(&image->cmpts_[cmptno], &image->cmpts_[cmptno + 1], + (image->numcmpts_ - 1 - cmptno) * sizeof(jas_image_cmpt_t *)); + } + --image->numcmpts_; - jas_image_setbbox(image); + jas_image_setbbox(image); } int jas_image_addcmpt(jas_image_t *image, uint_fast16_t cmptno, jas_image_cmptparm_t *cmptparm) { - jas_image_cmpt_t *newcmpt; - assert(cmptno <= image->numcmpts_); - if (image->numcmpts_ >= image->maxcmpts_) { - if (jas_image_growcmpts(image, image->maxcmpts_ + 128)) { - return -1; - } - } - if (!(newcmpt = jas_image_cmpt_create(cmptparm->tlx, - cmptparm->tly, cmptparm->hstep, cmptparm->vstep, - cmptparm->width, cmptparm->height, cmptparm->prec, - cmptparm->sgnd, 1))) { - return -1; - } - if (cmptno < image->numcmpts_) { - memmove(&image->cmpts_[cmptno + 1], &image->cmpts_[cmptno], - (image->numcmpts_ - cmptno) * sizeof(jas_image_cmpt_t *)); - } - image->cmpts_[cmptno] = newcmpt; - ++image->numcmpts_; - - jas_image_setbbox(image); - - return 0; + jas_image_cmpt_t *newcmpt; + assert(cmptno <= image->numcmpts_); + if (image->numcmpts_ >= image->maxcmpts_) { + if (jas_image_growcmpts(image, image->maxcmpts_ + 128)) { + return -1; + } + } + if (!(newcmpt = jas_image_cmpt_create(cmptparm->tlx, + cmptparm->tly, cmptparm->hstep, cmptparm->vstep, + cmptparm->width, cmptparm->height, cmptparm->prec, + cmptparm->sgnd, 1))) { + return -1; + } + if (cmptno < image->numcmpts_) { + memmove(&image->cmpts_[cmptno + 1], &image->cmpts_[cmptno], + (image->numcmpts_ - cmptno) * sizeof(jas_image_cmpt_t *)); + } + image->cmpts_[cmptno] = newcmpt; + ++image->numcmpts_; + + jas_image_setbbox(image); + + return 0; } jas_image_fmtinfo_t *jas_image_lookupfmtbyid(int id) { - int i; - jas_image_fmtinfo_t *fmtinfo; + int i; + jas_image_fmtinfo_t *fmtinfo; - for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i, ++fmtinfo) { - if (fmtinfo->id == id) { - return fmtinfo; - } - } - return 0; + for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i, ++fmtinfo) { + if (fmtinfo->id == id) { + return fmtinfo; + } + } + return 0; } jas_image_fmtinfo_t *jas_image_lookupfmtbyname(const char *name) { - int i; - jas_image_fmtinfo_t *fmtinfo; + int i; + jas_image_fmtinfo_t *fmtinfo; - for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i, ++fmtinfo) { - if (!strcmp(fmtinfo->name, name)) { - return fmtinfo; - } - } - return 0; + for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i, ++fmtinfo) { + if (!strcmp(fmtinfo->name, name)) { + return fmtinfo; + } + } + return 0; } @@ -783,220 +783,220 @@ jas_image_fmtinfo_t *jas_image_lookupfmtbyname(const char *name) static uint_fast32_t inttobits(jas_seqent_t v, int prec, bool sgnd) { - uint_fast32_t ret; - ret = ((sgnd && v < 0) ? ((1 << prec) + v) : v) & JAS_ONES(prec); - return ret; + uint_fast32_t ret; + ret = ((sgnd && v < 0) ? ((1 << prec) + v) : v) & JAS_ONES(prec); + return ret; } static jas_seqent_t bitstoint(uint_fast32_t v, int prec, bool sgnd) { - jas_seqent_t ret; - v &= JAS_ONES(prec); - ret = (sgnd && (v & (1 << (prec - 1)))) ? (v - (1 << prec)) : v; - return ret; + jas_seqent_t ret; + v &= JAS_ONES(prec); + ret = (sgnd && (v & (1 << (prec - 1)))) ? (v - (1 << prec)) : v; + return ret; } static void jas_image_setbbox(jas_image_t *image) { - jas_image_cmpt_t *cmpt; - int cmptno; - int_fast32_t x; - int_fast32_t y; - - if (image->numcmpts_ > 0) { - /* Determine the bounding box for all of the components on the - reference grid (i.e., the image area) */ - cmpt = image->cmpts_[0]; - image->tlx_ = cmpt->tlx_; - image->tly_ = cmpt->tly_; - image->brx_ = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1) + 1; - image->bry_ = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1) + 1; - for (cmptno = 1; cmptno < image->numcmpts_; ++cmptno) { - cmpt = image->cmpts_[cmptno]; - if (image->tlx_ > cmpt->tlx_) { - image->tlx_ = cmpt->tlx_; - } - if (image->tly_ > cmpt->tly_) { - image->tly_ = cmpt->tly_; - } - x = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1) + 1; - if (image->brx_ < x) { - image->brx_ = x; - } - y = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1) + 1; - if (image->bry_ < y) { - image->bry_ = y; - } - } - } else { - image->tlx_ = 0; - image->tly_ = 0; - image->brx_ = 0; - image->bry_ = 0; - } + jas_image_cmpt_t *cmpt; + int cmptno; + int_fast32_t x; + int_fast32_t y; + + if (image->numcmpts_ > 0) { + /* Determine the bounding box for all of the components on the + reference grid (i.e., the image area) */ + cmpt = image->cmpts_[0]; + image->tlx_ = cmpt->tlx_; + image->tly_ = cmpt->tly_; + image->brx_ = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1) + 1; + image->bry_ = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1) + 1; + for (cmptno = 1; cmptno < image->numcmpts_; ++cmptno) { + cmpt = image->cmpts_[cmptno]; + if (image->tlx_ > cmpt->tlx_) { + image->tlx_ = cmpt->tlx_; + } + if (image->tly_ > cmpt->tly_) { + image->tly_ = cmpt->tly_; + } + x = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1) + 1; + if (image->brx_ < x) { + image->brx_ = x; + } + y = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1) + 1; + if (image->bry_ < y) { + image->bry_ = y; + } + } + } else { + image->tlx_ = 0; + image->tly_ = 0; + image->brx_ = 0; + image->bry_ = 0; + } } static int jas_image_growcmpts(jas_image_t *image, int maxcmpts) { - jas_image_cmpt_t **newcmpts; - int cmptno; + jas_image_cmpt_t **newcmpts; + int cmptno; - newcmpts = (!image->cmpts_) ? jas_malloc(maxcmpts * sizeof(jas_image_cmpt_t *)) : - jas_realloc(image->cmpts_, maxcmpts * sizeof(jas_image_cmpt_t *)); - if (!newcmpts) { - return -1; - } - image->cmpts_ = newcmpts; - image->maxcmpts_ = maxcmpts; - for (cmptno = image->numcmpts_; cmptno < image->maxcmpts_; ++cmptno) { - image->cmpts_[cmptno] = 0; - } - return 0; + newcmpts = (!image->cmpts_) ? jas_malloc(maxcmpts * sizeof(jas_image_cmpt_t *)) : + jas_realloc(image->cmpts_, maxcmpts * sizeof(jas_image_cmpt_t *)); + if (!newcmpts) { + return -1; + } + image->cmpts_ = newcmpts; + image->maxcmpts_ = maxcmpts; + for (cmptno = image->numcmpts_; cmptno < image->maxcmpts_; ++cmptno) { + image->cmpts_[cmptno] = 0; + } + return 0; } int jas_image_copycmpt(jas_image_t *dstimage, int dstcmptno, jas_image_t *srcimage, int srccmptno) { - jas_image_cmpt_t *newcmpt; - if (dstimage->numcmpts_ >= dstimage->maxcmpts_) { - if (jas_image_growcmpts(dstimage, dstimage->maxcmpts_ + 128)) { - return -1; - } - } - if (!(newcmpt = jas_image_cmpt_copy(srcimage->cmpts_[srccmptno]))) { - return -1; - } - if (dstcmptno < dstimage->numcmpts_) { - memmove(&dstimage->cmpts_[dstcmptno + 1], &dstimage->cmpts_[dstcmptno], - (dstimage->numcmpts_ - dstcmptno) * sizeof(jas_image_cmpt_t *)); - } - dstimage->cmpts_[dstcmptno] = newcmpt; - ++dstimage->numcmpts_; - - jas_image_setbbox(dstimage); - return 0; + jas_image_cmpt_t *newcmpt; + if (dstimage->numcmpts_ >= dstimage->maxcmpts_) { + if (jas_image_growcmpts(dstimage, dstimage->maxcmpts_ + 128)) { + return -1; + } + } + if (!(newcmpt = jas_image_cmpt_copy(srcimage->cmpts_[srccmptno]))) { + return -1; + } + if (dstcmptno < dstimage->numcmpts_) { + memmove(&dstimage->cmpts_[dstcmptno + 1], &dstimage->cmpts_[dstcmptno], + (dstimage->numcmpts_ - dstcmptno) * sizeof(jas_image_cmpt_t *)); + } + dstimage->cmpts_[dstcmptno] = newcmpt; + ++dstimage->numcmpts_; + + jas_image_setbbox(dstimage); + return 0; } void jas_image_dump(jas_image_t *image, FILE *out) { - int cmptno; - jas_seq2d_t *data; - jas_image_cmpt_t *cmpt; - if (!(data = jas_seq2d_create(0, 0, 1, 1))) { - abort(); - } - for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) { - cmpt = image->cmpts_[cmptno]; - fprintf(out, "prec=%d sgnd=%d\n", (int)cmpt->prec_, cmpt->sgnd_); - if (jas_image_readcmpt(image, cmptno, 0, 0, 1, 1, data)) { - abort(); - } - fprintf(out, "tlsample %ld\n", (long) jas_seq2d_get(data, 0, 0)); - } - jas_seq2d_destroy(data); + int cmptno; + jas_seq2d_t *data; + jas_image_cmpt_t *cmpt; + if (!(data = jas_seq2d_create(0, 0, 1, 1))) { + abort(); + } + for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) { + cmpt = image->cmpts_[cmptno]; + fprintf(out, "prec=%d sgnd=%d\n", (int)cmpt->prec_, cmpt->sgnd_); + if (jas_image_readcmpt(image, cmptno, 0, 0, 1, 1, data)) { + abort(); + } + fprintf(out, "tlsample %ld\n", (long) jas_seq2d_get(data, 0, 0)); + } + jas_seq2d_destroy(data); } int jas_image_depalettize(jas_image_t *image, int cmptno, int numlutents, int_fast32_t *lutents, int dtype, int newcmptno) { - jas_image_cmptparm_t cmptparms; - int_fast32_t v; - int i; - int j; - jas_image_cmpt_t *cmpt; - - cmpt = image->cmpts_[cmptno]; - cmptparms.tlx = cmpt->tlx_; - cmptparms.tly = cmpt->tly_; - cmptparms.hstep = cmpt->hstep_; - cmptparms.vstep = cmpt->vstep_; - cmptparms.width = cmpt->width_; - cmptparms.height = cmpt->height_; - cmptparms.prec = JAS_IMAGE_CDT_GETPREC(dtype); - cmptparms.sgnd = JAS_IMAGE_CDT_GETSGND(dtype); - - if (numlutents < 1) { - return -1; - } - - if (jas_image_addcmpt(image, newcmptno, &cmptparms)) { - return -1; - } - if (newcmptno <= cmptno) { - ++cmptno; - cmpt = image->cmpts_[cmptno]; - } - - for (j = 0; j < cmpt->height_; ++j) { - for (i = 0; i < cmpt->width_; ++i) { - v = jas_image_readcmptsample(image, cmptno, i, j); - if (v < 0) { - v = 0; - } else if (v >= numlutents) { - v = numlutents - 1; - } - jas_image_writecmptsample(image, newcmptno, i, j, - lutents[v]); - } - } - return 0; + jas_image_cmptparm_t cmptparms; + int_fast32_t v; + int i; + int j; + jas_image_cmpt_t *cmpt; + + cmpt = image->cmpts_[cmptno]; + cmptparms.tlx = cmpt->tlx_; + cmptparms.tly = cmpt->tly_; + cmptparms.hstep = cmpt->hstep_; + cmptparms.vstep = cmpt->vstep_; + cmptparms.width = cmpt->width_; + cmptparms.height = cmpt->height_; + cmptparms.prec = JAS_IMAGE_CDT_GETPREC(dtype); + cmptparms.sgnd = JAS_IMAGE_CDT_GETSGND(dtype); + + if (numlutents < 1) { + return -1; + } + + if (jas_image_addcmpt(image, newcmptno, &cmptparms)) { + return -1; + } + if (newcmptno <= cmptno) { + ++cmptno; + cmpt = image->cmpts_[cmptno]; + } + + for (j = 0; j < cmpt->height_; ++j) { + for (i = 0; i < cmpt->width_; ++i) { + v = jas_image_readcmptsample(image, cmptno, i, j); + if (v < 0) { + v = 0; + } else if (v >= numlutents) { + v = numlutents - 1; + } + jas_image_writecmptsample(image, newcmptno, i, j, + lutents[v]); + } + } + return 0; } int jas_image_readcmptsample(jas_image_t *image, int cmptno, int x, int y) { - jas_image_cmpt_t *cmpt; - uint_fast32_t v; - int k; - int c; + jas_image_cmpt_t *cmpt; + uint_fast32_t v; + int k; + int c; - cmpt = image->cmpts_[cmptno]; + cmpt = image->cmpts_[cmptno]; - if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * y + x) * cmpt->cps_, - SEEK_SET) < 0) { - return -1; - } - v = 0; - for (k = cmpt->cps_; k > 0; --k) { - if ((c = jas_stream_getc(cmpt->stream_)) == EOF) { - return -1; - } - v = (v << 8) | (c & 0xff); - } - return bitstoint(v, cmpt->prec_, cmpt->sgnd_); + if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * y + x) * cmpt->cps_, + SEEK_SET) < 0) { + return -1; + } + v = 0; + for (k = cmpt->cps_; k > 0; --k) { + if ((c = jas_stream_getc(cmpt->stream_)) == EOF) { + return -1; + } + v = (v << 8) | (c & 0xff); + } + return bitstoint(v, cmpt->prec_, cmpt->sgnd_); } void jas_image_writecmptsample(jas_image_t *image, int cmptno, int x, int y, int_fast32_t v) { - jas_image_cmpt_t *cmpt; - uint_fast32_t t; - int k; - int c; + jas_image_cmpt_t *cmpt; + uint_fast32_t t; + int k; + int c; - cmpt = image->cmpts_[cmptno]; + cmpt = image->cmpts_[cmptno]; - if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * y + x) * cmpt->cps_, - SEEK_SET) < 0) { - return; - } - t = inttobits(v, cmpt->prec_, cmpt->sgnd_); - for (k = cmpt->cps_; k > 0; --k) { - c = (t >> (8 * (cmpt->cps_ - 1))) & 0xff; - if (jas_stream_putc(cmpt->stream_, (unsigned char) c) == EOF) { - return; - } - t <<= 8; - } + if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * y + x) * cmpt->cps_, + SEEK_SET) < 0) { + return; + } + t = inttobits(v, cmpt->prec_, cmpt->sgnd_); + for (k = cmpt->cps_; k > 0; --k) { + c = (t >> (8 * (cmpt->cps_ - 1))) & 0xff; + if (jas_stream_putc(cmpt->stream_, (unsigned char) c) == EOF) { + return; + } + t <<= 8; + } } int jas_image_getcmptbytype(jas_image_t *image, int ctype) { - int cmptno; + int cmptno; - for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) { - if (image->cmpts_[cmptno]->type_ == ctype) { - return cmptno; - } - } + for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) { + if (image->cmpts_[cmptno]->type_ == ctype) { + return cmptno; + } + } return -1; } diff --git a/converter/other/jpeg2000/libjasper/base/jas_init.c b/converter/other/jpeg2000/libjasper/base/jas_init.c index c1114bf7..8d79a7fe 100644 --- a/converter/other/jpeg2000/libjasper/base/jas_init.c +++ b/converter/other/jpeg2000/libjasper/base/jas_init.c @@ -4,14 +4,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -19,22 +19,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -54,17 +54,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -104,7 +104,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -123,78 +123,78 @@ /* Initialize the image format table. */ int jas_init() { - jas_image_fmtops_t fmtops; - int fmtid; + jas_image_fmtops_t fmtops; + int fmtid; - fmtid = 0; + fmtid = 0; #if !defined(EXCLUDE_MIF_SUPPORT) - fmtops.decode = mif_decode; - fmtops.encode = mif_encode; - fmtops.validate = mif_validate; - jas_image_addfmt(fmtid, "mif", "mif", "My Image Format (MIF)", &fmtops); - ++fmtid; + fmtops.decode = mif_decode; + fmtops.encode = mif_encode; + fmtops.validate = mif_validate; + jas_image_addfmt(fmtid, "mif", "mif", "My Image Format (MIF)", &fmtops); + ++fmtid; #endif #if !defined(EXCLUDE_PNM_SUPPORT) - fmtops.decode = pnm_decode; - fmtops.encode = pnm_encode; - fmtops.validate = pnm_validate; - jas_image_addfmt(fmtid, "pnm", "pnm", "Portable Graymap/Pixmap (PNM)", - &fmtops); - jas_image_addfmt(fmtid, "pnm", "pgm", "Portable Graymap/Pixmap (PNM)", - &fmtops); - jas_image_addfmt(fmtid, "pnm", "ppm", "Portable Graymap/Pixmap (PNM)", - &fmtops); - ++fmtid; + fmtops.decode = pnm_decode; + fmtops.encode = pnm_encode; + fmtops.validate = pnm_validate; + jas_image_addfmt(fmtid, "pnm", "pnm", "Portable Graymap/Pixmap (PNM)", + &fmtops); + jas_image_addfmt(fmtid, "pnm", "pgm", "Portable Graymap/Pixmap (PNM)", + &fmtops); + jas_image_addfmt(fmtid, "pnm", "ppm", "Portable Graymap/Pixmap (PNM)", + &fmtops); + ++fmtid; #endif #if !defined(EXCLUDE_BMP_SUPPORT) - fmtops.decode = bmp_decode; - fmtops.encode = bmp_encode; - fmtops.validate = bmp_validate; - jas_image_addfmt(fmtid, "bmp", "bmp", "Microsoft Bitmap (BMP)", &fmtops); - ++fmtid; + fmtops.decode = bmp_decode; + fmtops.encode = bmp_encode; + fmtops.validate = bmp_validate; + jas_image_addfmt(fmtid, "bmp", "bmp", "Microsoft Bitmap (BMP)", &fmtops); + ++fmtid; #endif #if !defined(EXCLUDE_RAS_SUPPORT) - fmtops.decode = ras_decode; - fmtops.encode = ras_encode; - fmtops.validate = ras_validate; - jas_image_addfmt(fmtid, "ras", "ras", "Sun Rasterfile (RAS)", &fmtops); - ++fmtid; + fmtops.decode = ras_decode; + fmtops.encode = ras_encode; + fmtops.validate = ras_validate; + jas_image_addfmt(fmtid, "ras", "ras", "Sun Rasterfile (RAS)", &fmtops); + ++fmtid; #endif #if !defined(EXCLUDE_JP2_SUPPORT) - fmtops.decode = jp2_decode; - fmtops.encode = jp2_encode; - fmtops.validate = jp2_validate; - jas_image_addfmt(fmtid, "jp2", "jp2", - "JPEG-2000 JP2 File Format Syntax (ISO/IEC 15444-1)", &fmtops); - ++fmtid; - fmtops.decode = jpc_decode; - fmtops.encode = jpc_encode; - fmtops.validate = jpc_validate; - jas_image_addfmt(fmtid, "jpc", "jpc", - "JPEG-2000 Code Stream Syntax (ISO/IEC 15444-1)", &fmtops); - ++fmtid; + fmtops.decode = jp2_decode; + fmtops.encode = jp2_encode; + fmtops.validate = jp2_validate; + jas_image_addfmt(fmtid, "jp2", "jp2", + "JPEG-2000 JP2 File Format Syntax (ISO/IEC 15444-1)", &fmtops); + ++fmtid; + fmtops.decode = jpc_decode; + fmtops.encode = jpc_encode; + fmtops.validate = jpc_validate; + jas_image_addfmt(fmtid, "jpc", "jpc", + "JPEG-2000 Code Stream Syntax (ISO/IEC 15444-1)", &fmtops); + ++fmtid; #endif #if !defined(EXCLUDE_JPG_SUPPORT) - fmtops.decode = jpg_decode; - fmtops.encode = jpg_encode; - fmtops.validate = jpg_validate; - jas_image_addfmt(fmtid, "jpg", "jpg", "JPEG (ISO/IEC 10918-1)", &fmtops); - ++fmtid; + fmtops.decode = jpg_decode; + fmtops.encode = jpg_encode; + fmtops.validate = jpg_validate; + jas_image_addfmt(fmtid, "jpg", "jpg", "JPEG (ISO/IEC 10918-1)", &fmtops); + ++fmtid; #endif #if !defined(EXCLUDE_PGX_SUPPORT) - fmtops.decode = pgx_decode; - fmtops.encode = pgx_encode; - fmtops.validate = pgx_validate; - jas_image_addfmt(fmtid, "pgx", "pgx", "JPEG-2000 VM Format (PGX)", &fmtops); - ++fmtid; + fmtops.decode = pgx_decode; + fmtops.encode = pgx_encode; + fmtops.validate = pgx_validate; + jas_image_addfmt(fmtid, "pgx", "pgx", "JPEG-2000 VM Format (PGX)", &fmtops); + ++fmtid; #endif - return 0; + return 0; } diff --git a/converter/other/jpeg2000/libjasper/base/jas_malloc.c b/converter/other/jpeg2000/libjasper/base/jas_malloc.c index 43c4d3cd..a8b85033 100644 --- a/converter/other/jpeg2000/libjasper/base/jas_malloc.c +++ b/converter/other/jpeg2000/libjasper/base/jas_malloc.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -139,29 +139,29 @@ void *jas_malloc(size_t size) { - return malloc(size); + return malloc(size); } void jas_free(void *ptr) { - free(ptr); + free(ptr); } void *jas_realloc(void *ptr, size_t size) { - return realloc(ptr, size); + return realloc(ptr, size); } void *jas_calloc(size_t nmemb, size_t size) { - void *ptr; - size_t n; - n = nmemb * size; - if (!(ptr = jas_malloc(n * sizeof(char)))) { - return 0; - } - memset(ptr, 0, n); - return ptr; + void *ptr; + size_t n; + n = nmemb * size; + if (!(ptr = jas_malloc(n * sizeof(char)))) { + return 0; + } + memset(ptr, 0, n); + return ptr; } #endif diff --git a/converter/other/jpeg2000/libjasper/base/jas_seq.c b/converter/other/jpeg2000/libjasper/base/jas_seq.c index 12dc1595..5aa2a75f 100644 --- a/converter/other/jpeg2000/libjasper/base/jas_seq.c +++ b/converter/other/jpeg2000/libjasper/base/jas_seq.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -134,108 +134,108 @@ jas_matrix_t *jas_seq2d_create(int xstart, int ystart, int xend, int yend) { - jas_matrix_t *matrix; - assert(xstart <= xend && ystart <= yend); - if (!(matrix = jas_matrix_create(yend - ystart, xend - xstart))) { - return 0; - } - matrix->xstart_ = xstart; - matrix->ystart_ = ystart; - matrix->xend_ = xend; - matrix->yend_ = yend; - return matrix; + jas_matrix_t *matrix; + assert(xstart <= xend && ystart <= yend); + if (!(matrix = jas_matrix_create(yend - ystart, xend - xstart))) { + return 0; + } + matrix->xstart_ = xstart; + matrix->ystart_ = ystart; + matrix->xend_ = xend; + matrix->yend_ = yend; + return matrix; } jas_matrix_t *jas_matrix_create(int numrows, int numcols) { - jas_matrix_t *matrix; - int i; - - if (!(matrix = jas_malloc(sizeof(jas_matrix_t)))) { - return 0; - } - matrix->flags_ = 0; - matrix->numrows_ = numrows; - matrix->numcols_ = numcols; - matrix->rows_ = 0; - matrix->maxrows_ = numrows; - matrix->data_ = 0; - matrix->datasize_ = numrows * numcols; - - if (matrix->maxrows_ > 0) { - if (!(matrix->rows_ = jas_malloc(matrix->maxrows_ * - sizeof(jas_seqent_t *)))) { - jas_matrix_destroy(matrix); - return 0; - } - } - - if (matrix->datasize_ > 0) { - if (!(matrix->data_ = jas_malloc(matrix->datasize_ * - sizeof(jas_seqent_t)))) { - jas_matrix_destroy(matrix); - return 0; - } - } - - for (i = 0; i < numrows; ++i) { - matrix->rows_[i] = &matrix->data_[i * matrix->numcols_]; - } - - for (i = 0; i < matrix->datasize_; ++i) { - matrix->data_[i] = 0; - } - - matrix->xstart_ = 0; - matrix->ystart_ = 0; - matrix->xend_ = matrix->numcols_; - matrix->yend_ = matrix->numrows_; - - return matrix; + jas_matrix_t *matrix; + int i; + + if (!(matrix = jas_malloc(sizeof(jas_matrix_t)))) { + return 0; + } + matrix->flags_ = 0; + matrix->numrows_ = numrows; + matrix->numcols_ = numcols; + matrix->rows_ = 0; + matrix->maxrows_ = numrows; + matrix->data_ = 0; + matrix->datasize_ = numrows * numcols; + + if (matrix->maxrows_ > 0) { + if (!(matrix->rows_ = jas_malloc(matrix->maxrows_ * + sizeof(jas_seqent_t *)))) { + jas_matrix_destroy(matrix); + return 0; + } + } + + if (matrix->datasize_ > 0) { + if (!(matrix->data_ = jas_malloc(matrix->datasize_ * + sizeof(jas_seqent_t)))) { + jas_matrix_destroy(matrix); + return 0; + } + } + + for (i = 0; i < numrows; ++i) { + matrix->rows_[i] = &matrix->data_[i * matrix->numcols_]; + } + + for (i = 0; i < matrix->datasize_; ++i) { + matrix->data_[i] = 0; + } + + matrix->xstart_ = 0; + matrix->ystart_ = 0; + matrix->xend_ = matrix->numcols_; + matrix->yend_ = matrix->numrows_; + + return matrix; } void jas_matrix_destroy(jas_matrix_t *matrix) { - if (matrix->data_) { - assert(!(matrix->flags_ & JAS_MATRIX_REF)); - jas_free(matrix->data_); - matrix->data_ = 0; - } - if (matrix->rows_) { - jas_free(matrix->rows_); - matrix->rows_ = 0; - } - jas_free(matrix); + if (matrix->data_) { + assert(!(matrix->flags_ & JAS_MATRIX_REF)); + jas_free(matrix->data_); + matrix->data_ = 0; + } + if (matrix->rows_) { + jas_free(matrix->rows_); + matrix->rows_ = 0; + } + jas_free(matrix); } jas_seq2d_t *jas_seq2d_copy(jas_seq2d_t *x) { - jas_matrix_t *y; - int i; - int j; - y = jas_seq2d_create(jas_seq2d_xstart(x), jas_seq2d_ystart(x), jas_seq2d_xend(x), - jas_seq2d_yend(x)); - assert(y); - for (i = 0; i < x->numrows_; ++i) { - for (j = 0; j < x->numcols_; ++j) { - *jas_matrix_getref(y, i, j) = jas_matrix_get(x, i, j); - } - } - return y; + jas_matrix_t *y; + int i; + int j; + y = jas_seq2d_create(jas_seq2d_xstart(x), jas_seq2d_ystart(x), jas_seq2d_xend(x), + jas_seq2d_yend(x)); + assert(y); + for (i = 0; i < x->numrows_; ++i) { + for (j = 0; j < x->numcols_; ++j) { + *jas_matrix_getref(y, i, j) = jas_matrix_get(x, i, j); + } + } + return y; } jas_matrix_t *jas_matrix_copy(jas_matrix_t *x) { - jas_matrix_t *y; - int i; - int j; - y = jas_matrix_create(x->numrows_, x->numcols_); - for (i = 0; i < x->numrows_; ++i) { - for (j = 0; j < x->numcols_; ++j) { - *jas_matrix_getref(y, i, j) = jas_matrix_get(x, i, j); - } - } - return y; + jas_matrix_t *y; + int i; + int j; + y = jas_matrix_create(x->numrows_, x->numcols_); + for (i = 0; i < x->numrows_; ++i) { + for (j = 0; j < x->numcols_; ++j) { + *jas_matrix_getref(y, i, j) = jas_matrix_get(x, i, j); + } + } + return y; } /******************************************************************************\ @@ -245,39 +245,39 @@ jas_matrix_t *jas_matrix_copy(jas_matrix_t *x) void jas_seq2d_bindsub(jas_matrix_t *s, jas_matrix_t *s1, int xstart, int ystart, int xend, int yend) { - jas_matrix_bindsub(s, s1, ystart - s1->ystart_, xstart - s1->xstart_, - yend - s1->ystart_ - 1, xend - s1->xstart_ - 1); + jas_matrix_bindsub(s, s1, ystart - s1->ystart_, xstart - s1->xstart_, + yend - s1->ystart_ - 1, xend - s1->xstart_ - 1); } void jas_matrix_bindsub(jas_matrix_t *mat0, jas_matrix_t *mat1, int r0, int c0, int r1, int c1) { - int i; - - if (mat0->data_) { - if (!(mat0->flags_ & JAS_MATRIX_REF)) { - jas_free(mat0->data_); - } - mat0->data_ = 0; - mat0->datasize_ = 0; - } - if (mat0->rows_) { - jas_free(mat0->rows_); - mat0->rows_ = 0; - } - mat0->flags_ |= JAS_MATRIX_REF; - mat0->numrows_ = r1 - r0 + 1; - mat0->numcols_ = c1 - c0 + 1; - mat0->maxrows_ = mat0->numrows_; - mat0->rows_ = jas_malloc(mat0->maxrows_ * sizeof(jas_seqent_t *)); - for (i = 0; i < mat0->numrows_; ++i) { - mat0->rows_[i] = mat1->rows_[r0 + i] + c0; - } - - mat0->xstart_ = mat1->xstart_ + c0; - mat0->ystart_ = mat1->ystart_ + r0; - mat0->xend_ = mat0->xstart_ + mat0->numcols_; - mat0->yend_ = mat0->ystart_ + mat0->numrows_; + int i; + + if (mat0->data_) { + if (!(mat0->flags_ & JAS_MATRIX_REF)) { + jas_free(mat0->data_); + } + mat0->data_ = 0; + mat0->datasize_ = 0; + } + if (mat0->rows_) { + jas_free(mat0->rows_); + mat0->rows_ = 0; + } + mat0->flags_ |= JAS_MATRIX_REF; + mat0->numrows_ = r1 - r0 + 1; + mat0->numcols_ = c1 - c0 + 1; + mat0->maxrows_ = mat0->numrows_; + mat0->rows_ = jas_malloc(mat0->maxrows_ * sizeof(jas_seqent_t *)); + for (i = 0; i < mat0->numrows_; ++i) { + mat0->rows_[i] = mat1->rows_[r0 + i] + c0; + } + + mat0->xstart_ = mat1->xstart_ + c0; + mat0->ystart_ = mat1->ystart_ + r0; + mat0->xend_ = mat0->xstart_ + mat0->numcols_; + mat0->yend_ = mat0->ystart_ + mat0->numrows_; } /******************************************************************************\ @@ -286,102 +286,102 @@ void jas_matrix_bindsub(jas_matrix_t *mat0, jas_matrix_t *mat1, int r0, int c0, int jas_matrix_cmp(jas_matrix_t *mat0, jas_matrix_t *mat1) { - int i; - int j; - - if (mat0->numrows_ != mat1->numrows_ || mat0->numcols_ != - mat1->numcols_) { - return 1; - } - for (i = 0; i < mat0->numrows_; i++) { - for (j = 0; j < mat0->numcols_; j++) { - if (jas_matrix_get(mat0, i, j) != jas_matrix_get(mat1, i, j)) { - return 1; - } - } - } - return 0; + int i; + int j; + + if (mat0->numrows_ != mat1->numrows_ || mat0->numcols_ != + mat1->numcols_) { + return 1; + } + for (i = 0; i < mat0->numrows_; i++) { + for (j = 0; j < mat0->numcols_; j++) { + if (jas_matrix_get(mat0, i, j) != jas_matrix_get(mat1, i, j)) { + return 1; + } + } + } + return 0; } void jas_matrix_divpow2(jas_matrix_t *matrix, int n) { - int i; - int j; - jas_seqent_t *rowstart; - int rowstep; - jas_seqent_t *data; - - rowstep = jas_matrix_rowstep(matrix); - for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i, - rowstart += rowstep) { - for (j = matrix->numcols_, data = rowstart; j > 0; --j, - ++data) { - *data = (*data >= 0) ? ((*data) >> n) : - (-((-(*data)) >> n)); - } - } + int i; + int j; + jas_seqent_t *rowstart; + int rowstep; + jas_seqent_t *data; + + rowstep = jas_matrix_rowstep(matrix); + for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i, + rowstart += rowstep) { + for (j = matrix->numcols_, data = rowstart; j > 0; --j, + ++data) { + *data = (*data >= 0) ? ((*data) >> n) : + (-((-(*data)) >> n)); + } + } } void jas_matrix_clip(jas_matrix_t *matrix, jas_seqent_t minval, jas_seqent_t maxval) { - int i; - int j; - jas_seqent_t v; - jas_seqent_t *rowstart; - jas_seqent_t *data; - int rowstep; - - rowstep = jas_matrix_rowstep(matrix); - for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i, - rowstart += rowstep) { - data = rowstart; - for (j = matrix->numcols_, data = rowstart; j > 0; --j, - ++data) { - v = *data; - if (v < minval) { - *data = minval; - } else if (v > maxval) { - *data = maxval; - } - } - } + int i; + int j; + jas_seqent_t v; + jas_seqent_t *rowstart; + jas_seqent_t *data; + int rowstep; + + rowstep = jas_matrix_rowstep(matrix); + for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i, + rowstart += rowstep) { + data = rowstart; + for (j = matrix->numcols_, data = rowstart; j > 0; --j, + ++data) { + v = *data; + if (v < minval) { + *data = minval; + } else if (v > maxval) { + *data = maxval; + } + } + } } void jas_matrix_asr(jas_matrix_t *matrix, int n) { - int i; - int j; - jas_seqent_t *rowstart; - int rowstep; - jas_seqent_t *data; - - assert(n >= 0); - rowstep = jas_matrix_rowstep(matrix); - for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i, - rowstart += rowstep) { - for (j = matrix->numcols_, data = rowstart; j > 0; --j, - ++data) { - *data >>= n; - } - } + int i; + int j; + jas_seqent_t *rowstart; + int rowstep; + jas_seqent_t *data; + + assert(n >= 0); + rowstep = jas_matrix_rowstep(matrix); + for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i, + rowstart += rowstep) { + for (j = matrix->numcols_, data = rowstart; j > 0; --j, + ++data) { + *data >>= n; + } + } } void jas_matrix_asl(jas_matrix_t *matrix, int n) { - int i; - int j; - jas_seqent_t *rowstart; - int rowstep; - jas_seqent_t *data; - - rowstep = jas_matrix_rowstep(matrix); - for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i, - rowstart += rowstep) { - for (j = matrix->numcols_, data = rowstart; j > 0; --j, - ++data) { - *data <<= n; - } - } + int i; + int j; + jas_seqent_t *rowstart; + int rowstep; + jas_seqent_t *data; + + rowstep = jas_matrix_rowstep(matrix); + for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i, + rowstart += rowstep) { + for (j = matrix->numcols_, data = rowstart; j > 0; --j, + ++data) { + *data <<= n; + } + } } /******************************************************************************\ @@ -390,87 +390,87 @@ void jas_matrix_asl(jas_matrix_t *matrix, int n) int jas_matrix_resize(jas_matrix_t *matrix, int numrows, int numcols) { - int size; - int i; + int size; + int i; - size = numrows * numcols; - if (size > matrix->datasize_ || numrows > matrix->maxrows_) { - return -1; - } + size = numrows * numcols; + if (size > matrix->datasize_ || numrows > matrix->maxrows_) { + return -1; + } - matrix->numrows_ = numrows; - matrix->numcols_ = numcols; + matrix->numrows_ = numrows; + matrix->numcols_ = numcols; - for (i = 0; i < numrows; ++i) { - matrix->rows_[i] = &matrix->data_[numcols * i]; - } + for (i = 0; i < numrows; ++i) { + matrix->rows_[i] = &matrix->data_[numcols * i]; + } - return 0; + return 0; } int jas_matrix_output(jas_matrix_t *matrix, FILE *out) { - int i; - int j; - jas_seqent_t x; + int i; + int j; + jas_seqent_t x; - fprintf(out, "%d %d\n", + fprintf(out, "%d %d\n", (int)jas_matrix_numrows(matrix), (int)jas_matrix_numcols(matrix)); - for (i = 0; i < jas_matrix_numrows(matrix); ++i) { - for (j = 0; j < jas_matrix_numcols(matrix); ++j) { - x = jas_matrix_get(matrix, i, j); - fprintf(out, "%ld", JAS_CAST(long, x)); - if (j < jas_matrix_numcols(matrix) - 1) { - fprintf(out, " "); - } - } - fprintf(out, "\n"); - } - return 0; + for (i = 0; i < jas_matrix_numrows(matrix); ++i) { + for (j = 0; j < jas_matrix_numcols(matrix); ++j) { + x = jas_matrix_get(matrix, i, j); + fprintf(out, "%ld", JAS_CAST(long, x)); + if (j < jas_matrix_numcols(matrix) - 1) { + fprintf(out, " "); + } + } + fprintf(out, "\n"); + } + return 0; } void jas_matrix_setall(jas_matrix_t *matrix, jas_seqent_t val) { - int i; - int j; - jas_seqent_t *rowstart; - int rowstep; - jas_seqent_t *data; - - rowstep = jas_matrix_rowstep(matrix); - for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i, - rowstart += rowstep) { - for (j = matrix->numcols_, data = rowstart; j > 0; --j, - ++data) { - *data = val; - } - } + int i; + int j; + jas_seqent_t *rowstart; + int rowstep; + jas_seqent_t *data; + + rowstep = jas_matrix_rowstep(matrix); + for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i, + rowstart += rowstep) { + for (j = matrix->numcols_, data = rowstart; j > 0; --j, + ++data) { + *data = val; + } + } } jas_matrix_t *jas_matrix_input(FILE *in) { - jas_matrix_t *matrix; - int i; - int j; - long x; - int numrows; - int numcols; - - if (fscanf(in, "%d %d", &numrows, &numcols) != 2) - return 0; - if (!(matrix = jas_matrix_create(numrows, numcols))) - return 0; - - /* Get matrix data. */ - for (i = 0; i < jas_matrix_numrows(matrix); i++) { - for (j = 0; j < jas_matrix_numcols(matrix); j++) { - if (fscanf(in, "%ld", &x) != 1) { - jas_matrix_destroy(matrix); - return 0; - } - jas_matrix_set(matrix, i, j, JAS_CAST(jas_seqent_t, x)); - } - } - - return matrix; + jas_matrix_t *matrix; + int i; + int j; + long x; + int numrows; + int numcols; + + if (fscanf(in, "%d %d", &numrows, &numcols) != 2) + return 0; + if (!(matrix = jas_matrix_create(numrows, numcols))) + return 0; + + /* Get matrix data. */ + for (i = 0; i < jas_matrix_numrows(matrix); i++) { + for (j = 0; j < jas_matrix_numcols(matrix); j++) { + if (fscanf(in, "%ld", &x) != 1) { + jas_matrix_destroy(matrix); + return 0; + } + jas_matrix_set(matrix, i, j, JAS_CAST(jas_seqent_t, x)); + } + } + + return matrix; } diff --git a/converter/other/jpeg2000/libjasper/base/jas_stream.c b/converter/other/jpeg2000/libjasper/base/jas_stream.c index a4b3a27c..d5ddcff2 100644 --- a/converter/other/jpeg2000/libjasper/base/jas_stream.c +++ b/converter/other/jpeg2000/libjasper/base/jas_stream.c @@ -169,24 +169,24 @@ static int file_close(jas_stream_obj_t *obj); \******************************************************************************/ static jas_stream_ops_t jas_stream_fileops = { - file_read, - file_write, - file_seek, - file_close + file_read, + file_write, + file_seek, + file_close }; static jas_stream_ops_t jas_stream_sfileops = { - sfile_read, - sfile_write, - sfile_seek, - sfile_close + sfile_read, + sfile_write, + sfile_seek, + sfile_close }; static jas_stream_ops_t jas_stream_memops = { - mem_read, - mem_write, - mem_seek, - mem_close + mem_read, + mem_write, + mem_seek, + mem_close }; /******************************************************************************\ @@ -195,214 +195,214 @@ static jas_stream_ops_t jas_stream_memops = { static jas_stream_t *jas_stream_create() { - jas_stream_t *stream; - - if (!(stream = jas_malloc(sizeof(jas_stream_t)))) { - return 0; - } - stream->openmode_ = 0; - stream->bufmode_ = 0; - stream->flags_ = 0; - stream->bufbase_ = 0; - stream->bufstart_ = 0; - stream->bufsize_ = 0; - stream->ptr_ = 0; - stream->cnt_ = 0; - stream->ops_ = 0; - stream->obj_ = 0; - stream->rwcnt_ = 0; - stream->rwlimit_ = -1; - - return stream; + jas_stream_t *stream; + + if (!(stream = jas_malloc(sizeof(jas_stream_t)))) { + return 0; + } + stream->openmode_ = 0; + stream->bufmode_ = 0; + stream->flags_ = 0; + stream->bufbase_ = 0; + stream->bufstart_ = 0; + stream->bufsize_ = 0; + stream->ptr_ = 0; + stream->cnt_ = 0; + stream->ops_ = 0; + stream->obj_ = 0; + stream->rwcnt_ = 0; + stream->rwlimit_ = -1; + + return stream; } jas_stream_t *jas_stream_memopen(char *buf, int bufsize) { - jas_stream_t *stream; - jas_stream_memobj_t *obj; - - if (!(stream = jas_stream_create())) { - return 0; - } - - /* A stream associated with a memory buffer is always opened - for both reading and writing in binary mode. */ - stream->openmode_ = JAS_STREAM_READ | JAS_STREAM_WRITE | JAS_STREAM_BINARY; - - /* Since the stream data is already resident in memory, buffering - is not necessary. */ - /* But... It still may be faster to use buffering anyways. */ - jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0); - - /* Select the operations for a memory stream. */ - stream->ops_ = &jas_stream_memops; - - /* Allocate memory for the underlying memory stream object. */ - if (!(obj = jas_malloc(sizeof(jas_stream_memobj_t)))) { - jas_stream_destroy(stream); - return 0; - } - stream->obj_ = (void *) obj; - - /* Initialize a few important members of the memory stream object. */ - obj->myalloc_ = 0; - obj->buf_ = 0; - - /* If the buffer size specified is nonpositive, then the buffer - is allocated internally and automatically grown as needed. */ - if (bufsize <= 0) { - obj->bufsize_ = 1024; - obj->growable_ = 1; - } else { - obj->bufsize_ = bufsize; - obj->growable_ = 0; - } - if (buf) { - obj->buf_ = (unsigned char *) buf; - } else { - obj->buf_ = jas_malloc(obj->bufsize_ * sizeof(char)); - obj->myalloc_ = 1; - } - if (!obj->buf_) { - jas_stream_close(stream); - return 0; - } - - if (bufsize > 0 && buf) { - /* If a buffer was supplied by the caller and its length is positive, - make the associated buffer data appear in the stream initially. */ - obj->len_ = bufsize; - } else { - /* The stream is initially empty. */ - obj->len_ = 0; - } - obj->pos_ = 0; - - return stream; + jas_stream_t *stream; + jas_stream_memobj_t *obj; + + if (!(stream = jas_stream_create())) { + return 0; + } + + /* A stream associated with a memory buffer is always opened + for both reading and writing in binary mode. */ + stream->openmode_ = JAS_STREAM_READ | JAS_STREAM_WRITE | JAS_STREAM_BINARY; + + /* Since the stream data is already resident in memory, buffering + is not necessary. */ + /* But... It still may be faster to use buffering anyways. */ + jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0); + + /* Select the operations for a memory stream. */ + stream->ops_ = &jas_stream_memops; + + /* Allocate memory for the underlying memory stream object. */ + if (!(obj = jas_malloc(sizeof(jas_stream_memobj_t)))) { + jas_stream_destroy(stream); + return 0; + } + stream->obj_ = (void *) obj; + + /* Initialize a few important members of the memory stream object. */ + obj->myalloc_ = 0; + obj->buf_ = 0; + + /* If the buffer size specified is nonpositive, then the buffer + is allocated internally and automatically grown as needed. */ + if (bufsize <= 0) { + obj->bufsize_ = 1024; + obj->growable_ = 1; + } else { + obj->bufsize_ = bufsize; + obj->growable_ = 0; + } + if (buf) { + obj->buf_ = (unsigned char *) buf; + } else { + obj->buf_ = jas_malloc(obj->bufsize_ * sizeof(char)); + obj->myalloc_ = 1; + } + if (!obj->buf_) { + jas_stream_close(stream); + return 0; + } + + if (bufsize > 0 && buf) { + /* If a buffer was supplied by the caller and its length is positive, + make the associated buffer data appear in the stream initially. */ + obj->len_ = bufsize; + } else { + /* The stream is initially empty. */ + obj->len_ = 0; + } + obj->pos_ = 0; + + return stream; } jas_stream_t *jas_stream_fopen(const char *filename, const char *mode) { - jas_stream_t *stream; - int *obj; - int openflags; - - /* Allocate a stream object. */ - if (!(stream = jas_stream_create())) { - return 0; - } - - /* Parse the mode string. */ - stream->openmode_ = jas_strtoopenmode(mode); - - /* Determine the correct flags to use for opening the file. */ - if ((stream->openmode_ & JAS_STREAM_READ) && - (stream->openmode_ & JAS_STREAM_WRITE)) { - openflags = O_RDWR; - } else if (stream->openmode_ & JAS_STREAM_READ) { - openflags = O_RDONLY; - } else if (stream->openmode_ & JAS_STREAM_WRITE) { - openflags = O_WRONLY; - } else { - openflags = 0; - } - if (stream->openmode_ & JAS_STREAM_APPEND) { - openflags |= O_APPEND; - } - if (stream->openmode_ & JAS_STREAM_BINARY) { - openflags |= O_BINARY; - } - if (stream->openmode_ & JAS_STREAM_CREATE) { - openflags |= O_CREAT | O_TRUNC; - } - - /* Allocate space for the underlying file stream object. */ - if (!(obj = jas_malloc(sizeof(int)))) { - jas_stream_destroy(stream); - return 0; - } - stream->obj_ = (void *) obj; - - /* Select the operations for a file stream object. */ - stream->ops_ = &jas_stream_fileops; - - /* Open the underlying file. */ - if ((*obj = open(filename, openflags, JAS_STREAM_PERMS)) < 0) { - jas_stream_destroy(stream); - return 0; - } - - /* By default, use full buffering for this type of stream. */ - jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0); - - return stream; + jas_stream_t *stream; + int *obj; + int openflags; + + /* Allocate a stream object. */ + if (!(stream = jas_stream_create())) { + return 0; + } + + /* Parse the mode string. */ + stream->openmode_ = jas_strtoopenmode(mode); + + /* Determine the correct flags to use for opening the file. */ + if ((stream->openmode_ & JAS_STREAM_READ) && + (stream->openmode_ & JAS_STREAM_WRITE)) { + openflags = O_RDWR; + } else if (stream->openmode_ & JAS_STREAM_READ) { + openflags = O_RDONLY; + } else if (stream->openmode_ & JAS_STREAM_WRITE) { + openflags = O_WRONLY; + } else { + openflags = 0; + } + if (stream->openmode_ & JAS_STREAM_APPEND) { + openflags |= O_APPEND; + } + if (stream->openmode_ & JAS_STREAM_BINARY) { + openflags |= O_BINARY; + } + if (stream->openmode_ & JAS_STREAM_CREATE) { + openflags |= O_CREAT | O_TRUNC; + } + + /* Allocate space for the underlying file stream object. */ + if (!(obj = jas_malloc(sizeof(int)))) { + jas_stream_destroy(stream); + return 0; + } + stream->obj_ = (void *) obj; + + /* Select the operations for a file stream object. */ + stream->ops_ = &jas_stream_fileops; + + /* Open the underlying file. */ + if ((*obj = open(filename, openflags, JAS_STREAM_PERMS)) < 0) { + jas_stream_destroy(stream); + return 0; + } + + /* By default, use full buffering for this type of stream. */ + jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0); + + return stream; } jas_stream_t *jas_stream_freopen(const char *path, const char *mode, FILE *fp) { - jas_stream_t *stream; - int openflags; - - /* Allocate a stream object. */ - if (!(stream = jas_stream_create())) { - return 0; - } - - /* Parse the mode string. */ - stream->openmode_ = jas_strtoopenmode(mode); - - /* Determine the correct flags to use for opening the file. */ - if ((stream->openmode_ & JAS_STREAM_READ) && - (stream->openmode_ & JAS_STREAM_WRITE)) { - openflags = O_RDWR; - } else if (stream->openmode_ & JAS_STREAM_READ) { - openflags = O_RDONLY; - } else if (stream->openmode_ & JAS_STREAM_WRITE) { - openflags = O_WRONLY; - } else { - openflags = 0; - } - if (stream->openmode_ & JAS_STREAM_APPEND) { - openflags |= O_APPEND; - } - if (stream->openmode_ & JAS_STREAM_BINARY) { - openflags |= O_BINARY; - } - if (stream->openmode_ & JAS_STREAM_CREATE) { - openflags |= O_CREAT | O_TRUNC; - } - - stream->obj_ = JAS_CAST(void *, fp); - - /* Select the operations for a file stream object. */ - stream->ops_ = &jas_stream_sfileops; - - /* By default, use full buffering for this type of stream. */ - jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0); - - return stream; + jas_stream_t *stream; + int openflags; + + /* Allocate a stream object. */ + if (!(stream = jas_stream_create())) { + return 0; + } + + /* Parse the mode string. */ + stream->openmode_ = jas_strtoopenmode(mode); + + /* Determine the correct flags to use for opening the file. */ + if ((stream->openmode_ & JAS_STREAM_READ) && + (stream->openmode_ & JAS_STREAM_WRITE)) { + openflags = O_RDWR; + } else if (stream->openmode_ & JAS_STREAM_READ) { + openflags = O_RDONLY; + } else if (stream->openmode_ & JAS_STREAM_WRITE) { + openflags = O_WRONLY; + } else { + openflags = 0; + } + if (stream->openmode_ & JAS_STREAM_APPEND) { + openflags |= O_APPEND; + } + if (stream->openmode_ & JAS_STREAM_BINARY) { + openflags |= O_BINARY; + } + if (stream->openmode_ & JAS_STREAM_CREATE) { + openflags |= O_CREAT | O_TRUNC; + } + + stream->obj_ = JAS_CAST(void *, fp); + + /* Select the operations for a file stream object. */ + stream->ops_ = &jas_stream_sfileops; + + /* By default, use full buffering for this type of stream. */ + jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0); + + return stream; } jas_stream_t *jas_stream_tmpfile() { - jas_stream_t *stream; - int *obj; + jas_stream_t *stream; + int *obj; - if (!(stream = jas_stream_create())) { - return 0; - } + if (!(stream = jas_stream_create())) { + return 0; + } - /* A temporary file stream is always opened for both reading and - writing in binary mode. */ - stream->openmode_ = JAS_STREAM_READ | JAS_STREAM_WRITE | JAS_STREAM_BINARY; + /* A temporary file stream is always opened for both reading and + writing in binary mode. */ + stream->openmode_ = JAS_STREAM_READ | JAS_STREAM_WRITE | JAS_STREAM_BINARY; - /* Allocate memory for the underlying temporary file object. */ - if (!(obj = jas_malloc(sizeof(int)))) { - jas_stream_destroy(stream); - return 0; - } - stream->obj_ = obj; + /* Allocate memory for the underlying temporary file object. */ + if (!(obj = jas_malloc(sizeof(int)))) { + jas_stream_destroy(stream); + return 0; + } + stream->obj_ = obj; { /* This is a Netpbm enhancement. Original Jasper library uses @@ -423,88 +423,88 @@ jas_stream_t *jas_stream_tmpfile() return 0; } } - /* Use full buffering. */ - jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0); + /* Use full buffering. */ + jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0); - stream->ops_ = &jas_stream_fileops; + stream->ops_ = &jas_stream_fileops; - return stream; + return stream; } jas_stream_t *jas_stream_fdopen(int fd, const char *mode) { - jas_stream_t *stream; - int *obj; + jas_stream_t *stream; + int *obj; - /* Allocate a stream object. */ - if (!(stream = jas_stream_create())) { - return 0; - } + /* Allocate a stream object. */ + if (!(stream = jas_stream_create())) { + return 0; + } - /* Parse the mode string. */ - stream->openmode_ = jas_strtoopenmode(mode); + /* Parse the mode string. */ + stream->openmode_ = jas_strtoopenmode(mode); #if defined(HAVE_SETMODE) && defined(O_BINARY) - /* Argh!!! Someone ought to banish text mode (i.e., O_TEXT) to the - greatest depths of purgatory! */ - /* Ensure that the file descriptor is in binary mode, if the caller - has specified the binary mode flag. Arguably, the caller ought to - take care of this, but text mode is a ugly wart anyways, so we save - the caller some grief by handling this within the stream library. */ - /* This ugliness is mainly for the benefit of those who run the - JasPer software under Windows from shells that insist on opening - files in text mode. For example, in the Cygwin environment, - shells often open files in text mode when I/O redirection is - used. Grr... */ - if (stream->openmode_ & JAS_STREAM_BINARY) { - setmode(fd, O_BINARY); - } + /* Argh!!! Someone ought to banish text mode (i.e., O_TEXT) to the + greatest depths of purgatory! */ + /* Ensure that the file descriptor is in binary mode, if the caller + has specified the binary mode flag. Arguably, the caller ought to + take care of this, but text mode is a ugly wart anyways, so we save + the caller some grief by handling this within the stream library. */ + /* This ugliness is mainly for the benefit of those who run the + JasPer software under Windows from shells that insist on opening + files in text mode. For example, in the Cygwin environment, + shells often open files in text mode when I/O redirection is + used. Grr... */ + if (stream->openmode_ & JAS_STREAM_BINARY) { + setmode(fd, O_BINARY); + } #endif - /* Allocate space for the underlying file stream object. */ - if (!(obj = jas_malloc(sizeof(int)))) { - jas_stream_destroy(stream); - return 0; - } - stream->obj_ = (void *) obj; - *obj = fd; + /* Allocate space for the underlying file stream object. */ + if (!(obj = jas_malloc(sizeof(int)))) { + jas_stream_destroy(stream); + return 0; + } + stream->obj_ = (void *) obj; + *obj = fd; - /* By default, use full buffering for this type of stream. */ - jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0); + /* By default, use full buffering for this type of stream. */ + jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0); - /* Select the operations for a file stream object. */ - stream->ops_ = &jas_stream_fileops; + /* Select the operations for a file stream object. */ + stream->ops_ = &jas_stream_fileops; /* Do not close the underlying file descriptor when the stream is closed. */ - stream->openmode_ |= JAS_STREAM_NOCLOSE; + stream->openmode_ |= JAS_STREAM_NOCLOSE; - return stream; + return stream; } static void jas_stream_destroy(jas_stream_t *stream) { - /* If the memory for the buffer was allocated with malloc, free - this memory. */ - if ((stream->bufmode_ & JAS_STREAM_FREEBUF) && stream->bufbase_) { - jas_free(stream->bufbase_); - stream->bufbase_ = 0; - } - jas_free(stream); + /* If the memory for the buffer was allocated with malloc, free + this memory. */ + if ((stream->bufmode_ & JAS_STREAM_FREEBUF) && stream->bufbase_) { + jas_free(stream->bufbase_); + stream->bufbase_ = 0; + } + jas_free(stream); } int jas_stream_close(jas_stream_t *stream) { - /* Flush buffer if necessary. */ - jas_stream_flush(stream); + /* Flush buffer if necessary. */ + jas_stream_flush(stream); - /* Close the underlying stream object. */ - if (!(stream->openmode_ & JAS_STREAM_NOCLOSE)) { - (*stream->ops_->close_)(stream->obj_); - } + /* Close the underlying stream object. */ + if (!(stream->openmode_ & JAS_STREAM_NOCLOSE)) { + (*stream->ops_->close_)(stream->obj_); + } - jas_stream_destroy(stream); + jas_stream_destroy(stream); - return 0; + return 0; } /******************************************************************************\ @@ -513,71 +513,71 @@ int jas_stream_close(jas_stream_t *stream) int jas_stream_getc_func(jas_stream_t *stream) { - assert(stream->ptr_ - stream->bufbase_ <= stream->bufsize_ + - JAS_STREAM_MAXPUTBACK); - return jas_stream_getc_macro(stream); + assert(stream->ptr_ - stream->bufbase_ <= stream->bufsize_ + + JAS_STREAM_MAXPUTBACK); + return jas_stream_getc_macro(stream); } int jas_stream_putc_func(jas_stream_t *stream, int c) { - assert(stream->ptr_ - stream->bufstart_ <= stream->bufsize_); - return jas_stream_putc_macro(stream, c); + assert(stream->ptr_ - stream->bufstart_ <= stream->bufsize_); + return jas_stream_putc_macro(stream, c); } int jas_stream_ungetc(jas_stream_t *stream, int c) { - if (!stream->ptr_ || stream->ptr_ == stream->bufbase_) { - return -1; - } - - /* Reset the EOF indicator (since we now have at least one character - to read). */ - stream->flags_ &= ~JAS_STREAM_EOF; - - --stream->rwcnt_; - --stream->ptr_; - ++stream->cnt_; - *stream->ptr_ = c; - return 0; + if (!stream->ptr_ || stream->ptr_ == stream->bufbase_) { + return -1; + } + + /* Reset the EOF indicator (since we now have at least one character + to read). */ + stream->flags_ &= ~JAS_STREAM_EOF; + + --stream->rwcnt_; + --stream->ptr_; + ++stream->cnt_; + *stream->ptr_ = c; + return 0; } int jas_stream_read(jas_stream_t *stream, void *buf, int cnt) { - int n; - int c; - char *bufptr; - - bufptr = buf; - - n = 0; - while (n < cnt) { - if ((c = jas_stream_getc(stream)) == EOF) { - return n; - } - *bufptr++ = c; - ++n; - } - - return n; + int n; + int c; + char *bufptr; + + bufptr = buf; + + n = 0; + while (n < cnt) { + if ((c = jas_stream_getc(stream)) == EOF) { + return n; + } + *bufptr++ = c; + ++n; + } + + return n; } int jas_stream_write(jas_stream_t *stream, const void *buf, int cnt) { - int n; - const char *bufptr; - - bufptr = buf; - - n = 0; - while (n < cnt) { - if (jas_stream_putc(stream, *bufptr) == EOF) { - return n; - } - ++bufptr; - ++n; - } + int n; + const char *bufptr; + + bufptr = buf; + + n = 0; + while (n < cnt) { + if (jas_stream_putc(stream, *bufptr) == EOF) { + return n; + } + ++bufptr; + ++n; + } - return n; + return n; } /* Note: This function uses a fixed size buffer. Therefore, it cannot @@ -585,59 +585,59 @@ int jas_stream_write(jas_stream_t *stream, const void *buf, int cnt) by the buffer. */ int jas_stream_printf(jas_stream_t *stream, const char *fmt, ...) { - va_list ap; - char buf[4096]; - int ret; - - va_start(ap, fmt); - ret = vsprintf(buf, fmt, ap); - jas_stream_puts(stream, buf); - va_end(ap); - return ret; + va_list ap; + char buf[4096]; + int ret; + + va_start(ap, fmt); + ret = vsprintf(buf, fmt, ap); + jas_stream_puts(stream, buf); + va_end(ap); + return ret; } int jas_stream_puts(jas_stream_t *stream, const char *s) { - while (*s != '\0') { - if (jas_stream_putc_macro(stream, *s) == EOF) { - return -1; - } - ++s; - } - return 0; + while (*s != '\0') { + if (jas_stream_putc_macro(stream, *s) == EOF) { + return -1; + } + ++s; + } + return 0; } char *jas_stream_gets(jas_stream_t *stream, char *buf, int bufsize) { - int c; - char *bufptr; - assert(bufsize > 0); - - bufptr = buf; - while (bufsize > 1) { - if ((c = jas_stream_getc(stream)) == EOF) { - break; - } - *bufptr++ = c; - --bufsize; - if (c == '\n') { - break; - } - } - *bufptr = '\0'; - return buf; + int c; + char *bufptr; + assert(bufsize > 0); + + bufptr = buf; + while (bufsize > 1) { + if ((c = jas_stream_getc(stream)) == EOF) { + break; + } + *bufptr++ = c; + --bufsize; + if (c == '\n') { + break; + } + } + *bufptr = '\0'; + return buf; } int jas_stream_gobble(jas_stream_t *stream, int n) { - int m; - m = n; - for (m = n; m > 0; --m) { - if (jas_stream_getc(stream) == EOF) { - return n - m; - } - } - return n; + int m; + m = n; + for (m = n; m > 0; --m) { + if (jas_stream_getc(stream) == EOF) { + return n - m; + } + } + return n; } /******************************************************************************\ @@ -646,73 +646,73 @@ int jas_stream_gobble(jas_stream_t *stream, int n) int jas_stream_isseekable(jas_stream_t *stream) { - if (stream->ops_ == &jas_stream_memops) { - return 1; - } else if (stream->ops_ == &jas_stream_fileops) { - if ((*stream->ops_->seek_)(stream->obj_, 0, SEEK_CUR) < 0) { - return 0; - } - return 1; - } else { - return 0; - } + if (stream->ops_ == &jas_stream_memops) { + return 1; + } else if (stream->ops_ == &jas_stream_fileops) { + if ((*stream->ops_->seek_)(stream->obj_, 0, SEEK_CUR) < 0) { + return 0; + } + return 1; + } else { + return 0; + } } int jas_stream_rewind(jas_stream_t *stream) { - return jas_stream_seek(stream, 0, SEEK_SET); + return jas_stream_seek(stream, 0, SEEK_SET); } long jas_stream_seek(jas_stream_t *stream, long offset, int origin) { - long newpos; - - /* The buffer cannot be in use for both reading and writing. */ - assert(!((stream->bufmode_ & JAS_STREAM_RDBUF) && (stream->bufmode_ & - JAS_STREAM_WRBUF))); - - /* Reset the EOF indicator (since we may not be at the EOF anymore). */ - stream->flags_ &= ~JAS_STREAM_EOF; - - if (stream->bufmode_ & JAS_STREAM_RDBUF) { - if (origin == SEEK_CUR) { - offset -= stream->cnt_; - } - } else if (stream->bufmode_ & JAS_STREAM_WRBUF) { - if (jas_stream_flush(stream)) { - return -1; - } - } - stream->cnt_ = 0; - stream->ptr_ = stream->bufstart_; - stream->bufmode_ &= ~(JAS_STREAM_RDBUF | JAS_STREAM_WRBUF); - - if ((newpos = (*stream->ops_->seek_)(stream->obj_, offset, origin)) - < 0) { - return -1; - } - - return newpos; + long newpos; + + /* The buffer cannot be in use for both reading and writing. */ + assert(!((stream->bufmode_ & JAS_STREAM_RDBUF) && (stream->bufmode_ & + JAS_STREAM_WRBUF))); + + /* Reset the EOF indicator (since we may not be at the EOF anymore). */ + stream->flags_ &= ~JAS_STREAM_EOF; + + if (stream->bufmode_ & JAS_STREAM_RDBUF) { + if (origin == SEEK_CUR) { + offset -= stream->cnt_; + } + } else if (stream->bufmode_ & JAS_STREAM_WRBUF) { + if (jas_stream_flush(stream)) { + return -1; + } + } + stream->cnt_ = 0; + stream->ptr_ = stream->bufstart_; + stream->bufmode_ &= ~(JAS_STREAM_RDBUF | JAS_STREAM_WRBUF); + + if ((newpos = (*stream->ops_->seek_)(stream->obj_, offset, origin)) + < 0) { + return -1; + } + + return newpos; } long jas_stream_tell(jas_stream_t *stream) { - int adjust; - int offset; - - if (stream->bufmode_ & JAS_STREAM_RDBUF) { - adjust = -stream->cnt_; - } else if (stream->bufmode_ & JAS_STREAM_WRBUF) { - adjust = stream->ptr_ - stream->bufstart_; - } else { - adjust = 0; - } - - if ((offset = (*stream->ops_->seek_)(stream->obj_, 0, SEEK_CUR)) < 0) { - return -1; - } - - return offset + adjust; + int adjust; + int offset; + + if (stream->bufmode_ & JAS_STREAM_RDBUF) { + adjust = -stream->cnt_; + } else if (stream->bufmode_ & JAS_STREAM_WRBUF) { + adjust = stream->ptr_ - stream->bufstart_; + } else { + adjust = 0; + } + + if ((offset = (*stream->ops_->seek_)(stream->obj_, 0, SEEK_CUR)) < 0) { + return -1; + } + + return offset + adjust; } /******************************************************************************\ @@ -722,45 +722,45 @@ long jas_stream_tell(jas_stream_t *stream) static void jas_stream_initbuf(jas_stream_t *stream, int bufmode, char *buf, int bufsize) { - /* If this function is being called, the buffer should not have been - initialized yet. */ - assert(!stream->bufbase_); - - if (bufmode != JAS_STREAM_UNBUF) { - /* The full- or line-buffered mode is being employed. */ - if (!buf) { - /* The caller has not specified a buffer to employ, so allocate - one. */ - if ((stream->bufbase_ = jas_malloc(JAS_STREAM_BUFSIZE + - JAS_STREAM_MAXPUTBACK))) { - stream->bufmode_ |= JAS_STREAM_FREEBUF; - stream->bufsize_ = JAS_STREAM_BUFSIZE; - } else { - /* The buffer allocation has failed. Resort to unbuffered - operation. */ - stream->bufbase_ = stream->tinybuf_; - stream->bufsize_ = 1; - } - } else { - /* The caller has specified a buffer to employ. */ - /* The buffer must be large enough to accommodate maximum - putback. */ - assert(bufsize > JAS_STREAM_MAXPUTBACK); - stream->bufbase_ = JAS_CAST(unsigned char *, buf); - stream->bufsize_ = bufsize - JAS_STREAM_MAXPUTBACK; - } - } else { - /* The unbuffered mode is being employed. */ - /* A buffer should not have been supplied by the caller. */ - assert(!buf); - /* Use a trivial one-character buffer. */ - stream->bufbase_ = stream->tinybuf_; - stream->bufsize_ = 1; - } - stream->bufstart_ = &stream->bufbase_[JAS_STREAM_MAXPUTBACK]; - stream->ptr_ = stream->bufstart_; - stream->cnt_ = 0; - stream->bufmode_ |= bufmode & JAS_STREAM_BUFMODEMASK; + /* If this function is being called, the buffer should not have been + initialized yet. */ + assert(!stream->bufbase_); + + if (bufmode != JAS_STREAM_UNBUF) { + /* The full- or line-buffered mode is being employed. */ + if (!buf) { + /* The caller has not specified a buffer to employ, so allocate + one. */ + if ((stream->bufbase_ = jas_malloc(JAS_STREAM_BUFSIZE + + JAS_STREAM_MAXPUTBACK))) { + stream->bufmode_ |= JAS_STREAM_FREEBUF; + stream->bufsize_ = JAS_STREAM_BUFSIZE; + } else { + /* The buffer allocation has failed. Resort to unbuffered + operation. */ + stream->bufbase_ = stream->tinybuf_; + stream->bufsize_ = 1; + } + } else { + /* The caller has specified a buffer to employ. */ + /* The buffer must be large enough to accommodate maximum + putback. */ + assert(bufsize > JAS_STREAM_MAXPUTBACK); + stream->bufbase_ = JAS_CAST(unsigned char *, buf); + stream->bufsize_ = bufsize - JAS_STREAM_MAXPUTBACK; + } + } else { + /* The unbuffered mode is being employed. */ + /* A buffer should not have been supplied by the caller. */ + assert(!buf); + /* Use a trivial one-character buffer. */ + stream->bufbase_ = stream->tinybuf_; + stream->bufsize_ = 1; + } + stream->bufstart_ = &stream->bufbase_[JAS_STREAM_MAXPUTBACK]; + stream->ptr_ = stream->bufstart_; + stream->cnt_ = 0; + stream->bufmode_ |= bufmode & JAS_STREAM_BUFMODEMASK; } /******************************************************************************\ @@ -769,97 +769,97 @@ static void jas_stream_initbuf(jas_stream_t *stream, int bufmode, char *buf, int jas_stream_flush(jas_stream_t *stream) { - if (stream->bufmode_ & JAS_STREAM_RDBUF) { - return 0; - } - return jas_stream_flushbuf(stream, EOF); + if (stream->bufmode_ & JAS_STREAM_RDBUF) { + return 0; + } + return jas_stream_flushbuf(stream, EOF); } int jas_stream_fillbuf(jas_stream_t *stream, int getflag) { - int c; - - /* The stream must not be in an error or EOF state. */ - if ((stream->flags_ & (JAS_STREAM_ERRMASK)) != 0) { - return EOF; - } - - /* The stream must be open for reading. */ - if ((stream->openmode_ & JAS_STREAM_READ) == 0) { - return EOF; - } - - /* Make a half-hearted attempt to confirm that the buffer is not - currently being used for writing. This check is not intended - to be foolproof! */ - assert((stream->bufmode_ & JAS_STREAM_WRBUF) == 0); - - assert(stream->ptr_ - stream->bufstart_ <= stream->bufsize_); - - /* Mark the buffer as being used for reading. */ - stream->bufmode_ |= JAS_STREAM_RDBUF; - - /* Read new data into the buffer. */ - stream->ptr_ = stream->bufstart_; - if ((stream->cnt_ = (*stream->ops_->read_)(stream->obj_, - (char *) stream->bufstart_, stream->bufsize_)) <= 0) { - if (stream->cnt_ < 0) { - stream->flags_ |= JAS_STREAM_ERR; - } else { - stream->flags_ |= JAS_STREAM_EOF; - } - stream->cnt_ = 0; - return EOF; - } - - assert(stream->cnt_ > 0); - /* Get or peek at the first character in the buffer. */ - c = (getflag) ? jas_stream_getc2(stream) : (*stream->ptr_); - - return c; + int c; + + /* The stream must not be in an error or EOF state. */ + if ((stream->flags_ & (JAS_STREAM_ERRMASK)) != 0) { + return EOF; + } + + /* The stream must be open for reading. */ + if ((stream->openmode_ & JAS_STREAM_READ) == 0) { + return EOF; + } + + /* Make a half-hearted attempt to confirm that the buffer is not + currently being used for writing. This check is not intended + to be foolproof! */ + assert((stream->bufmode_ & JAS_STREAM_WRBUF) == 0); + + assert(stream->ptr_ - stream->bufstart_ <= stream->bufsize_); + + /* Mark the buffer as being used for reading. */ + stream->bufmode_ |= JAS_STREAM_RDBUF; + + /* Read new data into the buffer. */ + stream->ptr_ = stream->bufstart_; + if ((stream->cnt_ = (*stream->ops_->read_)(stream->obj_, + (char *) stream->bufstart_, stream->bufsize_)) <= 0) { + if (stream->cnt_ < 0) { + stream->flags_ |= JAS_STREAM_ERR; + } else { + stream->flags_ |= JAS_STREAM_EOF; + } + stream->cnt_ = 0; + return EOF; + } + + assert(stream->cnt_ > 0); + /* Get or peek at the first character in the buffer. */ + c = (getflag) ? jas_stream_getc2(stream) : (*stream->ptr_); + + return c; } int jas_stream_flushbuf(jas_stream_t *stream, int c) { - int len; - int n; - - /* The stream should not be in an error or EOF state. */ - if ((stream->flags_ & (JAS_STREAM_ERRMASK)) != 0) { - return EOF; - } - - /* The stream must be open for writing. */ - if ((stream->openmode_ & (JAS_STREAM_WRITE | JAS_STREAM_APPEND)) == 0) { - return EOF; - } - - /* The buffer should not currently be in use for reading. */ - assert(!(stream->bufmode_ & JAS_STREAM_RDBUF)); - - /* Note: Do not use the quantity stream->cnt to determine the number - of characters in the buffer! Depending on how this function was - called, the stream->cnt value may be "off-by-one". */ - len = stream->ptr_ - stream->bufstart_; - if (len > 0) { - n = (*stream->ops_->write_)(stream->obj_, (char *) - stream->bufstart_, len); - if (n != len) { - stream->flags_ |= JAS_STREAM_ERR; - return EOF; - } - } - stream->cnt_ = stream->bufsize_; - stream->ptr_ = stream->bufstart_; - - stream->bufmode_ |= JAS_STREAM_WRBUF; - - if (c != EOF) { - assert(stream->cnt_ > 0); - jas_stream_putc2(stream, c); - } - - return 0; + int len; + int n; + + /* The stream should not be in an error or EOF state. */ + if ((stream->flags_ & (JAS_STREAM_ERRMASK)) != 0) { + return EOF; + } + + /* The stream must be open for writing. */ + if ((stream->openmode_ & (JAS_STREAM_WRITE | JAS_STREAM_APPEND)) == 0) { + return EOF; + } + + /* The buffer should not currently be in use for reading. */ + assert(!(stream->bufmode_ & JAS_STREAM_RDBUF)); + + /* Note: Do not use the quantity stream->cnt to determine the number + of characters in the buffer! Depending on how this function was + called, the stream->cnt value may be "off-by-one". */ + len = stream->ptr_ - stream->bufstart_; + if (len > 0) { + n = (*stream->ops_->write_)(stream->obj_, (char *) + stream->bufstart_, len); + if (n != len) { + stream->flags_ |= JAS_STREAM_ERR; + return EOF; + } + } + stream->cnt_ = stream->bufsize_; + stream->ptr_ = stream->bufstart_; + + stream->bufmode_ |= JAS_STREAM_WRBUF; + + if (c != EOF) { + assert(stream->cnt_ > 0); + jas_stream_putc2(stream, c); + } + + return 0; } /******************************************************************************\ @@ -868,134 +868,134 @@ int jas_stream_flushbuf(jas_stream_t *stream, int c) static int jas_strtoopenmode(const char *s) { - int openmode = 0; - while (*s != '\0') { - switch (*s) { - case 'r': - openmode |= JAS_STREAM_READ; - break; - case 'w': - openmode |= JAS_STREAM_WRITE | JAS_STREAM_CREATE; - break; - case 'b': - openmode |= JAS_STREAM_BINARY; - break; - case 'a': - openmode |= JAS_STREAM_APPEND; - break; - case '+': - openmode |= JAS_STREAM_READ | JAS_STREAM_WRITE; - break; - default: - break; - } - ++s; - } - return openmode; + int openmode = 0; + while (*s != '\0') { + switch (*s) { + case 'r': + openmode |= JAS_STREAM_READ; + break; + case 'w': + openmode |= JAS_STREAM_WRITE | JAS_STREAM_CREATE; + break; + case 'b': + openmode |= JAS_STREAM_BINARY; + break; + case 'a': + openmode |= JAS_STREAM_APPEND; + break; + case '+': + openmode |= JAS_STREAM_READ | JAS_STREAM_WRITE; + break; + default: + break; + } + ++s; + } + return openmode; } int jas_stream_copy(jas_stream_t *out, jas_stream_t *in, int n) { - int all; - int c; - int m; - - all = (n < 0) ? 1 : 0; - - m = n; - while (all || m > 0) { - if ((c = jas_stream_getc_macro(in)) == EOF) { - /* The next character of input could not be read. */ - /* Return with an error if an I/O error occurred - (not including EOF) or if an explicit copy count - was specified. */ - return (!all || jas_stream_error(in)) ? (-1) : 0; - } - if (jas_stream_putc_macro(out, c) == EOF) { - return -1; - } - --m; - } - return 0; + int all; + int c; + int m; + + all = (n < 0) ? 1 : 0; + + m = n; + while (all || m > 0) { + if ((c = jas_stream_getc_macro(in)) == EOF) { + /* The next character of input could not be read. */ + /* Return with an error if an I/O error occurred + (not including EOF) or if an explicit copy count + was specified. */ + return (!all || jas_stream_error(in)) ? (-1) : 0; + } + if (jas_stream_putc_macro(out, c) == EOF) { + return -1; + } + --m; + } + return 0; } long jas_stream_setrwcount(jas_stream_t *stream, long rwcnt) { - int old; + int old; - old = stream->rwcnt_; - stream->rwcnt_ = rwcnt; - return old; + old = stream->rwcnt_; + stream->rwcnt_ = rwcnt; + return old; } int jas_stream_display(jas_stream_t *stream, FILE *fp, int n) { - unsigned char buf[16]; - int i; - int j; - int m; - int c; - int display; - int cnt; - - cnt = n - (n % 16); - display = 1; - - for (i = 0; i < n; i += 16) { - if (n > 16 && i > 0) { - display = (i >= cnt) ? 1 : 0; - } - if (display) { - fprintf(fp, "%08x:", i); - } - m = JAS_MIN(n - i, 16); - for (j = 0; j < m; ++j) { - if ((c = jas_stream_getc(stream)) == EOF) { - abort(); - return -1; - } - buf[j] = c; - } - if (display) { - for (j = 0; j < m; ++j) { - fprintf(fp, " %02x", buf[j]); - } - fputc(' ', fp); - for (; j < 16; ++j) { - fprintf(fp, " "); - } - for (j = 0; j < m; ++j) { - if (isprint(buf[j])) { - fputc(buf[j], fp); - } else { - fputc(' ', fp); - } - } - fprintf(fp, "\n"); - } - - - } - return 0; + unsigned char buf[16]; + int i; + int j; + int m; + int c; + int display; + int cnt; + + cnt = n - (n % 16); + display = 1; + + for (i = 0; i < n; i += 16) { + if (n > 16 && i > 0) { + display = (i >= cnt) ? 1 : 0; + } + if (display) { + fprintf(fp, "%08x:", i); + } + m = JAS_MIN(n - i, 16); + for (j = 0; j < m; ++j) { + if ((c = jas_stream_getc(stream)) == EOF) { + abort(); + return -1; + } + buf[j] = c; + } + if (display) { + for (j = 0; j < m; ++j) { + fprintf(fp, " %02x", buf[j]); + } + fputc(' ', fp); + for (; j < 16; ++j) { + fprintf(fp, " "); + } + for (j = 0; j < m; ++j) { + if (isprint(buf[j])) { + fputc(buf[j], fp); + } else { + fputc(' ', fp); + } + } + fprintf(fp, "\n"); + } + + + } + return 0; } long jas_stream_length(jas_stream_t *stream) { - long oldpos; - long pos; - if ((oldpos = jas_stream_tell(stream)) < 0) { - return -1; - } - if (jas_stream_seek(stream, 0, SEEK_END) < 0) { - return -1; - } - if ((pos = jas_stream_tell(stream)) < 0) { - return -1; - } - if (jas_stream_seek(stream, oldpos, SEEK_SET) < 0) { - return -1; - } - return pos; + long oldpos; + long pos; + if ((oldpos = jas_stream_tell(stream)) < 0) { + return -1; + } + if (jas_stream_seek(stream, 0, SEEK_END) < 0) { + return -1; + } + if ((pos = jas_stream_tell(stream)) < 0) { + return -1; + } + if (jas_stream_seek(stream, oldpos, SEEK_SET) < 0) { + return -1; + } + return pos; } /******************************************************************************\ @@ -1004,109 +1004,109 @@ long jas_stream_length(jas_stream_t *stream) static int mem_read(jas_stream_obj_t *obj, char *buf, int cnt) { - int n; - jas_stream_memobj_t *m = (jas_stream_memobj_t *)obj; - n = m->len_ - m->pos_; - cnt = JAS_MIN(n, cnt); - memcpy(buf, &m->buf_[m->pos_], cnt); - m->pos_ += cnt; - return cnt; + int n; + jas_stream_memobj_t *m = (jas_stream_memobj_t *)obj; + n = m->len_ - m->pos_; + cnt = JAS_MIN(n, cnt); + memcpy(buf, &m->buf_[m->pos_], cnt); + m->pos_ += cnt; + return cnt; } static int mem_resize(jas_stream_memobj_t *m, int bufsize) { - unsigned char *buf; - - assert(m->buf_); - if (!(buf = jas_realloc(m->buf_, bufsize * sizeof(unsigned char)))) { - return -1; - } - m->buf_ = buf; - m->bufsize_ = bufsize; - return 0; + unsigned char *buf; + + assert(m->buf_); + if (!(buf = jas_realloc(m->buf_, bufsize * sizeof(unsigned char)))) { + return -1; + } + m->buf_ = buf; + m->bufsize_ = bufsize; + return 0; } static int mem_write(jas_stream_obj_t *obj, char *buf, int cnt) { - int n; - int ret; - jas_stream_memobj_t *m = (jas_stream_memobj_t *)obj; - long newbufsize; - long newpos; - - newpos = m->pos_ + cnt; - if (newpos > m->bufsize_ && m->growable_) { - newbufsize = m->bufsize_; - while (newbufsize < newpos) { - newbufsize <<= 1; - assert(newbufsize >= 0); - } - if (mem_resize(m, newbufsize)) { - return -1; - } - } - if (m->pos_ > m->len_) { - /* The current position is beyond the end of the file, so - pad the file to the current position with zeros. */ - n = JAS_MIN(m->pos_, m->bufsize_) - m->len_; - if (n > 0) { - memset(&m->buf_[m->len_], 0, n); - m->len_ += n; - } - if (m->pos_ != m->len_) { - /* The buffer is not big enough. */ - return 0; - } - } - n = m->bufsize_ - m->pos_; - ret = JAS_MIN(n, cnt); - if (ret > 0) { - memcpy(&m->buf_[m->pos_], buf, ret); - m->pos_ += ret; - } - if (m->pos_ > m->len_) { - m->len_ = m->pos_; - } + int n; + int ret; + jas_stream_memobj_t *m = (jas_stream_memobj_t *)obj; + long newbufsize; + long newpos; + + newpos = m->pos_ + cnt; + if (newpos > m->bufsize_ && m->growable_) { + newbufsize = m->bufsize_; + while (newbufsize < newpos) { + newbufsize <<= 1; + assert(newbufsize >= 0); + } + if (mem_resize(m, newbufsize)) { + return -1; + } + } + if (m->pos_ > m->len_) { + /* The current position is beyond the end of the file, so + pad the file to the current position with zeros. */ + n = JAS_MIN(m->pos_, m->bufsize_) - m->len_; + if (n > 0) { + memset(&m->buf_[m->len_], 0, n); + m->len_ += n; + } + if (m->pos_ != m->len_) { + /* The buffer is not big enough. */ + return 0; + } + } + n = m->bufsize_ - m->pos_; + ret = JAS_MIN(n, cnt); + if (ret > 0) { + memcpy(&m->buf_[m->pos_], buf, ret); + m->pos_ += ret; + } + if (m->pos_ > m->len_) { + m->len_ = m->pos_; + } assert(ret == cnt); - return ret; + return ret; } static long mem_seek(jas_stream_obj_t *obj, long offset, int origin) { - jas_stream_memobj_t *m = (jas_stream_memobj_t *)obj; - long newpos; - - switch (origin) { - case SEEK_SET: - newpos = offset; - break; - case SEEK_END: - newpos = m->len_ - offset; - break; - case SEEK_CUR: - newpos = m->pos_ + offset; - break; - default: - abort(); - break; - } - if (newpos < 0) { - return -1; - } - m->pos_ = newpos; - - return m->pos_; + jas_stream_memobj_t *m = (jas_stream_memobj_t *)obj; + long newpos; + + switch (origin) { + case SEEK_SET: + newpos = offset; + break; + case SEEK_END: + newpos = m->len_ - offset; + break; + case SEEK_CUR: + newpos = m->pos_ + offset; + break; + default: + abort(); + break; + } + if (newpos < 0) { + return -1; + } + m->pos_ = newpos; + + return m->pos_; } static int mem_close(jas_stream_obj_t *obj) { - jas_stream_memobj_t *m = (jas_stream_memobj_t *)obj; - if (m->myalloc_ && m->buf_) { - jas_free(m->buf_); - m->buf_ = 0; - } - jas_free(obj); - return 0; + jas_stream_memobj_t *m = (jas_stream_memobj_t *)obj; + if (m->myalloc_ && m->buf_) { + jas_free(m->buf_); + m->buf_ = 0; + } + jas_free(obj); + return 0; } /******************************************************************************\ @@ -1115,31 +1115,31 @@ static int mem_close(jas_stream_obj_t *obj) static int file_read(jas_stream_obj_t *obj, char *buf, int cnt) { - int fd; - fd = *((int *)obj); - return read(fd, buf, cnt); + int fd; + fd = *((int *)obj); + return read(fd, buf, cnt); } static int file_write(jas_stream_obj_t *obj, char *buf, int cnt) { - int fd; - fd = *((int *)obj); - return write(fd, buf, cnt); + int fd; + fd = *((int *)obj); + return write(fd, buf, cnt); } static long file_seek(jas_stream_obj_t *obj, long offset, int origin) { - int fd; - fd = *((int *)obj); - return lseek(fd, offset, origin); + int fd; + fd = *((int *)obj); + return lseek(fd, offset, origin); } static int file_close(jas_stream_obj_t *obj) { - int fd; - fd = *((int *)obj); - jas_free(obj); - return close(fd); + int fd; + fd = *((int *)obj); + jas_free(obj); + return close(fd); } /******************************************************************************\ @@ -1148,28 +1148,28 @@ static int file_close(jas_stream_obj_t *obj) static int sfile_read(jas_stream_obj_t *obj, char *buf, int cnt) { - FILE *fp; - fp = JAS_CAST(FILE *, obj); - return fread(buf, 1, cnt, fp); + FILE *fp; + fp = JAS_CAST(FILE *, obj); + return fread(buf, 1, cnt, fp); } static int sfile_write(jas_stream_obj_t *obj, char *buf, int cnt) { - FILE *fp; - fp = JAS_CAST(FILE *, obj); - return fwrite(buf, 1, cnt, fp); + FILE *fp; + fp = JAS_CAST(FILE *, obj); + return fwrite(buf, 1, cnt, fp); } static long sfile_seek(jas_stream_obj_t *obj, long offset, int origin) { - FILE *fp; - fp = JAS_CAST(FILE *, obj); - return fseek(fp, offset, origin); + FILE *fp; + fp = JAS_CAST(FILE *, obj); + return fseek(fp, offset, origin); } static int sfile_close(jas_stream_obj_t *obj) { - FILE *fp; - fp = JAS_CAST(FILE *, obj); - return fclose(fp); + FILE *fp; + fp = JAS_CAST(FILE *, obj); + return fclose(fp); } diff --git a/converter/other/jpeg2000/libjasper/base/jas_string.c b/converter/other/jpeg2000/libjasper/base/jas_string.c index 945731a1..b3c45b78 100644 --- a/converter/other/jpeg2000/libjasper/base/jas_string.c +++ b/converter/other/jpeg2000/libjasper/base/jas_string.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -134,12 +134,12 @@ char *jas_strdup(const char *s) { - int n; - char *p; - n = strlen(s) + 1; - if (!(p = jas_malloc(n * sizeof(char)))) { - return 0; - } - strcpy(p, s); - return p; + int n; + char *p; + n = strlen(s) + 1; + if (!(p = jas_malloc(n * sizeof(char)))) { + return 0; + } + strcpy(p, s); + return p; } diff --git a/converter/other/jpeg2000/libjasper/base/jas_tvp.c b/converter/other/jpeg2000/libjasper/base/jas_tvp.c index aab12703..43b2fd41 100644 --- a/converter/other/jpeg2000/libjasper/base/jas_tvp.c +++ b/converter/other/jpeg2000/libjasper/base/jas_tvp.c @@ -4,14 +4,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -19,22 +19,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -54,17 +54,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -104,7 +104,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -132,8 +132,8 @@ \******************************************************************************/ /* Is the specified character valid for a tag name? */ -#define JAS_TVP_ISTAG(x) \ - (isalpha(x) || (x) == '_' || isdigit(x)) +#define JAS_TVP_ISTAG(x) \ + (isalpha(x) || (x) == '_' || isdigit(x)) /******************************************************************************\ * Code for creating and destroying a tag-value parser. @@ -141,26 +141,26 @@ jas_tvparser_t *jas_tvparser_create(const char *s) { - jas_tvparser_t *tvp; - if (!(tvp = jas_malloc(sizeof(jas_tvparser_t)))) { - return 0; - } - if (!(tvp->buf = jas_strdup(s))) { - jas_tvparser_destroy(tvp); - return 0; - } - tvp->pos = tvp->buf; - tvp->tag = 0; - tvp->val = 0; - return tvp; + jas_tvparser_t *tvp; + if (!(tvp = jas_malloc(sizeof(jas_tvparser_t)))) { + return 0; + } + if (!(tvp->buf = jas_strdup(s))) { + jas_tvparser_destroy(tvp); + return 0; + } + tvp->pos = tvp->buf; + tvp->tag = 0; + tvp->val = 0; + return tvp; } void jas_tvparser_destroy(jas_tvparser_t *tvp) { - if (tvp->buf) { - jas_free(tvp->buf); - } - jas_free(tvp); + if (tvp->buf) { + jas_free(tvp->buf); + } + jas_free(tvp); } /******************************************************************************\ @@ -170,73 +170,73 @@ void jas_tvparser_destroy(jas_tvparser_t *tvp) /* Get the next tag-value pair. */ int jas_tvparser_next(jas_tvparser_t *tvp) { - char *p; - char *tag; - const char *val; + char *p; + char *tag; + const char *val; - /* Skip any leading whitespace. */ - p = tvp->pos; - while (*p != '\0' && isspace(*p)) { - ++p; - } + /* Skip any leading whitespace. */ + p = tvp->pos; + while (*p != '\0' && isspace(*p)) { + ++p; + } - /* Has the end of the input data been reached? */ - if (*p == '\0') { - /* No more tags are present. */ - tvp->pos = p; - return 1; - } + /* Has the end of the input data been reached? */ + if (*p == '\0') { + /* No more tags are present. */ + tvp->pos = p; + return 1; + } - /* Does the tag name begin with a valid character? */ - if (!JAS_TVP_ISTAG(*p)) { - return -1; - } + /* Does the tag name begin with a valid character? */ + if (!JAS_TVP_ISTAG(*p)) { + return -1; + } - /* Remember where the tag name begins. */ - tag = p; + /* Remember where the tag name begins. */ + tag = p; - /* Find the end of the tag name. */ - while (*p != '\0' && JAS_TVP_ISTAG(*p)) { - ++p; - } + /* Find the end of the tag name. */ + while (*p != '\0' && JAS_TVP_ISTAG(*p)) { + ++p; + } - /* Has the end of the input data been reached? */ - if (*p == '\0') { - /* The value field is empty. */ - tvp->tag = tag; - tvp->val = ""; - tvp->pos = p; - return 0; - } + /* Has the end of the input data been reached? */ + if (*p == '\0') { + /* The value field is empty. */ + tvp->tag = tag; + tvp->val = ""; + tvp->pos = p; + return 0; + } - /* Is a value field not present? */ - if (*p != '=') { - if (*p != '\0' && !isspace(*p)) { - return -1; - } - *p++ = '\0'; - tvp->tag = tag; - tvp->val = ""; - tvp->pos = p; - return 0; - } + /* Is a value field not present? */ + if (*p != '=') { + if (*p != '\0' && !isspace(*p)) { + return -1; + } + *p++ = '\0'; + tvp->tag = tag; + tvp->val = ""; + tvp->pos = p; + return 0; + } - *p++ = '\0'; + *p++ = '\0'; - val = p; - while (*p != '\0' && !isspace(*p)) { - ++p; - } + val = p; + while (*p != '\0' && !isspace(*p)) { + ++p; + } - if (*p != '\0') { - *p++ = '\0'; - } + if (*p != '\0') { + *p++ = '\0'; + } - tvp->pos = p; - tvp->tag = tag; - tvp->val = val; + tvp->pos = p; + tvp->tag = tag; + tvp->val = val; - return 0; + return 0; } /******************************************************************************\ @@ -246,13 +246,13 @@ int jas_tvparser_next(jas_tvparser_t *tvp) /* Get the current tag. */ char *jas_tvparser_gettag(jas_tvparser_t *tvp) { - return tvp->tag; + return tvp->tag; } /* Get the current value. */ const char *jas_tvparser_getval(jas_tvparser_t *tvp) { - return tvp->val; + return tvp->val; } /******************************************************************************\ @@ -262,15 +262,15 @@ const char *jas_tvparser_getval(jas_tvparser_t *tvp) /* Lookup a tag by name. */ jas_taginfo_t *jas_taginfos_lookup(jas_taginfo_t *taginfos, const char *name) { - jas_taginfo_t *taginfo; - taginfo = taginfos; - while (taginfo->id >= 0) { - if (!strcmp(taginfo->name, name)) { - return taginfo; - } - ++taginfo; - } - return 0; + jas_taginfo_t *taginfo; + taginfo = taginfos; + while (taginfo->id >= 0) { + if (!strcmp(taginfo->name, name)) { + return taginfo; + } + ++taginfo; + } + return 0; } /* This function is simply for convenience. */ @@ -278,9 +278,9 @@ jas_taginfo_t *jas_taginfos_lookup(jas_taginfo_t *taginfos, const char *name) using this function. This function never returns a null pointer. */ jas_taginfo_t *jas_taginfo_nonull(jas_taginfo_t *taginfo) { - static jas_taginfo_t invalidtaginfo = { - -1, 0 - }; - - return taginfo ? taginfo : &invalidtaginfo; + static jas_taginfo_t invalidtaginfo = { + -1, 0 + }; + + return taginfo ? taginfo : &invalidtaginfo; } diff --git a/converter/other/jpeg2000/libjasper/base/jas_version.c b/converter/other/jpeg2000/libjasper/base/jas_version.c index 5608c4d4..675a3883 100644 --- a/converter/other/jpeg2000/libjasper/base/jas_version.c +++ b/converter/other/jpeg2000/libjasper/base/jas_version.c @@ -4,14 +4,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -19,22 +19,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -54,17 +54,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -104,7 +104,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -112,5 +112,5 @@ const char *jas_getversion() { - return JAS_VERSION; + return JAS_VERSION; } diff --git a/converter/other/jpeg2000/libjasper/include/jasper/jas_debug.h b/converter/other/jpeg2000/libjasper/include/jasper/jas_debug.h index 6c597c59..77b65967 100644 --- a/converter/other/jpeg2000/libjasper/include/jasper/jas_debug.h +++ b/converter/other/jpeg2000/libjasper/include/jasper/jas_debug.h @@ -4,14 +4,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -19,22 +19,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -54,17 +54,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -104,7 +104,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -136,10 +136,10 @@ extern "C" { /* Output debugging information to standard error provided that the debug level is set sufficiently high. */ #if defined(DEBUG) -#define JAS_DBGLOG(n, x) \ - ((jas_getdbglevel() >= (n)) ? (jas_eprintf x) : 0) +#define JAS_DBGLOG(n, x) \ + ((jas_getdbglevel() >= (n)) ? (jas_eprintf x) : 0) #else -#define JAS_DBGLOG(n, x) +#define JAS_DBGLOG(n, x) #endif /* Get the library debug level. */ diff --git a/converter/other/jpeg2000/libjasper/include/jasper/jas_fix.h b/converter/other/jpeg2000/libjasper/include/jasper/jas_fix.h index 9599eb1c..7816b13e 100644 --- a/converter/other/jpeg2000/libjasper/include/jasper/jas_fix.h +++ b/converter/other/jpeg2000/libjasper/include/jasper/jas_fix.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -138,16 +138,16 @@ extern "C" { \******************************************************************************/ /* The representation of the value zero. */ -#define JAS_FIX_ZERO(fix_t, fracbits) \ - JAS_CAST(fix_t, 0) +#define JAS_FIX_ZERO(fix_t, fracbits) \ + JAS_CAST(fix_t, 0) /* The representation of the value one. */ -#define JAS_FIX_ONE(fix_t, fracbits) \ - (JAS_CAST(fix_t, 1) << (fracbits)) +#define JAS_FIX_ONE(fix_t, fracbits) \ + (JAS_CAST(fix_t, 1) << (fracbits)) /* The representation of the value one half. */ -#define JAS_FIX_HALF(fix_t, fracbits) \ - (JAS_CAST(fix_t, 1) << ((fracbits) - 1)) +#define JAS_FIX_HALF(fix_t, fracbits) \ + (JAS_CAST(fix_t, 1) << ((fracbits) - 1)) /******************************************************************************\ * Conversion operations. @@ -155,19 +155,19 @@ extern "C" { /* Convert an int to a fixed-point number. */ #define JAS_INTTOFIX(fix_t, fracbits, x) \ - JAS_CAST(fix_t, (x) << (fracbits)) + JAS_CAST(fix_t, (x) << (fracbits)) /* Convert a fixed-point number to an int. */ #define JAS_FIXTOINT(fix_t, fracbits, x) \ - JAS_CAST(int, (x) >> (fracbits)) + JAS_CAST(int, (x) >> (fracbits)) /* Convert a fixed-point number to a double. */ #define JAS_FIXTODBL(fix_t, fracbits, x) \ - (JAS_CAST(double, x) / (JAS_CAST(fix_t, 1) << (fracbits))) + (JAS_CAST(double, x) / (JAS_CAST(fix_t, 1) << (fracbits))) /* Convert a double to a fixed-point number. */ #define JAS_DBLTOFIX(fix_t, fracbits, x) \ - JAS_CAST(fix_t, ((x) * JAS_CAST(double, JAS_CAST(fix_t, 1) << (fracbits)))) + JAS_CAST(fix_t, ((x) * JAS_CAST(double, JAS_CAST(fix_t, 1) << (fracbits)))) /******************************************************************************\ * Basic arithmetic operations. @@ -181,128 +181,128 @@ extern "C" { /* Calculate the sum of two fixed-point numbers. */ #if !defined(DEBUG_OVERFLOW) -#define JAS_FIX_ADD JAS_FIX_ADD_FAST +#define JAS_FIX_ADD JAS_FIX_ADD_FAST #else -#define JAS_FIX_ADD JAS_FIX_ADD_OFLOW +#define JAS_FIX_ADD JAS_FIX_ADD_OFLOW #endif /* Calculate the sum of two fixed-point numbers without overflow checking. */ -#define JAS_FIX_ADD_FAST(fix_t, fracbits, x, y) ((x) + (y)) +#define JAS_FIX_ADD_FAST(fix_t, fracbits, x, y) ((x) + (y)) /* Calculate the sum of two fixed-point numbers with overflow checking. */ -#define JAS_FIX_ADD_OFLOW(fix_t, fracbits, x, y) \ - ((x) >= 0) ? \ - (((y) >= 0) ? ((x) + (y) >= 0 || JAS_FIX_OFLOW(), (x) + (y)) : \ - ((x) + (y))) : \ - (((y) >= 0) ? ((x) + (y)) : ((x) + (y) < 0 || JAS_FIX_OFLOW(), \ - (x) + (y))) +#define JAS_FIX_ADD_OFLOW(fix_t, fracbits, x, y) \ + ((x) >= 0) ? \ + (((y) >= 0) ? ((x) + (y) >= 0 || JAS_FIX_OFLOW(), (x) + (y)) : \ + ((x) + (y))) : \ + (((y) >= 0) ? ((x) + (y)) : ((x) + (y) < 0 || JAS_FIX_OFLOW(), \ + (x) + (y))) /* Calculate the product of two fixed-point numbers. */ #if !defined(DEBUG_OVERFLOW) -#define JAS_FIX_MUL JAS_FIX_MUL_FAST +#define JAS_FIX_MUL JAS_FIX_MUL_FAST #else -#define JAS_FIX_MUL JAS_FIX_MUL_OFLOW +#define JAS_FIX_MUL JAS_FIX_MUL_OFLOW #endif /* Calculate the product of two fixed-point numbers without overflow checking. */ -#define JAS_FIX_MUL_FAST(fix_t, fracbits, bigfix_t, x, y) \ - JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y)) >> \ - (fracbits)) +#define JAS_FIX_MUL_FAST(fix_t, fracbits, bigfix_t, x, y) \ + JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y)) >> \ + (fracbits)) /* Calculate the product of two fixed-point numbers with overflow checking. */ #define JAS_FIX_MUL_OFLOW(fix_t, fracbits, bigfix_t, x, y) \ - ((JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> (fracbits)) == \ - JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> \ - (fracbits))) ? \ - JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> \ - (fracbits))) : JAS_FIX_OFLOW()) + ((JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> (fracbits)) == \ + JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> \ + (fracbits))) ? \ + JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> \ + (fracbits))) : JAS_FIX_OFLOW()) /* Calculate the product of a fixed-point number and an int. */ #if !defined(DEBUG_OVERFLOW) -#define JAS_FIX_MULBYINT JAS_FIX_MULBYINT_FAST +#define JAS_FIX_MULBYINT JAS_FIX_MULBYINT_FAST #else -#define JAS_FIX_MULBYINT JAS_FIX_MULBYINT_OFLOW +#define JAS_FIX_MULBYINT JAS_FIX_MULBYINT_OFLOW #endif /* Calculate the product of a fixed-point number and an int without overflow checking. */ -#define JAS_FIX_MULBYINT_FAST(fix_t, fracbits, x, y) \ - JAS_CAST(fix_t, ((x) * (y))) +#define JAS_FIX_MULBYINT_FAST(fix_t, fracbits, x, y) \ + JAS_CAST(fix_t, ((x) * (y))) /* Calculate the product of a fixed-point number and an int with overflow checking. */ -#define JAS_FIX_MULBYINT_OFLOW(fix_t, fracbits, x, y) \ - JAS_FIX_MULBYINT_FAST(fix_t, fracbits, x, y) +#define JAS_FIX_MULBYINT_OFLOW(fix_t, fracbits, x, y) \ + JAS_FIX_MULBYINT_FAST(fix_t, fracbits, x, y) /* Calculate the quotient of two fixed-point numbers. */ #if !defined(DEBUG_OVERFLOW) -#define JAS_FIX_DIV JAS_FIX_DIV_FAST +#define JAS_FIX_DIV JAS_FIX_DIV_FAST #else -#define JAS_FIX_DIV JAS_FIX_DIV_UFLOW +#define JAS_FIX_DIV JAS_FIX_DIV_UFLOW #endif /* Calculate the quotient of two fixed-point numbers without underflow checking. */ -#define JAS_FIX_DIV_FAST(fix_t, fracbits, bigfix_t, x, y) \ - JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) << (fracbits)) / (y)) +#define JAS_FIX_DIV_FAST(fix_t, fracbits, bigfix_t, x, y) \ + JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) << (fracbits)) / (y)) /* Calculate the quotient of two fixed-point numbers with underflow checking. */ #define JAS_FIX_DIV_UFLOW(fix_t, fracbits, bigfix_t, x, y) \ - JAS_FIX_DIV_FAST(fix_t, fracbits, bigfix_t, x, y) + JAS_FIX_DIV_FAST(fix_t, fracbits, bigfix_t, x, y) /* Negate a fixed-point number. */ #if !defined(DEBUG_OVERFLOW) -#define JAS_FIX_NEG JAS_FIX_NEG_FAST +#define JAS_FIX_NEG JAS_FIX_NEG_FAST #else -#define JAS_FIX_NEG JAS_FIX_NEG_OFLOW +#define JAS_FIX_NEG JAS_FIX_NEG_OFLOW #endif /* Negate a fixed-point number without overflow checking. */ -#define JAS_FIX_NEG_FAST(fix_t, fracbits, x) \ - (-(x)) +#define JAS_FIX_NEG_FAST(fix_t, fracbits, x) \ + (-(x)) /* Negate a fixed-point number with overflow checking. */ /* Yes, overflow is actually possible for two's complement representations, although highly unlikely to occur. */ -#define JAS_FIX_NEG_OFLOW(fix_t, fracbits, x) \ - (((x) < 0) ? (-(x) > 0 || JAS_FIX_OFLOW(), -(x)) : (-(x))) +#define JAS_FIX_NEG_OFLOW(fix_t, fracbits, x) \ + (((x) < 0) ? (-(x) > 0 || JAS_FIX_OFLOW(), -(x)) : (-(x))) /* Perform an arithmetic shift left of a fixed-point number. */ #if !defined(DEBUG_OVERFLOW) -#define JAS_FIX_ASL JAS_FIX_ASL_FAST +#define JAS_FIX_ASL JAS_FIX_ASL_FAST #else -#define JAS_FIX_ASL JAS_FIX_ASL_OFLOW +#define JAS_FIX_ASL JAS_FIX_ASL_OFLOW #endif /* Perform an arithmetic shift left of a fixed-point number without overflow checking. */ -#define JAS_FIX_ASL_FAST(fix_t, fracbits, x, n) \ - ((x) << (n)) +#define JAS_FIX_ASL_FAST(fix_t, fracbits, x, n) \ + ((x) << (n)) /* Perform an arithmetic shift left of a fixed-point number with overflow checking. */ -#define JAS_FIX_ASL_OFLOW(fix_t, fracbits, x, n) \ - ((((x) << (n)) >> (n)) == (x) || JAS_FIX_OFLOW(), (x) << (n)) +#define JAS_FIX_ASL_OFLOW(fix_t, fracbits, x, n) \ + ((((x) << (n)) >> (n)) == (x) || JAS_FIX_OFLOW(), (x) << (n)) /* Perform an arithmetic shift right of a fixed-point number. */ #if !defined(DEBUG_OVERFLOW) -#define JAS_FIX_ASR JAS_FIX_ASR_FAST +#define JAS_FIX_ASR JAS_FIX_ASR_FAST #else -#define JAS_FIX_ASR JAS_FIX_ASR_UFLOW +#define JAS_FIX_ASR JAS_FIX_ASR_UFLOW #endif /* Perform an arithmetic shift right of a fixed-point number without underflow checking. */ -#define JAS_FIX_ASR_FAST(fix_t, fracbits, x, n) \ - ((x) >> (n)) +#define JAS_FIX_ASR_FAST(fix_t, fracbits, x, n) \ + ((x) >> (n)) /* Perform an arithmetic shift right of a fixed-point number with underflow checking. */ -#define JAS_FIX_ASR_UFLOW(fix_t, fracbits, x, n) \ - JAS_FIX_ASR_FAST(fix_t, fracbits, x, n) +#define JAS_FIX_ASR_UFLOW(fix_t, fracbits, x, n) \ + JAS_FIX_ASR_FAST(fix_t, fracbits, x, n) /******************************************************************************\ * Other basic arithmetic operations. @@ -310,35 +310,35 @@ extern "C" { /* Calculate the difference between two fixed-point numbers. */ #define JAS_FIX_SUB(fix_t, fracbits, x, y) \ - JAS_FIX_ADD(fix_t, fracbits, x, JAS_FIX_NEG(fix_t, fracbits, y)) + JAS_FIX_ADD(fix_t, fracbits, x, JAS_FIX_NEG(fix_t, fracbits, y)) /* Add one fixed-point number to another. */ #define JAS_FIX_PLUSEQ(fix_t, fracbits, x, y) \ - ((x) = JAS_FIX_ADD(fix_t, fracbits, x, y)) + ((x) = JAS_FIX_ADD(fix_t, fracbits, x, y)) /* Subtract one fixed-point number from another. */ #define JAS_FIX_MINUSEQ(fix_t, fracbits, x, y) \ - ((x) = JAS_FIX_SUB(fix_t, fracbits, x, y)) + ((x) = JAS_FIX_SUB(fix_t, fracbits, x, y)) /* Multiply one fixed-point number by another. */ -#define JAS_FIX_MULEQ(fix_t, fracbits, bigfix_t, x, y) \ - ((x) = JAS_FIX_MUL(fix_t, fracbits, bigfix_t, x, y)) +#define JAS_FIX_MULEQ(fix_t, fracbits, bigfix_t, x, y) \ + ((x) = JAS_FIX_MUL(fix_t, fracbits, bigfix_t, x, y)) /******************************************************************************\ * Miscellaneous operations. \******************************************************************************/ /* Calculate the absolute value of a fixed-point number. */ -#define JAS_FIX_ABS(fix_t, fracbits, x) \ - (((x) >= 0) ? (x) : (JAS_FIX_NEG(fix_t, fracbits, x))) +#define JAS_FIX_ABS(fix_t, fracbits, x) \ + (((x) >= 0) ? (x) : (JAS_FIX_NEG(fix_t, fracbits, x))) /* Is a fixed-point number an integer? */ -#define JAS_FIX_ISINT(fix_t, fracbits, x) \ - (JAS_FIX_FLOOR(fix_t, fracbits, x) == (x)) +#define JAS_FIX_ISINT(fix_t, fracbits, x) \ + (JAS_FIX_FLOOR(fix_t, fracbits, x) == (x)) /* Get the sign of a fixed-point number. */ #define JAS_FIX_SGN(fix_t, fracbits, x) \ - ((x) >= 0 ? 1 : (-1)) + ((x) >= 0 ? 1 : (-1)) /******************************************************************************\ * Relational operations. @@ -346,45 +346,45 @@ extern "C" { /* Compare two fixed-point numbers. */ #define JAS_FIX_CMP(fix_t, fracbits, x, y) \ - ((x) > (y) ? 1 : (((x) == (y)) ? 0 : (-1))) + ((x) > (y) ? 1 : (((x) == (y)) ? 0 : (-1))) /* Less than. */ -#define JAS_FIX_LT(fix_t, fracbits, x, y) \ - ((x) < (y)) +#define JAS_FIX_LT(fix_t, fracbits, x, y) \ + ((x) < (y)) /* Less than or equal. */ -#define JAS_FIX_LTE(fix_t, fracbits, x, y) \ - ((x) <= (y)) +#define JAS_FIX_LTE(fix_t, fracbits, x, y) \ + ((x) <= (y)) /* Greater than. */ -#define JAS_FIX_GT(fix_t, fracbits, x, y) \ - ((x) > (y)) +#define JAS_FIX_GT(fix_t, fracbits, x, y) \ + ((x) > (y)) /* Greater than or equal. */ -#define JAS_FIX_GTE(fix_t, fracbits, x, y) \ - ((x) >= (y)) +#define JAS_FIX_GTE(fix_t, fracbits, x, y) \ + ((x) >= (y)) /******************************************************************************\ * Rounding functions. \******************************************************************************/ /* Round a fixed-point number to the nearest integer. */ -#define JAS_FIX_ROUND(fix_t, fracbits, x) \ - (((x) < 0) ? JAS_FIX_FLOOR(fix_t, fracbits, JAS_FIX_ADD(fix_t, fracbits, \ - (x), JAS_FIX_HALF(fix_t, fracbits))) : \ - JAS_FIX_NEG(fix_t, fracbits, JAS_FIX_FLOOR(fix_t, fracbits, \ - JAS_FIX_ADD(fix_t, fracbits, (-(x)), JAS_FIX_HALF(fix_t, fracbits))))) +#define JAS_FIX_ROUND(fix_t, fracbits, x) \ + (((x) < 0) ? JAS_FIX_FLOOR(fix_t, fracbits, JAS_FIX_ADD(fix_t, fracbits, \ + (x), JAS_FIX_HALF(fix_t, fracbits))) : \ + JAS_FIX_NEG(fix_t, fracbits, JAS_FIX_FLOOR(fix_t, fracbits, \ + JAS_FIX_ADD(fix_t, fracbits, (-(x)), JAS_FIX_HALF(fix_t, fracbits))))) /* Round a fixed-point number to the nearest integer in the direction of negative infinity (i.e., the floor function). */ -#define JAS_FIX_FLOOR(fix_t, fracbits, x) \ - ((x) & (~((JAS_CAST(fix_t, 1) << (fracbits)) - 1))) +#define JAS_FIX_FLOOR(fix_t, fracbits, x) \ + ((x) & (~((JAS_CAST(fix_t, 1) << (fracbits)) - 1))) /* Round a fixed-point number to the nearest integer in the direction of zero. */ #define JAS_FIX_TRUNC(fix_t, fracbits, x) \ - (((x) >= 0) ? JAS_FIX_FLOOR(fix_t, fracbits, x) : \ - JAS_FIX_CEIL(fix_t, fracbits, x)) + (((x) >= 0) ? JAS_FIX_FLOOR(fix_t, fracbits, x) : \ + JAS_FIX_CEIL(fix_t, fracbits, x)) /******************************************************************************\ * The below macros are for internal library use only. Do not invoke them @@ -392,12 +392,12 @@ extern "C" { \******************************************************************************/ /* Handle overflow. */ -#define JAS_FIX_OFLOW() \ - fprintf(stderr, "overflow error: file %s, line %d\n", __FILE__, __LINE__) +#define JAS_FIX_OFLOW() \ + fprintf(stderr, "overflow error: file %s, line %d\n", __FILE__, __LINE__) /* Handle underflow. */ -#define JAS_FIX_UFLOW() \ - fprintf(stderr, "underflow error: file %s, line %d\n", __FILE__, __LINE__) +#define JAS_FIX_UFLOW() \ + fprintf(stderr, "underflow error: file %s, line %d\n", __FILE__, __LINE__) #ifdef __cplusplus } diff --git a/converter/other/jpeg2000/libjasper/include/jasper/jas_getopt.h b/converter/other/jpeg2000/libjasper/include/jasper/jas_getopt.h index 4f272dc9..31087948 100644 --- a/converter/other/jpeg2000/libjasper/include/jasper/jas_getopt.h +++ b/converter/other/jpeg2000/libjasper/include/jasper/jas_getopt.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -127,11 +127,11 @@ extern "C" { * Constants. \******************************************************************************/ -#define JAS_GETOPT_EOF (-1) -#define JAS_GETOPT_ERR '?' +#define JAS_GETOPT_EOF (-1) +#define JAS_GETOPT_ERR '?' /* option flags. */ -#define JAS_OPT_HASARG 0x01 /* option has argument */ +#define JAS_OPT_HASARG 0x01 /* option has argument */ /******************************************************************************\ * Types. @@ -140,14 +140,14 @@ extern "C" { /* Command line option type. */ typedef struct { - int id; - /* The unique identifier for this option. */ + int id; + /* The unique identifier for this option. */ - char *name; - /* The name of this option. */ + char *name; + /* The name of this option. */ - int flags; - /* option flags. */ + int flags; + /* option flags. */ } jas_opt_t; diff --git a/converter/other/jpeg2000/libjasper/include/jasper/jas_image.h b/converter/other/jpeg2000/libjasper/include/jasper/jas_image.h index 20170986..56bb6cdf 100644 --- a/converter/other/jpeg2000/libjasper/include/jasper/jas_image.h +++ b/converter/other/jpeg2000/libjasper/include/jasper/jas_image.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -140,36 +140,36 @@ extern "C" { */ /* The threshold at which image data is no longer stored in memory. */ -#define JAS_IMAGE_INMEMTHRESH (16 * 1024 * 1024) +#define JAS_IMAGE_INMEMTHRESH (16 * 1024 * 1024) /* * Color models. */ -#define JAS_IMAGE_CS_UNKNOWN 0 /* Unknown */ -#define JAS_IMAGE_CS_GRAY 1 /* Standard Gray */ -#define JAS_IMAGE_CS_RGB 2 /* Standard RGB */ -#define JAS_IMAGE_CS_YCBCR 3 /* Standard YCC */ +#define JAS_IMAGE_CS_UNKNOWN 0 /* Unknown */ +#define JAS_IMAGE_CS_GRAY 1 /* Standard Gray */ +#define JAS_IMAGE_CS_RGB 2 /* Standard RGB */ +#define JAS_IMAGE_CS_YCBCR 3 /* Standard YCC */ #if 0 -#define JAS_IMAGE_CM_ICC 4 /* ICC Profile */ +#define JAS_IMAGE_CM_ICC 4 /* ICC Profile */ #endif /* * Component types */ -#define JAS_IMAGE_CT_UNKNOWN 0x10000 -#define JAS_IMAGE_CT_COLOR(n) ((n) & 0x7fff) -#define JAS_IMAGE_CT_OPACITY 0x08000 +#define JAS_IMAGE_CT_UNKNOWN 0x10000 +#define JAS_IMAGE_CT_COLOR(n) ((n) & 0x7fff) +#define JAS_IMAGE_CT_OPACITY 0x08000 -#define JAS_IMAGE_CT_RGB_R 0 -#define JAS_IMAGE_CT_RGB_G 1 -#define JAS_IMAGE_CT_RGB_B 2 +#define JAS_IMAGE_CT_RGB_R 0 +#define JAS_IMAGE_CT_RGB_G 1 +#define JAS_IMAGE_CT_RGB_B 2 -#define JAS_IMAGE_CT_YCBCR_Y 0 -#define JAS_IMAGE_CT_YCBCR_CB 1 -#define JAS_IMAGE_CT_YCBCR_CR 2 +#define JAS_IMAGE_CT_YCBCR_Y 0 +#define JAS_IMAGE_CT_YCBCR_CB 1 +#define JAS_IMAGE_CT_YCBCR_CR 2 -#define JAS_IMAGE_CT_GRAY_Y 0 +#define JAS_IMAGE_CT_GRAY_Y 0 /*****************************************************************************\ * Image class and supporting classes. @@ -179,40 +179,40 @@ extern "C" { typedef struct { - uint_fast32_t tlx_; - /* The x-coordinate of the top-left corner of the component. */ + uint_fast32_t tlx_; + /* The x-coordinate of the top-left corner of the component. */ - uint_fast32_t tly_; - /* The y-coordinate of the top-left corner of the component. */ + uint_fast32_t tly_; + /* The y-coordinate of the top-left corner of the component. */ - uint_fast32_t hstep_; - /* The horizontal sampling period in units of the reference grid. */ + uint_fast32_t hstep_; + /* The horizontal sampling period in units of the reference grid. */ - uint_fast32_t vstep_; - /* The vertical sampling period in units of the reference grid. */ + uint_fast32_t vstep_; + /* The vertical sampling period in units of the reference grid. */ - uint_fast32_t width_; - /* The component width in samples. */ + uint_fast32_t width_; + /* The component width in samples. */ - uint_fast32_t height_; - /* The component height in samples. */ + uint_fast32_t height_; + /* The component height in samples. */ - uint_fast16_t prec_; - /* The precision of the sample data (i.e., the number of bits per - sample). If the samples are signed values, this quantity - includes the sign bit. */ + uint_fast16_t prec_; + /* The precision of the sample data (i.e., the number of bits per + sample). If the samples are signed values, this quantity + includes the sign bit. */ - uint_fast8_t sgnd_; - /* The signedness of the sample data. */ + uint_fast8_t sgnd_; + /* The signedness of the sample data. */ - jas_stream_t *stream_; - /* The stream containing the component data. */ + jas_stream_t *stream_; + /* The stream containing the component data. */ - int cps_; - /* The number of characters per sample in the stream. */ + int cps_; + /* The number of characters per sample in the stream. */ - uint_fast32_t type_; - /* The type of component (e.g., opacity, red, green, blue, luma). */ + uint_fast32_t type_; + /* The type of component (e.g., opacity, red, green, blue, luma). */ } jas_image_cmpt_t; @@ -220,40 +220,40 @@ typedef struct { typedef struct { - uint_fast32_t tlx_; - /* The x-coordinate of the top-left corner of the image bounding box. */ + uint_fast32_t tlx_; + /* The x-coordinate of the top-left corner of the image bounding box. */ - uint_fast32_t tly_; - /* The y-coordinate of the top-left corner of the image bounding box. */ + uint_fast32_t tly_; + /* The y-coordinate of the top-left corner of the image bounding box. */ - uint_fast32_t brx_; - /* The x-coordinate of the bottom-right corner of the image bounding - box (plus one). */ + uint_fast32_t brx_; + /* The x-coordinate of the bottom-right corner of the image bounding + box (plus one). */ - uint_fast32_t bry_; - /* The y-coordinate of the bottom-right corner of the image bounding - box (plus one). */ + uint_fast32_t bry_; + /* The y-coordinate of the bottom-right corner of the image bounding + box (plus one). */ - uint_fast16_t numcmpts_; - /* The number of components. */ + uint_fast16_t numcmpts_; + /* The number of components. */ - uint_fast16_t maxcmpts_; - /* The maximum number of components that this image can have (i.e., the - allocated size of the components array). */ + uint_fast16_t maxcmpts_; + /* The maximum number of components that this image can have (i.e., the + allocated size of the components array). */ - jas_image_cmpt_t **cmpts_; - /* Per-component information. */ + jas_image_cmpt_t **cmpts_; + /* Per-component information. */ - int colorspace_; - /* The color space used (e.g., RGB, YCbCr, gray). This field is only - of particular relevance in the case of a multi-component image. */ + int colorspace_; + /* The color space used (e.g., RGB, YCbCr, gray). This field is only + of particular relevance in the case of a multi-component image. */ - unsigned char *iccp_; - /* ICC profile information. */ + unsigned char *iccp_; + /* ICC profile information. */ - int iccplen_; + int iccplen_; - bool inmem_; + bool inmem_; } jas_image_t; @@ -263,29 +263,29 @@ typedef struct { typedef struct { - uint_fast32_t tlx; - /* The x-coordinate of the top-left corner of the component. */ + uint_fast32_t tlx; + /* The x-coordinate of the top-left corner of the component. */ - uint_fast32_t tly; - /* The y-coordinate of the top-left corner of the component. */ + uint_fast32_t tly; + /* The y-coordinate of the top-left corner of the component. */ - uint_fast32_t hstep; - /* The horizontal sampling period in units of the reference grid. */ + uint_fast32_t hstep; + /* The horizontal sampling period in units of the reference grid. */ - uint_fast32_t vstep; - /* The vertical sampling period in units of the reference grid. */ + uint_fast32_t vstep; + /* The vertical sampling period in units of the reference grid. */ - uint_fast32_t width; - /* The width of the component in samples. */ + uint_fast32_t width; + /* The width of the component in samples. */ - uint_fast32_t height; - /* The height of the component in samples. */ + uint_fast32_t height; + /* The height of the component in samples. */ - uint_fast16_t prec; - /* The precision of the component sample data. */ + uint_fast16_t prec; + /* The precision of the component sample data. */ - bool sgnd; - /* The signedness of the component sample data. */ + bool sgnd; + /* The signedness of the component sample data. */ } jas_image_cmptparm_t; @@ -293,24 +293,24 @@ typedef struct { * File format related classes. \******************************************************************************/ -#define JAS_IMAGE_MAXFMTS 32 +#define JAS_IMAGE_MAXFMTS 32 /* The maximum number of image data formats we can handle. */ /* Image format-dependent operations. */ typedef struct { - void (*decode)(jas_stream_t * const in, - const char * const opts, - jas_image_t ** const imagePP, - const char ** const errorP); - /* Decode image data from a stream. */ + void (*decode)(jas_stream_t * const in, + const char * const opts, + jas_image_t ** const imagePP, + const char ** const errorP); + /* Decode image data from a stream. */ - int (*encode)(jas_image_t *image, jas_stream_t *out, char *opts); - /* Encode image data to a stream. */ + int (*encode)(jas_image_t *image, jas_stream_t *out, char *opts); + /* Encode image data to a stream. */ - int (*validate)(jas_stream_t *in); - /* Determine if stream data is in a particular format. */ + int (*validate)(jas_stream_t *in); + /* Determine if stream data is in a particular format. */ } jas_image_fmtops_t; @@ -318,20 +318,20 @@ typedef struct { typedef struct { - int id; - /* The ID for this format. */ + int id; + /* The ID for this format. */ - char *name; - /* The name by which this format is identified. */ + char *name; + /* The name by which this format is identified. */ - char *ext; - /* The file name extension associated with this format. */ + char *ext; + /* The file name extension associated with this format. */ - char *desc; - /* A brief description of the format. */ + char *desc; + /* A brief description of the format. */ - jas_image_fmtops_t ops; - /* The operations for this format. */ + jas_image_fmtops_t ops; + /* The operations for this format. */ } jas_image_fmtinfo_t; @@ -354,92 +354,92 @@ void jas_image_destroy(jas_image_t *image); /* Get the width of the image in units of the image reference grid. */ #define jas_image_width(image) \ - ((image)->brx_ - (image)->tlx_) + ((image)->brx_ - (image)->tlx_) /* Get the height of the image in units of the image reference grid. */ -#define jas_image_height(image) \ - ((image)->bry_ - (image)->tly_) +#define jas_image_height(image) \ + ((image)->bry_ - (image)->tly_) /* Get the x-coordinate of the top-left corner of the image bounding box on the reference grid. */ #define jas_image_tlx(image) \ - ((image)->tlx_) + ((image)->tlx_) /* Get the y-coordinate of the top-left corner of the image bounding box on the reference grid. */ #define jas_image_tly(image) \ - ((image)->tly_) + ((image)->tly_) /* Get the x-coordinate of the bottom-right corner of the image bounding box on the reference grid (plus one). */ #define jas_image_brx(image) \ - ((image)->brx_) + ((image)->brx_) /* Get the y-coordinate of the bottom-right corner of the image bounding box on the reference grid (plus one). */ #define jas_image_bry(image) \ - ((image)->bry_) + ((image)->bry_) /* Get the number of image components. */ -#define jas_image_numcmpts(image) \ - ((image)->numcmpts_) +#define jas_image_numcmpts(image) \ + ((image)->numcmpts_) /* Get the color model used by the image. */ -#define jas_image_colorspace(image) \ - ((image)->colorspace_) +#define jas_image_colorspace(image) \ + ((image)->colorspace_) /* Set the color model for an image. */ #define jas_image_setcolorspace(image, colorspace) \ - ((image)->colorspace_ = (colorspace)) + ((image)->colorspace_ = (colorspace)) #define jas_image_cmpttype(image, cmptno) \ - ((image)->cmpts_[(cmptno)]->type_) + ((image)->cmpts_[(cmptno)]->type_) #define jas_image_setcmpttype(image, cmptno, type) \ - ((image)->cmpts_[(cmptno)]->type_ = (type)) + ((image)->cmpts_[(cmptno)]->type_ = (type)) /* Get the width of a component. */ -#define jas_image_cmptwidth(image, cmptno) \ - ((image)->cmpts_[cmptno]->width_) +#define jas_image_cmptwidth(image, cmptno) \ + ((image)->cmpts_[cmptno]->width_) /* Get the height of a component. */ -#define jas_image_cmptheight(image, cmptno) \ - ((image)->cmpts_[cmptno]->height_) +#define jas_image_cmptheight(image, cmptno) \ + ((image)->cmpts_[cmptno]->height_) /* Get the signedness of the sample data for a component. */ -#define jas_image_cmptsgnd(image, cmptno) \ - ((image)->cmpts_[cmptno]->sgnd_) +#define jas_image_cmptsgnd(image, cmptno) \ + ((image)->cmpts_[cmptno]->sgnd_) /* Get the precision of the sample data for a component. */ -#define jas_image_cmptprec(image, cmptno) \ - ((image)->cmpts_[cmptno]->prec_) +#define jas_image_cmptprec(image, cmptno) \ + ((image)->cmpts_[cmptno]->prec_) /* Get the horizontal subsampling factor for a component. */ -#define jas_image_cmpthstep(image, cmptno) \ - ((image)->cmpts_[cmptno]->hstep_) +#define jas_image_cmpthstep(image, cmptno) \ + ((image)->cmpts_[cmptno]->hstep_) /* Get the vertical subsampling factor for a component. */ -#define jas_image_cmptvstep(image, cmptno) \ - ((image)->cmpts_[cmptno]->vstep_) +#define jas_image_cmptvstep(image, cmptno) \ + ((image)->cmpts_[cmptno]->vstep_) /* Get the x-coordinate of the top-left corner of a component. */ -#define jas_image_cmpttlx(image, cmptno) \ - ((image)->cmpts_[cmptno]->tlx_) +#define jas_image_cmpttlx(image, cmptno) \ + ((image)->cmpts_[cmptno]->tlx_) /* Get the y-coordinate of the top-left corner of a component. */ -#define jas_image_cmpttly(image, cmptno) \ - ((image)->cmpts_[cmptno]->tly_) +#define jas_image_cmpttly(image, cmptno) \ + ((image)->cmpts_[cmptno]->tly_) /* Get the x-coordinate of the bottom-right corner of a component (plus "one"). */ -#define jas_image_cmptbrx(image, cmptno) \ - ((image)->cmpts_[cmptno]->tlx_ + (image)->cmpts_[cmptno]->width_ * \ - (image)->cmpts_[cmptno]->hstep_) +#define jas_image_cmptbrx(image, cmptno) \ + ((image)->cmpts_[cmptno]->tlx_ + (image)->cmpts_[cmptno]->width_ * \ + (image)->cmpts_[cmptno]->hstep_) /* Get the y-coordinate of the bottom-right corner of a component (plus "one"). */ -#define jas_image_cmptbry(image, cmptno) \ - ((image)->cmpts_[cmptno]->tly_ + (image)->cmpts_[cmptno]->height_ * \ - (image)->cmpts_[cmptno]->vstep_) +#define jas_image_cmptbry(image, cmptno) \ + ((image)->cmpts_[cmptno]->tly_ + (image)->cmpts_[cmptno]->height_ * \ + (image)->cmpts_[cmptno]->vstep_) /* Get the raw size of an image (i.e., the nominal size of the image without any compression. */ @@ -449,10 +449,10 @@ uint_fast32_t jas_image_rawsize(jas_image_t *image); void pmjas_image_decode(jas_stream_t * const in, - int const fmt, - const char * const optstr, - jas_image_t ** const imagePP, - const char ** const errorP); + int const fmt, + const char * const optstr, + jas_image_t ** const imagePP, + const char ** const errorP); /* Write an image to a stream in a specified format. */ int jas_image_encode(jas_image_t *image, jas_stream_t *out, int fmt, @@ -486,13 +486,13 @@ int_fast64_t jas_image_readcmpt1(jas_image_t *image, uint_fast16_t cmptno, uint_fast32_t x, uint_fast32_t y); #endif -#define JAS_IMAGE_CDT_GETSGND(dtype) (((dtype) >> 7) & 1) -#define JAS_IMAGE_CDT_SETSGND(dtype) (((dtype) & 1) << 7) -#define JAS_IMAGE_CDT_GETPREC(dtype) ((dtype) & 0x7f) -#define JAS_IMAGE_CDT_SETPREC(dtype) ((dtype) & 0x7f) +#define JAS_IMAGE_CDT_GETSGND(dtype) (((dtype) >> 7) & 1) +#define JAS_IMAGE_CDT_SETSGND(dtype) (((dtype) & 1) << 7) +#define JAS_IMAGE_CDT_GETPREC(dtype) ((dtype) & 0x7f) +#define JAS_IMAGE_CDT_SETPREC(dtype) ((dtype) & 0x7f) -#define jas_image_cmptdtype(image, cmptno) \ - (JAS_IMAGE_CDT_SETSGND((image)->cmpts_[cmptno]->sgnd_) | JAS_IMAGE_CDT_SETPREC((image)->cmpts_[cmptno]->prec_)) +#define jas_image_cmptdtype(image, cmptno) \ + (JAS_IMAGE_CDT_SETSGND((image)->cmpts_[cmptno]->sgnd_) | JAS_IMAGE_CDT_SETPREC((image)->cmpts_[cmptno]->prec_)) void jas_image_dump(jas_image_t *image, FILE *out); @@ -513,7 +513,7 @@ int jas_image_getcmptbytype(jas_image_t *image, int ctype); void jas_image_clearfmts(void); /* Add entry to table of image formats. */ -int jas_image_addfmt(int id, const char *name, const char *ext, +int jas_image_addfmt(int id, const char *name, const char *ext, const char *desc, jas_image_fmtops_t *ops); @@ -578,9 +578,9 @@ int bmp_validate(jas_stream_t *in); /* Format-dependent operations for JP2 capability. */ void jp2_decode(jas_stream_t * const in, - const char * const optstr, - jas_image_t ** const imagePP, - const char ** const errorP); + const char * const optstr, + jas_image_t ** const imagePP, + const char ** const errorP); int jp2_encode(jas_image_t *image, jas_stream_t *out, char *optstr); int jp2_validate(jas_stream_t *in); #endif diff --git a/converter/other/jpeg2000/libjasper/include/jasper/jas_init.h b/converter/other/jpeg2000/libjasper/include/jasper/jas_init.h index 4ebeaa87..8d84a10b 100644 --- a/converter/other/jpeg2000/libjasper/include/jasper/jas_init.h +++ b/converter/other/jpeg2000/libjasper/include/jasper/jas_init.h @@ -4,14 +4,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -19,22 +19,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -54,17 +54,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -104,7 +104,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ diff --git a/converter/other/jpeg2000/libjasper/include/jasper/jas_malloc.h b/converter/other/jpeg2000/libjasper/include/jasper/jas_malloc.h index fe5b6172..c2a32581 100644 --- a/converter/other/jpeg2000/libjasper/include/jasper/jas_malloc.h +++ b/converter/other/jpeg2000/libjasper/include/jasper/jas_malloc.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -138,10 +138,10 @@ extern "C" { /* This is somewhat of a hack, but it's a useful hack. :-) */ /* Use my own custom memory allocator for debugging. */ #include "../../../../local/src/memalloc.h" -#define jas_malloc MEMALLOC -#define jas_free MEMFREE -#define jas_realloc MEMREALLOC -#define jas_calloc MEMCALLOC +#define jas_malloc MEMALLOC +#define jas_free MEMFREE +#define jas_realloc MEMREALLOC +#define jas_calloc MEMCALLOC #endif /******************************************************************************\ diff --git a/converter/other/jpeg2000/libjasper/include/jasper/jas_math.h b/converter/other/jpeg2000/libjasper/include/jasper/jas_math.h index a43051e5..2baac725 100644 --- a/converter/other/jpeg2000/libjasper/include/jasper/jas_math.h +++ b/converter/other/jpeg2000/libjasper/include/jasper/jas_math.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -116,16 +116,16 @@ * $Id$ */ -#ifndef JAS_MATH_H -#define JAS_MATH_H +#ifndef JAS_MATH_H +#define JAS_MATH_H /******************************************************************************\ * Includes \******************************************************************************/ -#include <assert.h> -#include <stdio.h> -#include <string.h> +#include <assert.h> +#include <stdio.h> +#include <string.h> #ifdef __cplusplus extern "C" { @@ -136,25 +136,25 @@ extern "C" { \******************************************************************************/ /* Compute the absolute value. */ -#define JAS_ABS(x) \ - (((x) >= 0) ? (x) : (-(x))) +#define JAS_ABS(x) \ + (((x) >= 0) ? (x) : (-(x))) /* Compute the minimum of two values. */ -#define JAS_MIN(x, y) \ - (((x) < (y)) ? (x) : (y)) +#define JAS_MIN(x, y) \ + (((x) < (y)) ? (x) : (y)) /* Compute the maximum of two values. */ -#define JAS_MAX(x, y) \ - (((x) > (y)) ? (x) : (y)) +#define JAS_MAX(x, y) \ + (((x) > (y)) ? (x) : (y)) /* Compute the remainder from division (where division is defined such that the remainder is always nonnegative). */ -#define JAS_MOD(x, y) \ - (((x) < 0) ? (((-x) % (y)) ? ((y) - ((-(x)) % (y))) : (0)) : ((x) % (y))) +#define JAS_MOD(x, y) \ + (((x) < 0) ? (((-x) % (y)) ? ((y) - ((-(x)) % (y))) : (0)) : ((x) % (y))) /* Compute the integer with the specified number of least significant bits set to one. */ -#define JAS_ONES(n) \ +#define JAS_ONES(n) \ ((1 << (n)) - 1) #ifdef __cplusplus diff --git a/converter/other/jpeg2000/libjasper/include/jasper/jas_seq.h b/converter/other/jpeg2000/libjasper/include/jasper/jas_seq.h index 4599f50c..502470d0 100644 --- a/converter/other/jpeg2000/libjasper/include/jasper/jas_seq.h +++ b/converter/other/jpeg2000/libjasper/include/jasper/jas_seq.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -135,7 +135,7 @@ extern "C" { \******************************************************************************/ /* This matrix is a reference to another matrix. */ -#define JAS_MATRIX_REF 0x0001 +#define JAS_MATRIX_REF 0x0001 /******************************************************************************\ * Types. @@ -151,38 +151,38 @@ typedef int_fast32_t jas_matent_t; typedef struct { - /* Additional state information. */ - int flags_; + /* Additional state information. */ + int flags_; - /* The starting horizontal index. */ - int_fast32_t xstart_; + /* The starting horizontal index. */ + int_fast32_t xstart_; - /* The starting vertical index. */ - int_fast32_t ystart_; + /* The starting vertical index. */ + int_fast32_t ystart_; - /* The ending horizontal index. */ - int_fast32_t xend_; + /* The ending horizontal index. */ + int_fast32_t xend_; - /* The ending vertical index. */ - int_fast32_t yend_; + /* The ending vertical index. */ + int_fast32_t yend_; - /* The number of rows in the matrix. */ - int_fast32_t numrows_; + /* The number of rows in the matrix. */ + int_fast32_t numrows_; - /* The number of columns in the matrix. */ - int_fast32_t numcols_; + /* The number of columns in the matrix. */ + int_fast32_t numcols_; - /* Pointers to the start of each row. */ - jas_seqent_t **rows_; + /* Pointers to the start of each row. */ + jas_seqent_t **rows_; - /* The allocated size of the rows array. */ - int_fast32_t maxrows_; + /* The allocated size of the rows array. */ + int_fast32_t maxrows_; - /* The matrix data buffer. */ - jas_seqent_t *data_; + /* The matrix data buffer. */ + jas_seqent_t *data_; - /* The allocated size of the data array. */ - int_fast32_t datasize_; + /* The allocated size of the data array. */ + int_fast32_t datasize_; } jas_matrix_t; @@ -195,39 +195,39 @@ typedef jas_matrix_t jas_seq_t; /* Get the number of rows. */ #define jas_matrix_numrows(matrix) \ - ((matrix)->numrows_) + ((matrix)->numrows_) /* Get the number of columns. */ #define jas_matrix_numcols(matrix) \ - ((matrix)->numcols_) + ((matrix)->numcols_) /* Get a matrix element. */ #define jas_matrix_get(matrix, i, j) \ - ((matrix)->rows_[i][j]) + ((matrix)->rows_[i][j]) /* Set a matrix element. */ #define jas_matrix_set(matrix, i, j, v) \ - ((matrix)->rows_[i][j] = (v)) + ((matrix)->rows_[i][j] = (v)) /* Get an element from a matrix that is known to be a row or column vector. */ #define jas_matrix_getv(matrix, i) \ - (((matrix)->numrows_ == 1) ? ((matrix)->rows_[0][i]) : \ - ((matrix)->rows_[i][0])) + (((matrix)->numrows_ == 1) ? ((matrix)->rows_[0][i]) : \ + ((matrix)->rows_[i][0])) /* Set an element in a matrix that is known to be a row or column vector. */ #define jas_matrix_setv(matrix, i, v) \ - (((matrix)->numrows_ == 1) ? ((matrix)->rows_[0][i] = (v)) : \ - ((matrix)->rows_[i][0] = (v))) + (((matrix)->numrows_ == 1) ? ((matrix)->rows_[0][i] = (v)) : \ + ((matrix)->rows_[i][0] = (v))) /* Get the address of an element in a matrix. */ -#define jas_matrix_getref(matrix, i, j) \ - (&(matrix)->rows_[i][j]) +#define jas_matrix_getref(matrix, i, j) \ + (&(matrix)->rows_[i][j]) -#define jas_matrix_getvref(matrix, i) \ - (((matrix)->numrows_ > 1) ? jas_matrix_getref(matrix, i, 0) : jas_matrix_getref(matrix, 0, i)) +#define jas_matrix_getvref(matrix, i) \ + (((matrix)->numrows_ > 1) ? jas_matrix_getref(matrix, i, 0) : jas_matrix_getref(matrix, 0, i)) #define jas_matrix_length(matrix) \ - (max((matrix)->numrows_, (matrix)->numcols_)) + (max((matrix)->numrows_, (matrix)->numcols_)) /* Create a matrix with the specified dimensions. */ jas_matrix_t *jas_matrix_create(int numrows, int numcols); @@ -273,12 +273,12 @@ void jas_matrix_divpow2(jas_matrix_t *matrix, int n); void jas_matrix_setall(jas_matrix_t *matrix, jas_seqent_t val); /* The spacing between rows of a matrix. */ -#define jas_matrix_rowstep(matrix) \ - (((matrix)->numrows_ > 1) ? ((matrix)->rows_[1] - (matrix)->rows_[0]) : (0)) +#define jas_matrix_rowstep(matrix) \ + (((matrix)->numrows_ > 1) ? ((matrix)->rows_[1] - (matrix)->rows_[0]) : (0)) /* The spacing between columns of a matrix. */ -#define jas_matrix_step(matrix) \ - (((matrix)->numrows_ > 1) ? (jas_matrix_rowstep(matrix)) : (1)) +#define jas_matrix_step(matrix) \ + (((matrix)->numrows_ > 1) ? (jas_matrix_rowstep(matrix)) : (1)) /* Compare two matrices for equality. */ int jas_matrix_cmp(jas_matrix_t *mat0, jas_matrix_t *mat1); @@ -291,31 +291,31 @@ jas_seq2d_t *jas_seq2d_copy(jas_seq2d_t *x); jas_matrix_t *jas_seq2d_create(int xstart, int ystart, int xend, int yend); -#define jas_seq2d_destroy(s) \ - jas_matrix_destroy(s) - -#define jas_seq2d_xstart(s) \ - ((s)->xstart_) -#define jas_seq2d_ystart(s) \ - ((s)->ystart_) -#define jas_seq2d_xend(s) \ - ((s)->xend_) -#define jas_seq2d_yend(s) \ - ((s)->yend_) -#define jas_seq2d_getref(s, x, y) \ - (jas_matrix_getref(s, (y) - (s)->ystart_, (x) - (s)->xstart_)) -#define jas_seq2d_get(s, x, y) \ - (jas_matrix_get(s, (y) - (s)->ystart_, (x) - (s)->xstart_)) -#define jas_seq2d_rowstep(s) \ - jas_matrix_rowstep(s) -#define jas_seq2d_width(s) \ - ((s)->xend_ - (s)->xstart_) -#define jas_seq2d_height(s) \ - ((s)->yend_ - (s)->ystart_) -#define jas_seq2d_setshift(s, x, y) \ - ((s)->xstart_ = (x), (s)->ystart_ = (y), \ - (s)->xend_ = (s)->xstart_ + (s)->numcols_, \ - (s)->yend_ = (s)->ystart_ + (s)->numrows_) +#define jas_seq2d_destroy(s) \ + jas_matrix_destroy(s) + +#define jas_seq2d_xstart(s) \ + ((s)->xstart_) +#define jas_seq2d_ystart(s) \ + ((s)->ystart_) +#define jas_seq2d_xend(s) \ + ((s)->xend_) +#define jas_seq2d_yend(s) \ + ((s)->yend_) +#define jas_seq2d_getref(s, x, y) \ + (jas_matrix_getref(s, (y) - (s)->ystart_, (x) - (s)->xstart_)) +#define jas_seq2d_get(s, x, y) \ + (jas_matrix_get(s, (y) - (s)->ystart_, (x) - (s)->xstart_)) +#define jas_seq2d_rowstep(s) \ + jas_matrix_rowstep(s) +#define jas_seq2d_width(s) \ + ((s)->xend_ - (s)->xstart_) +#define jas_seq2d_height(s) \ + ((s)->yend_ - (s)->ystart_) +#define jas_seq2d_setshift(s, x, y) \ + ((s)->xstart_ = (x), (s)->ystart_ = (y), \ + (s)->xend_ = (s)->xstart_ + (s)->numcols_, \ + (s)->yend_ = (s)->ystart_ + (s)->numrows_) void jas_seq2d_bindsub(jas_matrix_t *s, jas_matrix_t *s1, int xstart, int ystart, int xend, int yend); @@ -324,22 +324,22 @@ void jas_seq2d_bindsub(jas_matrix_t *s, jas_matrix_t *s1, int xstart, * Functions/macros for 1-D sequence class. \******************************************************************************/ -#define jas_seq_create(start, end) \ - (jas_seq2d_create(start, 0, end, 1)) +#define jas_seq_create(start, end) \ + (jas_seq2d_create(start, 0, end, 1)) -#define jas_seq_destroy(seq) \ - (jas_seq2d_destroy(seq)) +#define jas_seq_destroy(seq) \ + (jas_seq2d_destroy(seq)) #define jas_seq_set(seq, i, v) \ - ((seq)->rows_[0][(i) - (seq)->xstart_] = (v)) -#define jas_seq_getref(seq, i) \ - (&(seq)->rows_[0][(i) - (seq)->xstart_]) -#define jas_seq_get(seq, i) \ - ((seq)->rows_[0][(i) - (seq)->xstart_]) -#define jas_seq_start(seq) \ - ((seq)->xstart_) -#define jas_seq_end(seq) \ - ((seq)->xend_) + ((seq)->rows_[0][(i) - (seq)->xstart_] = (v)) +#define jas_seq_getref(seq, i) \ + (&(seq)->rows_[0][(i) - (seq)->xstart_]) +#define jas_seq_get(seq, i) \ + ((seq)->rows_[0][(i) - (seq)->xstart_]) +#define jas_seq_start(seq) \ + ((seq)->xstart_) +#define jas_seq_end(seq) \ + ((seq)->xend_) #ifdef __cplusplus } diff --git a/converter/other/jpeg2000/libjasper/include/jasper/jas_stream.h b/converter/other/jpeg2000/libjasper/include/jasper/jas_stream.h index 1062fe1d..8d4d4a77 100644 --- a/converter/other/jpeg2000/libjasper/include/jasper/jas_stream.h +++ b/converter/other/jpeg2000/libjasper/include/jasper/jas_stream.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -141,7 +141,7 @@ extern "C" { /* On most UNIX systems, we probably need to define O_BINARY ourselves. */ #ifndef O_BINARY -#define O_BINARY 0 +#define O_BINARY 0 #endif /* @@ -149,64 +149,64 @@ extern "C" { */ /* The stream was opened for reading. */ -#define JAS_STREAM_READ 0x0001 +#define JAS_STREAM_READ 0x0001 /* The stream was opened for writing. */ -#define JAS_STREAM_WRITE 0x0002 +#define JAS_STREAM_WRITE 0x0002 /* The stream was opened for appending. */ -#define JAS_STREAM_APPEND 0x0004 +#define JAS_STREAM_APPEND 0x0004 /* The stream was opened in binary mode. */ -#define JAS_STREAM_BINARY 0x0008 +#define JAS_STREAM_BINARY 0x0008 /* The stream should be created/truncated. */ -#define JAS_STREAM_CREATE 0x0010 +#define JAS_STREAM_CREATE 0x0010 -#define JAS_STREAM_NOCLOSE 0x0020 +#define JAS_STREAM_NOCLOSE 0x0020 /* * Stream buffering flags. */ /* The stream is unbuffered. */ -#define JAS_STREAM_UNBUF 0x0000 +#define JAS_STREAM_UNBUF 0x0000 /* The stream is line buffered. */ -#define JAS_STREAM_LINEBUF 0x0001 +#define JAS_STREAM_LINEBUF 0x0001 /* The stream is fully buffered. */ -#define JAS_STREAM_FULLBUF 0x0002 +#define JAS_STREAM_FULLBUF 0x0002 /* The buffering mode mask. */ -#define JAS_STREAM_BUFMODEMASK 0x000f +#define JAS_STREAM_BUFMODEMASK 0x000f /* The memory associated with the buffer needs to be deallocated when the stream is destroyed. */ -#define JAS_STREAM_FREEBUF 0x0008 +#define JAS_STREAM_FREEBUF 0x0008 /* The buffer is currently being used for reading. */ -#define JAS_STREAM_RDBUF 0x0010 +#define JAS_STREAM_RDBUF 0x0010 /* The buffer is currently being used for writing. */ -#define JAS_STREAM_WRBUF 0x0020 +#define JAS_STREAM_WRBUF 0x0020 /* * Stream error flags. */ /* The end-of-file has been encountered (on reading). */ -#define JAS_STREAM_EOF 0x0001 +#define JAS_STREAM_EOF 0x0001 /* An I/O error has been encountered on the stream. */ -#define JAS_STREAM_ERR 0x0002 +#define JAS_STREAM_ERR 0x0002 /* The read/write limit has been exceeded. */ -#define JAS_STREAM_RWLIMIT 0x0004 +#define JAS_STREAM_RWLIMIT 0x0004 /* The error mask. */ #define JAS_STREAM_ERRMASK \ - (JAS_STREAM_EOF | JAS_STREAM_ERR | JAS_STREAM_RWLIMIT) + (JAS_STREAM_EOF | JAS_STREAM_ERR | JAS_STREAM_RWLIMIT) /* * Other miscellaneous constants. */ /* The default buffer size (for fully-buffered operation). */ -#define JAS_STREAM_BUFSIZE 8192 +#define JAS_STREAM_BUFSIZE 8192 /* The default permission mask for file creation. */ -#define JAS_STREAM_PERMS 0666 +#define JAS_STREAM_PERMS 0666 /* The maximum number of characters that can always be put back on a stream. */ -#define JAS_STREAM_MAXPUTBACK 16 +#define JAS_STREAM_MAXPUTBACK 16 /******************************************************************************\ * Types. @@ -224,17 +224,17 @@ typedef void jas_stream_obj_t; typedef struct { - /* Read characters from a file object. */ - int (*read_)(jas_stream_obj_t *obj, char *buf, int cnt); + /* Read characters from a file object. */ + int (*read_)(jas_stream_obj_t *obj, char *buf, int cnt); - /* Write characters to a file object. */ - int (*write_)(jas_stream_obj_t *obj, char *buf, int cnt); + /* Write characters to a file object. */ + int (*write_)(jas_stream_obj_t *obj, char *buf, int cnt); - /* Set the position for a file object. */ - long (*seek_)(jas_stream_obj_t *obj, long offset, int origin); + /* Set the position for a file object. */ + long (*seek_)(jas_stream_obj_t *obj, long offset, int origin); - /* Close a file object. */ - int (*close_)(jas_stream_obj_t *obj); + /* Close a file object. */ + int (*close_)(jas_stream_obj_t *obj); } jas_stream_ops_t; @@ -244,46 +244,46 @@ typedef struct { typedef struct { - /* The mode in which the stream was opened. */ - int openmode_; + /* The mode in which the stream was opened. */ + int openmode_; - /* The buffering mode. */ - int bufmode_; + /* The buffering mode. */ + int bufmode_; - /* The stream status. */ - int flags_; + /* The stream status. */ + int flags_; - /* The start of the buffer area to use for reading/writing. */ - unsigned char *bufbase_; + /* The start of the buffer area to use for reading/writing. */ + unsigned char *bufbase_; - /* The start of the buffer area excluding the extra initial space for - character putback. */ - unsigned char *bufstart_; + /* The start of the buffer area excluding the extra initial space for + character putback. */ + unsigned char *bufstart_; - /* The buffer size. */ - int bufsize_; + /* The buffer size. */ + int bufsize_; - /* The current position in the buffer. */ - unsigned char *ptr_; + /* The current position in the buffer. */ + unsigned char *ptr_; - /* The number of characters that must be read/written before - the buffer needs to be filled/flushed. */ - int cnt_; + /* The number of characters that must be read/written before + the buffer needs to be filled/flushed. */ + int cnt_; - /* A trivial buffer to be used for unbuffered operation. */ - unsigned char tinybuf_[JAS_STREAM_MAXPUTBACK + 1]; + /* A trivial buffer to be used for unbuffered operation. */ + unsigned char tinybuf_[JAS_STREAM_MAXPUTBACK + 1]; - /* The operations for the underlying stream file object. */ - jas_stream_ops_t *ops_; + /* The operations for the underlying stream file object. */ + jas_stream_ops_t *ops_; - /* The underlying stream file object. */ - jas_stream_obj_t *obj_; + /* The underlying stream file object. */ + jas_stream_obj_t *obj_; - /* The number of characters read/written. */ - long rwcnt_; + /* The number of characters read/written. */ + long rwcnt_; - /* The maximum number of characters that may be read/written. */ - long rwlimit_; + /* The maximum number of characters that may be read/written. */ + long rwlimit_; } jas_stream_t; @@ -300,23 +300,23 @@ typedef int jas_stream_fileobj_t; typedef struct { - /* The data associated with this file. */ - unsigned char *buf_; + /* The data associated with this file. */ + unsigned char *buf_; - /* The allocated size of the buffer for holding file data. */ - int bufsize_; + /* The allocated size of the buffer for holding file data. */ + int bufsize_; - /* The length of the file. */ - int_fast32_t len_; + /* The length of the file. */ + int_fast32_t len_; - /* The seek position. */ - int_fast32_t pos_; + /* The seek position. */ + int_fast32_t pos_; - /* Is the buffer growable? */ - int growable_; + /* Is the buffer growable? */ + int growable_; - /* Was the buffer allocated internally? */ - int myalloc_; + /* Was the buffer allocated internally? */ + int myalloc_; } jas_stream_memobj_t; @@ -348,26 +348,26 @@ int jas_stream_close(jas_stream_t *stream); /* Get the EOF indicator for a stream. */ #define jas_stream_eof(stream) \ - (((stream)->flags_ & JAS_STREAM_EOF) != 0) + (((stream)->flags_ & JAS_STREAM_EOF) != 0) /* Get the error indicator for a stream. */ #define jas_stream_error(stream) \ - (((stream)->flags_ & JAS_STREAM_ERR) != 0) + (((stream)->flags_ & JAS_STREAM_ERR) != 0) /* Clear the error indicator for a stream. */ #define jas_stream_clearerr(stream) \ - ((stream)->flags_ &= ~(JAS_STREAM_ERR | JAS_STREAM_EOF)) + ((stream)->flags_ &= ~(JAS_STREAM_ERR | JAS_STREAM_EOF)) /* Get the read/write limit for a stream. */ -#define jas_stream_getrwlimit(stream) \ - (((const jas_stream_t *)(stream))->rwlimit_) +#define jas_stream_getrwlimit(stream) \ + (((const jas_stream_t *)(stream))->rwlimit_) /* Set the read/write limit for a stream. */ int jas_stream_setrwlimit(jas_stream_t *stream, long rwlimit); /* Get the read/write count for a stream. */ -#define jas_stream_getrwcount(stream) \ - (((const jas_stream_t *)(stream))->rwcnt_) +#define jas_stream_getrwcount(stream) \ + (((const jas_stream_t *)(stream))->rwcnt_) /* Set the read/write count for a stream. */ long jas_stream_setrwcount(jas_stream_t *stream, long rwcnt); @@ -378,16 +378,16 @@ long jas_stream_setrwcount(jas_stream_t *stream, long rwcnt); /* Read a character from a stream. */ #if defined(DEBUG) -#define jas_stream_getc(stream) jas_stream_getc_func(stream) +#define jas_stream_getc(stream) jas_stream_getc_func(stream) #else -#define jas_stream_getc(stream) jas_stream_getc_macro(stream) +#define jas_stream_getc(stream) jas_stream_getc_macro(stream) #endif /* Write a character to a stream. */ #if defined(DEBUG) -#define jas_stream_putc(stream, c) jas_stream_putc_func(stream, c) +#define jas_stream_putc(stream, c) jas_stream_putc_func(stream, c) #else -#define jas_stream_putc(stream, c) jas_stream_putc_macro(stream, c) +#define jas_stream_putc(stream, c) jas_stream_putc_macro(stream, c) #endif /* Read characters from a stream into a buffer. */ @@ -407,9 +407,9 @@ char *jas_stream_gets(jas_stream_t *stream, char *buf, int bufsize); /* Look at the next character to be read from a stream without actually removing it from the stream. */ -#define jas_stream_peekc(stream) \ - (((stream)->cnt_ <= 0) ? jas_stream_fillbuf(stream, 0) : \ - ((int)(*(stream)->ptr_))) +#define jas_stream_peekc(stream) \ + (((stream)->cnt_ <= 0) ? jas_stream_fillbuf(stream, 0) : \ + ((int)(*(stream)->ptr_))) /* Put a character back on a stream. */ int jas_stream_ungetc(jas_stream_t *stream, int c); @@ -463,26 +463,26 @@ directly, you will die a horrible, miserable, and painful death! */ /* Read a character from a stream. */ #define jas_stream_getc_macro(stream) \ - ((!((stream)->flags_ & (JAS_STREAM_ERR | JAS_STREAM_EOF | \ - JAS_STREAM_RWLIMIT))) ? \ - (((stream)->rwlimit_ >= 0 && (stream)->rwcnt_ >= (stream)->rwlimit_) ? \ - (stream->flags_ |= JAS_STREAM_RWLIMIT, EOF) : \ - jas_stream_getc2(stream)) : EOF) + ((!((stream)->flags_ & (JAS_STREAM_ERR | JAS_STREAM_EOF | \ + JAS_STREAM_RWLIMIT))) ? \ + (((stream)->rwlimit_ >= 0 && (stream)->rwcnt_ >= (stream)->rwlimit_) ? \ + (stream->flags_ |= JAS_STREAM_RWLIMIT, EOF) : \ + jas_stream_getc2(stream)) : EOF) #define jas_stream_getc2(stream) \ - ((--(stream)->cnt_ < 0) ? jas_stream_fillbuf(stream, 1) : \ - (++(stream)->rwcnt_, (int)(*(stream)->ptr_++))) + ((--(stream)->cnt_ < 0) ? jas_stream_fillbuf(stream, 1) : \ + (++(stream)->rwcnt_, (int)(*(stream)->ptr_++))) /* Write a character to a stream. */ #define jas_stream_putc_macro(stream, c) \ - ((!((stream)->flags_ & (JAS_STREAM_ERR | JAS_STREAM_EOF | \ - JAS_STREAM_RWLIMIT))) ? \ - (((stream)->rwlimit_ >= 0 && (stream)->rwcnt_ >= (stream)->rwlimit_) ? \ - (stream->flags_ |= JAS_STREAM_RWLIMIT, EOF) : \ - jas_stream_putc2(stream, c)) : EOF) + ((!((stream)->flags_ & (JAS_STREAM_ERR | JAS_STREAM_EOF | \ + JAS_STREAM_RWLIMIT))) ? \ + (((stream)->rwlimit_ >= 0 && (stream)->rwcnt_ >= (stream)->rwlimit_) ? \ + (stream->flags_ |= JAS_STREAM_RWLIMIT, EOF) : \ + jas_stream_putc2(stream, c)) : EOF) #define jas_stream_putc2(stream, c) \ - (((stream)->bufmode_ |= JAS_STREAM_WRBUF, --(stream)->cnt_ < 0) ? \ - jas_stream_flushbuf((stream), (unsigned char)(c)) : \ - (++(stream)->rwcnt_, (int)(*(stream)->ptr_++ = (c)))) + (((stream)->bufmode_ |= JAS_STREAM_WRBUF, --(stream)->cnt_ < 0) ? \ + jas_stream_flushbuf((stream), (unsigned char)(c)) : \ + (++(stream)->rwcnt_, (int)(*(stream)->ptr_++ = (c)))) /* These prototypes need to be here for the sake of the stream_getc and stream_putc macros. */ diff --git a/converter/other/jpeg2000/libjasper/include/jasper/jas_string.h b/converter/other/jpeg2000/libjasper/include/jasper/jas_string.h index 55b611ba..ff2d3af4 100644 --- a/converter/other/jpeg2000/libjasper/include/jasper/jas_string.h +++ b/converter/other/jpeg2000/libjasper/include/jasper/jas_string.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -116,8 +116,8 @@ * $Id$ */ -#ifndef JAS_STRING_H -#define JAS_STRING_H +#ifndef JAS_STRING_H +#define JAS_STRING_H /******************************************************************************\ * Includes. diff --git a/converter/other/jpeg2000/libjasper/include/jasper/jas_tvp.h b/converter/other/jpeg2000/libjasper/include/jasper/jas_tvp.h index 9ac50dbd..34e389bf 100644 --- a/converter/other/jpeg2000/libjasper/include/jasper/jas_tvp.h +++ b/converter/other/jpeg2000/libjasper/include/jasper/jas_tvp.h @@ -4,14 +4,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -19,22 +19,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -54,17 +54,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -104,7 +104,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -133,11 +133,11 @@ extern "C" { typedef struct { - int id; - /* The ID for the tag. */ + int id; + /* The ID for the tag. */ - const char *name; - /* The name of the tag. */ + const char *name; + /* The name of the tag. */ } jas_taginfo_t; @@ -145,17 +145,17 @@ typedef struct { typedef struct { - char *buf; - /* The parsing buffer. */ + char *buf; + /* The parsing buffer. */ - char *tag; - /* The current tag name. */ + char *tag; + /* The current tag name. */ - const char *val; - /* The current value. */ + const char *val; + /* The current value. */ - char *pos; - /* The current position in the parsing buffer. */ + char *pos; + /* The current position in the parsing buffer. */ } jas_tvparser_t; diff --git a/converter/other/jpeg2000/libjasper/include/jasper/jas_types.h b/converter/other/jpeg2000/libjasper/include/jasper/jas_types.h index fbcb2ffb..ce12e083 100644 --- a/converter/other/jpeg2000/libjasper/include/jasper/jas_types.h +++ b/converter/other/jpeg2000/libjasper/include/jasper/jas_types.h @@ -10,5 +10,5 @@ /* The below macro is intended to be used for type casts. By using this macro, type casts can be easily located in the source code with tools like "grep". */ -#define JAS_CAST(t, e) \ - ((t) (e)) +#define JAS_CAST(t, e) \ + ((t) (e)) diff --git a/converter/other/jpeg2000/libjasper/include/jasper/jas_version.h b/converter/other/jpeg2000/libjasper/include/jasper/jas_version.h index 2178257c..28442f51 100644 --- a/converter/other/jpeg2000/libjasper/include/jasper/jas_version.h +++ b/converter/other/jpeg2000/libjasper/include/jasper/jas_version.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -128,28 +128,28 @@ extern "C" { #if !defined(JAS_VERSION) /* The version information below should match that specified in the "configure.in" file! */ -#define JAS_VERSION "1.600.0" +#define JAS_VERSION "1.600.0" #endif -#define JAS_COPYRIGHT \ - "Copyright (c) 1999-2000 Image Power, Inc. and the University of\n" \ - " British Columbia.\n" \ - "Copyright (c) 2001-2002 Michael David Adams.\n" \ - "All rights reserved.\n" +#define JAS_COPYRIGHT \ + "Copyright (c) 1999-2000 Image Power, Inc. and the University of\n" \ + " British Columbia.\n" \ + "Copyright (c) 2001-2002 Michael David Adams.\n" \ + "All rights reserved.\n" -#define JAS_NOTES \ - "For more information about this software, please visit the following\n" \ - "web sites/pages:\n" \ - " http://www.ece.ubc.ca/~mdadams/jasper\n" \ - " http://www.jpeg.org/software\n" \ - "To be added to the (moderated) JasPer software announcements\n" \ - "mailing list, send an email to:\n" \ - " jasper-announce-subscribe@yahoogroups.com\n" \ - "To be added to the (unmoderated) JasPer software discussion\n" \ - "mailing list, send an email to:\n" \ - " jasper-discussion-subscribe@yahoogroups.com\n" \ - "Please send any bug reports to:\n" \ - " mdadams@ieee.org\n" +#define JAS_NOTES \ + "For more information about this software, please visit the following\n" \ + "web sites/pages:\n" \ + " http://www.ece.ubc.ca/~mdadams/jasper\n" \ + " http://www.jpeg.org/software\n" \ + "To be added to the (moderated) JasPer software announcements\n" \ + "mailing list, send an email to:\n" \ + " jasper-announce-subscribe@yahoogroups.com\n" \ + "To be added to the (unmoderated) JasPer software discussion\n" \ + "mailing list, send an email to:\n" \ + " jasper-discussion-subscribe@yahoogroups.com\n" \ + "Please send any bug reports to:\n" \ + " mdadams@ieee.org\n" /******************************************************************************\ * Functions. diff --git a/converter/other/jpeg2000/libjasper/include/jasper/jasper.h b/converter/other/jpeg2000/libjasper/include/jasper/jasper.h index b003acfa..68986c65 100644 --- a/converter/other/jpeg2000/libjasper/include/jasper/jasper.h +++ b/converter/other/jpeg2000/libjasper/include/jasper/jasper.h @@ -4,14 +4,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -19,22 +19,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -54,17 +54,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -104,7 +104,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ diff --git a/converter/other/jpeg2000/libjasper/jp2/jp2_cod.c b/converter/other/jpeg2000/libjasper/jp2/jp2_cod.c index c99c9608..510c01a4 100644 --- a/converter/other/jpeg2000/libjasper/jp2/jp2_cod.c +++ b/converter/other/jpeg2000/libjasper/jp2/jp2_cod.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -794,7 +794,7 @@ static int jp2_cmap_getdata(jp2_box_t *box, jas_stream_t *in) return -1; } } - + return 0; } diff --git a/converter/other/jpeg2000/libjasper/jp2/jp2_cod.h b/converter/other/jpeg2000/libjasper/jp2/jp2_cod.h index 96b48d12..86c4c3ee 100644 --- a/converter/other/jpeg2000/libjasper/jp2/jp2_cod.h +++ b/converter/other/jpeg2000/libjasper/jp2/jp2_cod.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -129,188 +129,188 @@ * Macros. \******************************************************************************/ -#define JP2_SPTOBPC(s, p) \ - ((((p) - 1) & 0x7f) | (((s) & 1) << 7)) +#define JP2_SPTOBPC(s, p) \ + ((((p) - 1) & 0x7f) | (((s) & 1) << 7)) /******************************************************************************\ * Box class. \******************************************************************************/ -#define JP2_BOX_HDRLEN 8 +#define JP2_BOX_HDRLEN 8 /* Box types. */ -#define JP2_BOX_JP 0x6a502020 /* Signature */ -#define JP2_BOX_FTYP 0x66747970 /* File Type */ -#define JP2_BOX_JP2H 0x6a703268 /* JP2 Header */ -#define JP2_BOX_IHDR 0x69686472 /* Image Header */ -#define JP2_BOX_BPCC 0x62706363 /* Bits Per Component */ -#define JP2_BOX_COLR 0x636f6c72 /* Color Specification */ -#define JP2_BOX_PCLR 0x70636c72 /* Palette */ -#define JP2_BOX_CMAP 0x636d6170 /* Component Mapping */ -#define JP2_BOX_CDEF 0x63646566 /* Channel Definition */ -#define JP2_BOX_RES 0x72657320 /* Resolution */ -#define JP2_BOX_RESC 0x72657363 /* Capture Resolution */ -#define JP2_BOX_RESD 0x72657364 /* Default Display Resolution */ -#define JP2_BOX_JP2C 0x6a703263 /* Contiguous Code Stream */ -#define JP2_BOX_JP2I 0x6a703269 /* Intellectual Property */ -#define JP2_BOX_XML 0x786d6c20 /* XML */ -#define JP2_BOX_UUID 0x75756964 /* UUID */ -#define JP2_BOX_UINF 0x75696e66 /* UUID Info */ -#define JP2_BOX_ULST 0x75637374 /* UUID List */ -#define JP2_BOX_URL 0x75726c20 /* URL */ - -#define JP2_BOX_SUPER 0x01 -#define JP2_BOX_NODATA 0x02 +#define JP2_BOX_JP 0x6a502020 /* Signature */ +#define JP2_BOX_FTYP 0x66747970 /* File Type */ +#define JP2_BOX_JP2H 0x6a703268 /* JP2 Header */ +#define JP2_BOX_IHDR 0x69686472 /* Image Header */ +#define JP2_BOX_BPCC 0x62706363 /* Bits Per Component */ +#define JP2_BOX_COLR 0x636f6c72 /* Color Specification */ +#define JP2_BOX_PCLR 0x70636c72 /* Palette */ +#define JP2_BOX_CMAP 0x636d6170 /* Component Mapping */ +#define JP2_BOX_CDEF 0x63646566 /* Channel Definition */ +#define JP2_BOX_RES 0x72657320 /* Resolution */ +#define JP2_BOX_RESC 0x72657363 /* Capture Resolution */ +#define JP2_BOX_RESD 0x72657364 /* Default Display Resolution */ +#define JP2_BOX_JP2C 0x6a703263 /* Contiguous Code Stream */ +#define JP2_BOX_JP2I 0x6a703269 /* Intellectual Property */ +#define JP2_BOX_XML 0x786d6c20 /* XML */ +#define JP2_BOX_UUID 0x75756964 /* UUID */ +#define JP2_BOX_UINF 0x75696e66 /* UUID Info */ +#define JP2_BOX_ULST 0x75637374 /* UUID List */ +#define JP2_BOX_URL 0x75726c20 /* URL */ + +#define JP2_BOX_SUPER 0x01 +#define JP2_BOX_NODATA 0x02 /* JP box data. */ -#define JP2_JP_MAGIC 0x0d0a870a -#define JP2_JP_LEN 12 +#define JP2_JP_MAGIC 0x0d0a870a +#define JP2_JP_LEN 12 typedef struct { - uint_fast32_t magic; + uint_fast32_t magic; } jp2_jp_t; /* FTYP box data. */ -#define JP2_FTYP_MAXCOMPATCODES 32 -#define JP2_FTYP_MAJVER 0x6a703220 -#define JP2_FTYP_MINVER 0 -#define JP2_FTYP_COMPATCODE JP2_FTYP_MAJVER +#define JP2_FTYP_MAXCOMPATCODES 32 +#define JP2_FTYP_MAJVER 0x6a703220 +#define JP2_FTYP_MINVER 0 +#define JP2_FTYP_COMPATCODE JP2_FTYP_MAJVER typedef struct { - uint_fast32_t majver; - uint_fast32_t minver; - uint_fast32_t numcompatcodes; - uint_fast32_t compatcodes[JP2_FTYP_MAXCOMPATCODES]; + uint_fast32_t majver; + uint_fast32_t minver; + uint_fast32_t numcompatcodes; + uint_fast32_t compatcodes[JP2_FTYP_MAXCOMPATCODES]; } jp2_ftyp_t; /* IHDR box data. */ -#define JP2_IHDR_COMPTYPE 7 -#define JP2_IHDR_BPCNULL 255 +#define JP2_IHDR_COMPTYPE 7 +#define JP2_IHDR_BPCNULL 255 typedef struct { - uint_fast32_t width; - uint_fast32_t height; - uint_fast16_t numcmpts; - uint_fast8_t bpc; - uint_fast8_t comptype; - uint_fast8_t csunk; - uint_fast8_t ipr; + uint_fast32_t width; + uint_fast32_t height; + uint_fast16_t numcmpts; + uint_fast8_t bpc; + uint_fast8_t comptype; + uint_fast8_t csunk; + uint_fast8_t ipr; } jp2_ihdr_t; /* BPCC box data. */ typedef struct { - uint_fast16_t numcmpts; - uint_fast8_t *bpcs; + uint_fast16_t numcmpts; + uint_fast8_t *bpcs; } jp2_bpcc_t; /* COLR box data. */ -#define JP2_COLR_ENUM 1 -#define JP2_COLR_ICC 2 -#define JP2_COLR_PRI 0 +#define JP2_COLR_ENUM 1 +#define JP2_COLR_ICC 2 +#define JP2_COLR_PRI 0 -#define JP2_COLR_SRGB 16 -#define JP2_COLR_SGRAY 17 -#define JP2_COLR_SYCC 18 +#define JP2_COLR_SRGB 16 +#define JP2_COLR_SGRAY 17 +#define JP2_COLR_SYCC 18 typedef struct { - uint_fast8_t method; - uint_fast8_t pri; - uint_fast8_t approx; - uint_fast32_t csid; - uint_fast8_t *iccp; - int iccplen; - /* XXX - Someday we ought to add ICC profile data here. */ + uint_fast8_t method; + uint_fast8_t pri; + uint_fast8_t approx; + uint_fast32_t csid; + uint_fast8_t *iccp; + int iccplen; + /* XXX - Someday we ought to add ICC profile data here. */ } jp2_colr_t; /* PCLR box data. */ typedef struct { - uint_fast16_t numlutents; - uint_fast8_t numchans; - int_fast32_t *lutdata; - uint_fast8_t *bpc; + uint_fast16_t numlutents; + uint_fast8_t numchans; + int_fast32_t *lutdata; + uint_fast8_t *bpc; } jp2_pclr_t; /* CDEF box per-channel data. */ -#define JP2_CDEF_RGB_R 1 -#define JP2_CDEF_RGB_G 2 -#define JP2_CDEF_RGB_B 3 +#define JP2_CDEF_RGB_R 1 +#define JP2_CDEF_RGB_G 2 +#define JP2_CDEF_RGB_B 3 -#define JP2_CDEF_YCBCR_Y 1 -#define JP2_CDEF_YCBCR_CB 2 -#define JP2_CDEF_YCBCR_CR 3 +#define JP2_CDEF_YCBCR_Y 1 +#define JP2_CDEF_YCBCR_CB 2 +#define JP2_CDEF_YCBCR_CR 3 -#define JP2_CDEF_GRAY_Y 1 +#define JP2_CDEF_GRAY_Y 1 -#define JP2_CDEF_TYPE_COLOR 0 -#define JP2_CDEF_TYPE_OPACITY 1 -#define JP2_CDEF_TYPE_UNSPEC 65535 -#define JP2_CDEF_ASOC_ALL 0 -#define JP2_CDEF_ASOC_NONE 65535 +#define JP2_CDEF_TYPE_COLOR 0 +#define JP2_CDEF_TYPE_OPACITY 1 +#define JP2_CDEF_TYPE_UNSPEC 65535 +#define JP2_CDEF_ASOC_ALL 0 +#define JP2_CDEF_ASOC_NONE 65535 typedef struct { - uint_fast16_t channo; - uint_fast16_t type; - uint_fast16_t assoc; + uint_fast16_t channo; + uint_fast16_t type; + uint_fast16_t assoc; } jp2_cdefchan_t; /* CDEF box data. */ typedef struct { - uint_fast16_t numchans; - jp2_cdefchan_t *ents; + uint_fast16_t numchans; + jp2_cdefchan_t *ents; } jp2_cdef_t; typedef struct { - uint_fast16_t cmptno; - uint_fast8_t map; - uint_fast8_t pcol; + uint_fast16_t cmptno; + uint_fast8_t map; + uint_fast8_t pcol; } jp2_cmapent_t; typedef struct { - uint_fast16_t numchans; - jp2_cmapent_t *ents; + uint_fast16_t numchans; + jp2_cmapent_t *ents; } jp2_cmap_t; -#define JP2_CMAP_DIRECT 0 -#define JP2_CMAP_PALETTE 1 +#define JP2_CMAP_DIRECT 0 +#define JP2_CMAP_PALETTE 1 /* Generic box. */ struct jp2_boxops_s; typedef struct { - struct jp2_boxops_s *ops; - struct jp2_boxinfo_s *info; + struct jp2_boxops_s *ops; + struct jp2_boxinfo_s *info; - uint_fast32_t type; - uint_fast32_t len; + uint_fast32_t type; + uint_fast32_t len; - union { - jp2_jp_t jp; - jp2_ftyp_t ftyp; - jp2_ihdr_t ihdr; - jp2_bpcc_t bpcc; - jp2_colr_t colr; - jp2_pclr_t pclr; - jp2_cdef_t cdef; - jp2_cmap_t cmap; - } data; + union { + jp2_jp_t jp; + jp2_ftyp_t ftyp; + jp2_ihdr_t ihdr; + jp2_bpcc_t bpcc; + jp2_colr_t colr; + jp2_pclr_t pclr; + jp2_cdef_t cdef; + jp2_cmap_t cmap; + } data; } jp2_box_t; typedef struct jp2_boxops_s { - void (*init)(jp2_box_t *box); - void (*destroy)(jp2_box_t *box); - int (*getdata)(jp2_box_t *box, jas_stream_t *in); - int (*putdata)(jp2_box_t *box, jas_stream_t *out); - void (*dumpdata)(jp2_box_t *box, FILE *out); + void (*init)(jp2_box_t *box); + void (*destroy)(jp2_box_t *box); + int (*getdata)(jp2_box_t *box, jas_stream_t *in); + int (*putdata)(jp2_box_t *box, jas_stream_t *out); + void (*dumpdata)(jp2_box_t *box, FILE *out); } jp2_boxops_t; /******************************************************************************\ @@ -318,10 +318,10 @@ typedef struct jp2_boxops_s { \******************************************************************************/ typedef struct jp2_boxinfo_s { - int type; - const char *name; - int flags; - jp2_boxops_t ops; + int type; + const char *name; + int flags; + jp2_boxops_t ops; } jp2_boxinfo_t; /******************************************************************************\ @@ -335,12 +335,12 @@ int jp2_box_put(jp2_box_t *box, jas_stream_t *out); #define JP2_DTYPETOBPC(dtype) \ ((JAS_IMAGE_CDT_GETSGND(dtype) << 7) | (JAS_IMAGE_CDT_GETPREC(dtype) - 1)) -#define JP2_BPCTODTYPE(bpc) \ +#define JP2_BPCTODTYPE(bpc) \ (JAS_IMAGE_CDT_SETSGND(bpc >> 7) | JAS_IMAGE_CDT_SETPREC((bpc & 0x7f) + 1)) -#define ICC_CS_RGB 0x52474220 -#define ICC_CS_YCBCR 0x59436272 -#define ICC_CS_GRAY 0x47524159 +#define ICC_CS_RGB 0x52474220 +#define ICC_CS_YCBCR 0x59436272 +#define ICC_CS_GRAY 0x47524159 jp2_cdefchan_t *jp2_cdef_lookup(jp2_cdef_t *cdef, int channo); diff --git a/converter/other/jpeg2000/libjasper/jp2/jp2_dec.c b/converter/other/jpeg2000/libjasper/jp2/jp2_dec.c index e8d71b0a..b056cfa9 100644 --- a/converter/other/jpeg2000/libjasper/jp2/jp2_dec.c +++ b/converter/other/jpeg2000/libjasper/jp2/jp2_dec.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -256,7 +256,7 @@ jp2_getcs(jp2_colr_t *colr) { static int fromiccpcs(int cs) { - + switch (cs) { case ICC_CS_RGB: return JAS_IMAGE_CS_RGB; @@ -505,7 +505,7 @@ jp2_decode(jas_stream_t * const in, /* Determine the number of channels (which is essentially the number of components after any palette mappings have been applied). */ dec->numchans = dec->cmap ? - dec->cmap->data.cmap.numchans : + dec->cmap->data.cmap.numchans : jas_image_numcmpts(dec->image); /* Perform a basic sanity check on the CMAP box if present. */ diff --git a/converter/other/jpeg2000/libjasper/jp2/jp2_dec.h b/converter/other/jpeg2000/libjasper/jp2/jp2_dec.h index 300be107..0da2b85f 100644 --- a/converter/other/jpeg2000/libjasper/jp2/jp2_dec.h +++ b/converter/other/jpeg2000/libjasper/jp2/jp2_dec.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -119,15 +119,15 @@ typedef struct { - jp2_box_t *pclr; - jp2_box_t *cdef; - jp2_box_t *ihdr; - jp2_box_t *bpcc; - jp2_box_t *cmap; - jp2_box_t *colr; - jas_image_t *image; - uint_fast16_t numchans; - uint_fast16_t *chantocmptlut; + jp2_box_t *pclr; + jp2_box_t *cdef; + jp2_box_t *ihdr; + jp2_box_t *bpcc; + jp2_box_t *cmap; + jp2_box_t *colr; + jas_image_t *image; + uint_fast16_t numchans; + uint_fast16_t *chantocmptlut; } jp2_dec_t; diff --git a/converter/other/jpeg2000/libjasper/jp2/jp2_enc.c b/converter/other/jpeg2000/libjasper/jp2/jp2_enc.c index 12538248..f57233f1 100644 --- a/converter/other/jpeg2000/libjasper/jp2/jp2_enc.c +++ b/converter/other/jpeg2000/libjasper/jp2/jp2_enc.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -134,281 +134,281 @@ static uint_fast32_t jp2_gettypeasoc(int colorspace, int ctype); int jp2_encode(jas_image_t *image, jas_stream_t *out, char *optstr) { - jp2_box_t *box; - jp2_ftyp_t *ftyp; - jp2_ihdr_t *ihdr; - jas_stream_t *tmpstream; - int allcmptssame; - jp2_bpcc_t *bpcc; - long len; - uint_fast16_t cmptno; - jp2_colr_t *colr; - char buf[4096]; - uint_fast32_t overhead; - jp2_cdefchan_t *cdefchanent; - jp2_cdef_t *cdef; - int i; - uint_fast32_t typeasoc; - - box = 0; - tmpstream = 0; - - /* Output the signature box. */ - - if (!(box = jp2_box_create(JP2_BOX_JP))) { - goto error; - } - box->data.jp.magic = JP2_JP_MAGIC; - if (jp2_box_put(box, out)) { - goto error; - } - jp2_box_destroy(box); - box = 0; - - /* Output the file type box. */ - - if (!(box = jp2_box_create(JP2_BOX_FTYP))) { - goto error; - } - ftyp = &box->data.ftyp; - ftyp->majver = JP2_FTYP_MAJVER; - ftyp->minver = JP2_FTYP_MINVER; - ftyp->numcompatcodes = 1; - ftyp->compatcodes[0] = JP2_FTYP_COMPATCODE; - if (jp2_box_put(box, out)) { - goto error; - } - jp2_box_destroy(box); - box = 0; - - /* - * Generate the data portion of the JP2 header box. - * We cannot simply output the header for this box - * since we do not yet know the correct value for the length - * field. - */ - - if (!(tmpstream = jas_stream_memopen(0, 0))) { - goto error; - } - - /* Generate image header box. */ - - if (!(box = jp2_box_create(JP2_BOX_IHDR))) { - goto error; - } - ihdr = &box->data.ihdr; - ihdr->width = jas_image_width(image); - ihdr->height = jas_image_height(image); - ihdr->numcmpts = jas_image_numcmpts(image); - allcmptssame = 0; - ihdr->bpc = allcmptssame ? JP2_SPTOBPC(jas_image_cmptsgnd(image, 0), - jas_image_cmptprec(image, 0)) : JP2_IHDR_BPCNULL; - ihdr->comptype = JP2_IHDR_COMPTYPE; - ihdr->csunk = 0; - ihdr->ipr = 0; - if (jp2_box_put(box, tmpstream)) { - goto error; - } - jp2_box_destroy(box); - box = 0; - - /* Generate bits per component box. */ - - if (!allcmptssame) { - if (!(box = jp2_box_create(JP2_BOX_BPCC))) { - goto error; - } - bpcc = &box->data.bpcc; - bpcc->numcmpts = jas_image_numcmpts(image); - if (!(bpcc->bpcs = jas_malloc(bpcc->numcmpts * - sizeof(uint_fast8_t)))) { - goto error; - } - for (cmptno = 0; cmptno < bpcc->numcmpts; ++cmptno) { - bpcc->bpcs[cmptno] = JP2_SPTOBPC(jas_image_cmptsgnd(image, - cmptno), jas_image_cmptprec(image, cmptno)); - } - if (jp2_box_put(box, tmpstream)) { - goto error; - } - jp2_box_destroy(box); - box = 0; - } - - /* Generate color specification box. */ - - if (!(box = jp2_box_create(JP2_BOX_COLR))) { - goto error; - } - colr = &box->data.colr; - colr->method = JP2_COLR_ENUM; - colr->pri = JP2_COLR_PRI; - colr->approx = 0; - colr->csid = (jas_image_colorspace(image) == JAS_IMAGE_CS_RGB) ? JP2_COLR_SRGB : - JP2_COLR_SGRAY; - if (jp2_box_put(box, tmpstream)) { - goto error; - } - jp2_box_destroy(box); - box = 0; - - if (!(jas_image_colorspace(image) == JAS_IMAGE_CS_RGB && - jas_image_numcmpts(image) == 3 && - jas_image_getcmptbytype(image, 0) == - JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_R) && - jas_image_getcmptbytype(image, 1) == - JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_G) && - jas_image_getcmptbytype(image, 2) == - JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_B)) && - !(jas_image_colorspace(image) == JAS_IMAGE_CS_YCBCR && - jas_image_numcmpts(image) != 3 && - jas_image_getcmptbytype(image, 0) == - JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_YCBCR_Y) && - jas_image_getcmptbytype(image, 1) == - JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_YCBCR_CB) && - jas_image_getcmptbytype(image, 2) == - JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_YCBCR_CR)) && - !(jas_image_colorspace(image) == JAS_IMAGE_CS_GRAY && - jas_image_numcmpts(image) == 1 && - jas_image_getcmptbytype(image, 0) == - JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_GRAY_Y))) { - - if (!(box = jp2_box_create(JP2_BOX_CDEF))) { - goto error; - } - cdef = &box->data.cdef; - cdef->numchans = jas_image_numcmpts(image); - cdef->ents = jas_malloc(cdef->numchans * sizeof(jp2_cdefchan_t)); - for (i = 0; i < jas_image_numcmpts(image); ++i) { - cdefchanent = &cdef->ents[i]; - cdefchanent->channo = i; - typeasoc = jp2_gettypeasoc(jas_image_colorspace(image), jas_image_cmpttype(image, i)); - cdefchanent->type = typeasoc >> 16; - cdefchanent->assoc = typeasoc & 0x7fff; - } - jp2_box_destroy(box); - box = 0; - } - - /* Determine the total length of the JP2 header box. */ - - len = jas_stream_tell(tmpstream); - jas_stream_rewind(tmpstream); - - /* - * Output the JP2 header box and all of the boxes which it contains. - */ - - if (!(box = jp2_box_create(JP2_BOX_JP2H))) { - goto error; - } - box->len = len + JP2_BOX_HDRLEN; - if (jp2_box_put(box, out)) { - goto error; - } - jp2_box_destroy(box); - box = 0; - - if (jas_stream_copy(out, tmpstream, len)) { - goto error; - } - - jas_stream_close(tmpstream); - tmpstream = 0; - - /* - * Output the contiguous code stream box. - */ - - if (!(box = jp2_box_create(JP2_BOX_JP2C))) { - goto error; - } - box->len = 0; - if (jp2_box_put(box, out)) { - goto error; - } - jp2_box_destroy(box); - box = 0; - - /* Output the JPEG-2000 code stream. */ - - overhead = jas_stream_getrwcount(out); - sprintf(buf, "%s\n_jp2overhead=%lu\n", (optstr ? optstr : ""), - (unsigned long) overhead); - - if (jpc_encode(image, out, buf)) { - goto error; - } - - return 0; - abort(); + jp2_box_t *box; + jp2_ftyp_t *ftyp; + jp2_ihdr_t *ihdr; + jas_stream_t *tmpstream; + int allcmptssame; + jp2_bpcc_t *bpcc; + long len; + uint_fast16_t cmptno; + jp2_colr_t *colr; + char buf[4096]; + uint_fast32_t overhead; + jp2_cdefchan_t *cdefchanent; + jp2_cdef_t *cdef; + int i; + uint_fast32_t typeasoc; + + box = 0; + tmpstream = 0; + + /* Output the signature box. */ + + if (!(box = jp2_box_create(JP2_BOX_JP))) { + goto error; + } + box->data.jp.magic = JP2_JP_MAGIC; + if (jp2_box_put(box, out)) { + goto error; + } + jp2_box_destroy(box); + box = 0; + + /* Output the file type box. */ + + if (!(box = jp2_box_create(JP2_BOX_FTYP))) { + goto error; + } + ftyp = &box->data.ftyp; + ftyp->majver = JP2_FTYP_MAJVER; + ftyp->minver = JP2_FTYP_MINVER; + ftyp->numcompatcodes = 1; + ftyp->compatcodes[0] = JP2_FTYP_COMPATCODE; + if (jp2_box_put(box, out)) { + goto error; + } + jp2_box_destroy(box); + box = 0; + + /* + * Generate the data portion of the JP2 header box. + * We cannot simply output the header for this box + * since we do not yet know the correct value for the length + * field. + */ + + if (!(tmpstream = jas_stream_memopen(0, 0))) { + goto error; + } + + /* Generate image header box. */ + + if (!(box = jp2_box_create(JP2_BOX_IHDR))) { + goto error; + } + ihdr = &box->data.ihdr; + ihdr->width = jas_image_width(image); + ihdr->height = jas_image_height(image); + ihdr->numcmpts = jas_image_numcmpts(image); + allcmptssame = 0; + ihdr->bpc = allcmptssame ? JP2_SPTOBPC(jas_image_cmptsgnd(image, 0), + jas_image_cmptprec(image, 0)) : JP2_IHDR_BPCNULL; + ihdr->comptype = JP2_IHDR_COMPTYPE; + ihdr->csunk = 0; + ihdr->ipr = 0; + if (jp2_box_put(box, tmpstream)) { + goto error; + } + jp2_box_destroy(box); + box = 0; + + /* Generate bits per component box. */ + + if (!allcmptssame) { + if (!(box = jp2_box_create(JP2_BOX_BPCC))) { + goto error; + } + bpcc = &box->data.bpcc; + bpcc->numcmpts = jas_image_numcmpts(image); + if (!(bpcc->bpcs = jas_malloc(bpcc->numcmpts * + sizeof(uint_fast8_t)))) { + goto error; + } + for (cmptno = 0; cmptno < bpcc->numcmpts; ++cmptno) { + bpcc->bpcs[cmptno] = JP2_SPTOBPC(jas_image_cmptsgnd(image, + cmptno), jas_image_cmptprec(image, cmptno)); + } + if (jp2_box_put(box, tmpstream)) { + goto error; + } + jp2_box_destroy(box); + box = 0; + } + + /* Generate color specification box. */ + + if (!(box = jp2_box_create(JP2_BOX_COLR))) { + goto error; + } + colr = &box->data.colr; + colr->method = JP2_COLR_ENUM; + colr->pri = JP2_COLR_PRI; + colr->approx = 0; + colr->csid = (jas_image_colorspace(image) == JAS_IMAGE_CS_RGB) ? JP2_COLR_SRGB : + JP2_COLR_SGRAY; + if (jp2_box_put(box, tmpstream)) { + goto error; + } + jp2_box_destroy(box); + box = 0; + + if (!(jas_image_colorspace(image) == JAS_IMAGE_CS_RGB && + jas_image_numcmpts(image) == 3 && + jas_image_getcmptbytype(image, 0) == + JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_R) && + jas_image_getcmptbytype(image, 1) == + JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_G) && + jas_image_getcmptbytype(image, 2) == + JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_RGB_B)) && + !(jas_image_colorspace(image) == JAS_IMAGE_CS_YCBCR && + jas_image_numcmpts(image) != 3 && + jas_image_getcmptbytype(image, 0) == + JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_YCBCR_Y) && + jas_image_getcmptbytype(image, 1) == + JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_YCBCR_CB) && + jas_image_getcmptbytype(image, 2) == + JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_YCBCR_CR)) && + !(jas_image_colorspace(image) == JAS_IMAGE_CS_GRAY && + jas_image_numcmpts(image) == 1 && + jas_image_getcmptbytype(image, 0) == + JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_GRAY_Y))) { + + if (!(box = jp2_box_create(JP2_BOX_CDEF))) { + goto error; + } + cdef = &box->data.cdef; + cdef->numchans = jas_image_numcmpts(image); + cdef->ents = jas_malloc(cdef->numchans * sizeof(jp2_cdefchan_t)); + for (i = 0; i < jas_image_numcmpts(image); ++i) { + cdefchanent = &cdef->ents[i]; + cdefchanent->channo = i; + typeasoc = jp2_gettypeasoc(jas_image_colorspace(image), jas_image_cmpttype(image, i)); + cdefchanent->type = typeasoc >> 16; + cdefchanent->assoc = typeasoc & 0x7fff; + } + jp2_box_destroy(box); + box = 0; + } + + /* Determine the total length of the JP2 header box. */ + + len = jas_stream_tell(tmpstream); + jas_stream_rewind(tmpstream); + + /* + * Output the JP2 header box and all of the boxes which it contains. + */ + + if (!(box = jp2_box_create(JP2_BOX_JP2H))) { + goto error; + } + box->len = len + JP2_BOX_HDRLEN; + if (jp2_box_put(box, out)) { + goto error; + } + jp2_box_destroy(box); + box = 0; + + if (jas_stream_copy(out, tmpstream, len)) { + goto error; + } + + jas_stream_close(tmpstream); + tmpstream = 0; + + /* + * Output the contiguous code stream box. + */ + + if (!(box = jp2_box_create(JP2_BOX_JP2C))) { + goto error; + } + box->len = 0; + if (jp2_box_put(box, out)) { + goto error; + } + jp2_box_destroy(box); + box = 0; + + /* Output the JPEG-2000 code stream. */ + + overhead = jas_stream_getrwcount(out); + sprintf(buf, "%s\n_jp2overhead=%lu\n", (optstr ? optstr : ""), + (unsigned long) overhead); + + if (jpc_encode(image, out, buf)) { + goto error; + } + + return 0; + abort(); error: - if (box) { - jp2_box_destroy(box); - } - if (tmpstream) { - jas_stream_close(tmpstream); - } - return -1; + if (box) { + jp2_box_destroy(box); + } + if (tmpstream) { + jas_stream_close(tmpstream); + } + return -1; } static uint_fast32_t jp2_gettypeasoc(int colorspace, int ctype) { - int type; - int asoc; - - if (ctype & JAS_IMAGE_CT_OPACITY) { - type = JP2_CDEF_TYPE_OPACITY; - asoc = JP2_CDEF_ASOC_ALL; - goto done; - } - - type = JP2_CDEF_TYPE_UNSPEC; - asoc = JP2_CDEF_ASOC_NONE; - switch (colorspace) { - case JAS_IMAGE_CS_RGB: - switch (JAS_IMAGE_CT_COLOR(ctype)) { - case JAS_IMAGE_CT_RGB_R: - type = JP2_CDEF_TYPE_COLOR; - asoc = JP2_CDEF_RGB_R; - break; - case JAS_IMAGE_CT_RGB_G: - type = JP2_CDEF_TYPE_COLOR; - asoc = JP2_CDEF_RGB_G; - break; - case JAS_IMAGE_CT_RGB_B: - type = JP2_CDEF_TYPE_COLOR; - asoc = JP2_CDEF_RGB_B; - break; - } - break; - case JAS_IMAGE_CS_YCBCR: - switch (JAS_IMAGE_CT_COLOR(ctype)) { - case JAS_IMAGE_CT_YCBCR_Y: - type = JP2_CDEF_TYPE_COLOR; - asoc = JP2_CDEF_YCBCR_Y; - break; - case JAS_IMAGE_CT_YCBCR_CB: - type = JP2_CDEF_TYPE_COLOR; - asoc = JP2_CDEF_YCBCR_CB; - break; - case JAS_IMAGE_CT_YCBCR_CR: - type = JP2_CDEF_TYPE_COLOR; - asoc = JP2_CDEF_YCBCR_CR; - break; - } - break; - case JAS_IMAGE_CS_GRAY: - type = JP2_CDEF_TYPE_COLOR; - asoc = JP2_CDEF_GRAY_Y; - break; - } + int type; + int asoc; + + if (ctype & JAS_IMAGE_CT_OPACITY) { + type = JP2_CDEF_TYPE_OPACITY; + asoc = JP2_CDEF_ASOC_ALL; + goto done; + } + + type = JP2_CDEF_TYPE_UNSPEC; + asoc = JP2_CDEF_ASOC_NONE; + switch (colorspace) { + case JAS_IMAGE_CS_RGB: + switch (JAS_IMAGE_CT_COLOR(ctype)) { + case JAS_IMAGE_CT_RGB_R: + type = JP2_CDEF_TYPE_COLOR; + asoc = JP2_CDEF_RGB_R; + break; + case JAS_IMAGE_CT_RGB_G: + type = JP2_CDEF_TYPE_COLOR; + asoc = JP2_CDEF_RGB_G; + break; + case JAS_IMAGE_CT_RGB_B: + type = JP2_CDEF_TYPE_COLOR; + asoc = JP2_CDEF_RGB_B; + break; + } + break; + case JAS_IMAGE_CS_YCBCR: + switch (JAS_IMAGE_CT_COLOR(ctype)) { + case JAS_IMAGE_CT_YCBCR_Y: + type = JP2_CDEF_TYPE_COLOR; + asoc = JP2_CDEF_YCBCR_Y; + break; + case JAS_IMAGE_CT_YCBCR_CB: + type = JP2_CDEF_TYPE_COLOR; + asoc = JP2_CDEF_YCBCR_CB; + break; + case JAS_IMAGE_CT_YCBCR_CR: + type = JP2_CDEF_TYPE_COLOR; + asoc = JP2_CDEF_YCBCR_CR; + break; + } + break; + case JAS_IMAGE_CS_GRAY: + type = JP2_CDEF_TYPE_COLOR; + asoc = JP2_CDEF_GRAY_Y; + break; + } done: - return (type << 16) | asoc; + return (type << 16) | asoc; } diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_bs.c b/converter/other/jpeg2000/libjasper/jpc/jpc_bs.c index c66fcd99..3f693fff 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_bs.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_bs.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -137,66 +137,66 @@ /* Allocate a new bit stream. */ static jpc_bitstream_t *jpc_bitstream_alloc() { - jpc_bitstream_t *bitstream; - - /* Allocate memory for the new bit stream object. */ - if (!(bitstream = jas_malloc(sizeof(jpc_bitstream_t)))) { - return 0; - } - /* Initialize all of the data members. */ - bitstream->stream_ = 0; - bitstream->cnt_ = 0; - bitstream->flags_ = 0; - bitstream->openmode_ = 0; - - return bitstream; + jpc_bitstream_t *bitstream; + + /* Allocate memory for the new bit stream object. */ + if (!(bitstream = jas_malloc(sizeof(jpc_bitstream_t)))) { + return 0; + } + /* Initialize all of the data members. */ + bitstream->stream_ = 0; + bitstream->cnt_ = 0; + bitstream->flags_ = 0; + bitstream->openmode_ = 0; + + return bitstream; } /* Open a bit stream from a stream. */ jpc_bitstream_t *jpc_bitstream_sopen(jas_stream_t *stream, const char *mode) { - jpc_bitstream_t *bitstream; + jpc_bitstream_t *bitstream; - if (!(bitstream = jpc_bitstream_alloc())) { - return 0; - } + if (!(bitstream = jpc_bitstream_alloc())) { + return 0; + } - /* By default, do not close the underlying (character) stream, upon - the close of the bit stream. */ - bitstream->flags_ = JPC_BITSTREAM_NOCLOSE; + /* By default, do not close the underlying (character) stream, upon + the close of the bit stream. */ + bitstream->flags_ = JPC_BITSTREAM_NOCLOSE; - bitstream->stream_ = stream; - bitstream->openmode_ = (mode[0] == 'w') ? JPC_BITSTREAM_WRITE : - JPC_BITSTREAM_READ; + bitstream->stream_ = stream; + bitstream->openmode_ = (mode[0] == 'w') ? JPC_BITSTREAM_WRITE : + JPC_BITSTREAM_READ; - /* Mark the data buffer as empty. */ - bitstream->cnt_ = (bitstream->openmode_ == JPC_BITSTREAM_READ) ? 0 : 8; - bitstream->buf_ = 0; + /* Mark the data buffer as empty. */ + bitstream->cnt_ = (bitstream->openmode_ == JPC_BITSTREAM_READ) ? 0 : 8; + bitstream->buf_ = 0; - return bitstream; + return bitstream; } /* Close a bit stream. */ int jpc_bitstream_close(jpc_bitstream_t *bitstream) { - int ret = 0; - - /* Align to the next byte boundary while considering the effects of - bit stuffing. */ - if (jpc_bitstream_align(bitstream)) { - ret = -1; - } - - /* If necessary, close the underlying (character) stream. */ - if (!(bitstream->flags_ & JPC_BITSTREAM_NOCLOSE) && bitstream->stream_) { - if (jas_stream_close(bitstream->stream_)) { - ret = -1; - } - bitstream->stream_ = 0; - } - - jas_free(bitstream); - return ret; + int ret = 0; + + /* Align to the next byte boundary while considering the effects of + bit stuffing. */ + if (jpc_bitstream_align(bitstream)) { + ret = -1; + } + + /* If necessary, close the underlying (character) stream. */ + if (!(bitstream->flags_ & JPC_BITSTREAM_NOCLOSE) && bitstream->stream_) { + if (jas_stream_close(bitstream->stream_)) { + ret = -1; + } + bitstream->stream_ = 0; + } + + jas_free(bitstream); + return ret; } /******************************************************************************\ @@ -206,64 +206,64 @@ int jpc_bitstream_close(jpc_bitstream_t *bitstream) /* Get a bit from a bit stream. */ int jpc_bitstream_getbit_func(jpc_bitstream_t *bitstream) { - int ret; - JAS_DBGLOG(1000, ("jpc_bitstream_getbit_func(%p)\n", bitstream)); - ret = jpc_bitstream_getbit_macro(bitstream); - JAS_DBGLOG(1000, ("jpc_bitstream_getbit_func -> %d\n", ret)); - return ret; + int ret; + JAS_DBGLOG(1000, ("jpc_bitstream_getbit_func(%p)\n", bitstream)); + ret = jpc_bitstream_getbit_macro(bitstream); + JAS_DBGLOG(1000, ("jpc_bitstream_getbit_func -> %d\n", ret)); + return ret; } /* Put a bit to a bit stream. */ int jpc_bitstream_putbit_func(jpc_bitstream_t *bitstream, int b) { - int ret; - JAS_DBGLOG(1000, ("jpc_bitstream_putbit_func(%p, %d)\n", bitstream, b)); - ret = jpc_bitstream_putbit_macro(bitstream, b); - JAS_DBGLOG(1000, ("jpc_bitstream_putbit_func() -> %d\n", ret)); - return ret; + int ret; + JAS_DBGLOG(1000, ("jpc_bitstream_putbit_func(%p, %d)\n", bitstream, b)); + ret = jpc_bitstream_putbit_macro(bitstream, b); + JAS_DBGLOG(1000, ("jpc_bitstream_putbit_func() -> %d\n", ret)); + return ret; } /* Get one or more bits from a bit stream. */ long jpc_bitstream_getbits(jpc_bitstream_t *bitstream, int n) { - long v; - int u; - - /* We can reliably get at most 31 bits since ISO/IEC 9899 only - guarantees that a long can represent values up to 2^31-1. */ - assert(n >= 0 && n < 32); - - /* Get the number of bits requested from the specified bit stream. */ - v = 0; - while (--n >= 0) { - if ((u = jpc_bitstream_getbit(bitstream)) < 0) { - return -1; - } - v = (v << 1) | u; - } - return v; + long v; + int u; + + /* We can reliably get at most 31 bits since ISO/IEC 9899 only + guarantees that a long can represent values up to 2^31-1. */ + assert(n >= 0 && n < 32); + + /* Get the number of bits requested from the specified bit stream. */ + v = 0; + while (--n >= 0) { + if ((u = jpc_bitstream_getbit(bitstream)) < 0) { + return -1; + } + v = (v << 1) | u; + } + return v; } /* Put one or more bits to a bit stream. */ int jpc_bitstream_putbits(jpc_bitstream_t *bitstream, int n, long v) { - int m; - - /* We can reliably put at most 31 bits since ISO/IEC 9899 only - guarantees that a long can represent values up to 2^31-1. */ - assert(n >= 0 && n < 32); - /* Ensure that only the bits to be output are nonzero. */ - assert(!(v & (~JAS_ONES(n)))); - - /* Put the desired number of bits to the specified bit stream. */ - m = n - 1; - while (--n >= 0) { - if (jpc_bitstream_putbit(bitstream, (v >> m) & 1) == EOF) { - return EOF; - } - v <<= 1; - } - return 0; + int m; + + /* We can reliably put at most 31 bits since ISO/IEC 9899 only + guarantees that a long can represent values up to 2^31-1. */ + assert(n >= 0 && n < 32); + /* Ensure that only the bits to be output are nonzero. */ + assert(!(v & (~JAS_ONES(n)))); + + /* Put the desired number of bits to the specified bit stream. */ + m = n - 1; + while (--n >= 0) { + if (jpc_bitstream_putbit(bitstream, (v >> m) & 1) == EOF) { + return EOF; + } + v <<= 1; + } + return 0; } /******************************************************************************\ @@ -273,30 +273,30 @@ int jpc_bitstream_putbits(jpc_bitstream_t *bitstream, int n, long v) /* Fill the buffer for a bit stream. */ int jpc_bitstream_fillbuf(jpc_bitstream_t *bitstream) { - int c; - /* Note: The count has already been decremented by the caller. */ - assert(bitstream->openmode_ & JPC_BITSTREAM_READ); - assert(bitstream->cnt_ <= 0); - - if (bitstream->flags_ & JPC_BITSTREAM_ERR) { - bitstream->cnt_ = 0; - return -1; - } - - if (bitstream->flags_ & JPC_BITSTREAM_EOF) { - bitstream->buf_ = 0x7f; - bitstream->cnt_ = 7; - return 1; - } - - bitstream->buf_ = (bitstream->buf_ << 8) & 0xffff; - if ((c = jas_stream_getc((bitstream)->stream_)) == EOF) { - bitstream->flags_ |= JPC_BITSTREAM_EOF; - return 1; - } - bitstream->cnt_ = (bitstream->buf_ == 0xff00) ? 6 : 7; - bitstream->buf_ |= c & ((1 << (bitstream->cnt_ + 1)) - 1); - return (bitstream->buf_ >> bitstream->cnt_) & 1; + int c; + /* Note: The count has already been decremented by the caller. */ + assert(bitstream->openmode_ & JPC_BITSTREAM_READ); + assert(bitstream->cnt_ <= 0); + + if (bitstream->flags_ & JPC_BITSTREAM_ERR) { + bitstream->cnt_ = 0; + return -1; + } + + if (bitstream->flags_ & JPC_BITSTREAM_EOF) { + bitstream->buf_ = 0x7f; + bitstream->cnt_ = 7; + return 1; + } + + bitstream->buf_ = (bitstream->buf_ << 8) & 0xffff; + if ((c = jas_stream_getc((bitstream)->stream_)) == EOF) { + bitstream->flags_ |= JPC_BITSTREAM_EOF; + return 1; + } + bitstream->cnt_ = (bitstream->buf_ == 0xff00) ? 6 : 7; + bitstream->buf_ |= c & ((1 << (bitstream->cnt_ + 1)) - 1); + return (bitstream->buf_ >> bitstream->cnt_) & 1; } @@ -308,167 +308,167 @@ int jpc_bitstream_fillbuf(jpc_bitstream_t *bitstream) the effects of bit stuffing)? */ int jpc_bitstream_needalign(jpc_bitstream_t *bitstream) { - if (bitstream->openmode_ & JPC_BITSTREAM_READ) { - /* The bit stream is open for reading. */ - /* If there are any bits buffered for reading, or the - previous byte forced a stuffed bit, alignment is - required. */ - if ((bitstream->cnt_ < 8 && bitstream->cnt_ > 0) || - ((bitstream->buf_ >> 8) & 0xff) == 0xff) { - return 1; - } - } else if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) { - /* The bit stream is open for writing. */ - /* If there are any bits buffered for writing, or the - previous byte forced a stuffed bit, alignment is - required. */ - if ((bitstream->cnt_ < 8 && bitstream->cnt_ >= 0) || - ((bitstream->buf_ >> 8) & 0xff) == 0xff) { - return 1; - } - } else { - /* This should not happen. Famous last words, eh? :-) */ - assert(0); - return -1; - } - return 0; + if (bitstream->openmode_ & JPC_BITSTREAM_READ) { + /* The bit stream is open for reading. */ + /* If there are any bits buffered for reading, or the + previous byte forced a stuffed bit, alignment is + required. */ + if ((bitstream->cnt_ < 8 && bitstream->cnt_ > 0) || + ((bitstream->buf_ >> 8) & 0xff) == 0xff) { + return 1; + } + } else if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) { + /* The bit stream is open for writing. */ + /* If there are any bits buffered for writing, or the + previous byte forced a stuffed bit, alignment is + required. */ + if ((bitstream->cnt_ < 8 && bitstream->cnt_ >= 0) || + ((bitstream->buf_ >> 8) & 0xff) == 0xff) { + return 1; + } + } else { + /* This should not happen. Famous last words, eh? :-) */ + assert(0); + return -1; + } + return 0; } /* How many additional bytes would be output if we align the bit stream? */ int jpc_bitstream_pending(jpc_bitstream_t *bitstream) { - if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) { - /* The bit stream is being used for writing. */ + if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) { + /* The bit stream is being used for writing. */ #if 1 - /* XXX - Is this really correct? Check someday... */ - if (bitstream->cnt_ < 8) { - return 1; - } + /* XXX - Is this really correct? Check someday... */ + if (bitstream->cnt_ < 8) { + return 1; + } #else - if (bitstream->cnt_ < 8) { - if (((bitstream->buf_ >> 8) & 0xff) == 0xff) { - return 2; - } - return 1; - } + if (bitstream->cnt_ < 8) { + if (((bitstream->buf_ >> 8) & 0xff) == 0xff) { + return 2; + } + return 1; + } #endif - return 0; - } else { - /* This operation should not be invoked on a bit stream that - is being used for reading. */ - return -1; - } + return 0; + } else { + /* This operation should not be invoked on a bit stream that + is being used for reading. */ + return -1; + } } /* Align the bit stream to a byte boundary. */ int jpc_bitstream_align(jpc_bitstream_t *bitstream) { - int ret; - if (bitstream->openmode_ & JPC_BITSTREAM_READ) { - ret = jpc_bitstream_inalign(bitstream, 0, 0); - } else if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) { - ret = jpc_bitstream_outalign(bitstream, 0); - } - return ret; + int ret; + if (bitstream->openmode_ & JPC_BITSTREAM_READ) { + ret = jpc_bitstream_inalign(bitstream, 0, 0); + } else if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) { + ret = jpc_bitstream_outalign(bitstream, 0); + } + return ret; } /* Align a bit stream in the input case. */ int jpc_bitstream_inalign(jpc_bitstream_t *bitstream, int fillmask, int filldata) { - int n; - int v; - int u; - int numfill; - int m; - - numfill = 7; - m = 0; - v = 0; - if (bitstream->cnt_ > 0) { - n = bitstream->cnt_; - } else if (!bitstream->cnt_) { - n = ((bitstream->buf_ & 0xff) == 0xff) ? 7 : 0; - } else { - n = 0; - } - if (n > 0) { - if ((u = jpc_bitstream_getbits(bitstream, n)) < 0) { - return -1; - } - m += n; - v = (v << n) | u; - } - if ((bitstream->buf_ & 0xff) == 0xff) { - if ((u = jpc_bitstream_getbits(bitstream, 7)) < 0) { - return -1; - } - v = (v << 7) | u; - m += 7; - } - if (m > numfill) { - v >>= m - numfill; - } else { - filldata >>= numfill - m; - fillmask >>= numfill - m; - } - if (((~(v ^ filldata)) & fillmask) != fillmask) { - /* The actual fill pattern does not match the expected one. */ - return 1; - } - - return 0; + int n; + int v; + int u; + int numfill; + int m; + + numfill = 7; + m = 0; + v = 0; + if (bitstream->cnt_ > 0) { + n = bitstream->cnt_; + } else if (!bitstream->cnt_) { + n = ((bitstream->buf_ & 0xff) == 0xff) ? 7 : 0; + } else { + n = 0; + } + if (n > 0) { + if ((u = jpc_bitstream_getbits(bitstream, n)) < 0) { + return -1; + } + m += n; + v = (v << n) | u; + } + if ((bitstream->buf_ & 0xff) == 0xff) { + if ((u = jpc_bitstream_getbits(bitstream, 7)) < 0) { + return -1; + } + v = (v << 7) | u; + m += 7; + } + if (m > numfill) { + v >>= m - numfill; + } else { + filldata >>= numfill - m; + fillmask >>= numfill - m; + } + if (((~(v ^ filldata)) & fillmask) != fillmask) { + /* The actual fill pattern does not match the expected one. */ + return 1; + } + + return 0; } /* Align a bit stream in the output case. */ int jpc_bitstream_outalign(jpc_bitstream_t *bitstream, int filldata) { - int n; - int v; - - /* Ensure that this bit stream is open for writing. */ - assert(bitstream->openmode_ & JPC_BITSTREAM_WRITE); - - /* Ensure that the first bit of fill data is zero. */ - /* Note: The first bit of fill data must be zero. If this were not - the case, the fill data itself could cause further bit stuffing to - be required (which would cause numerous complications). */ - assert(!(filldata & (~0x3f))); - - if (!bitstream->cnt_) { - if ((bitstream->buf_ & 0xff) == 0xff) { - n = 7; - v = filldata; - } else { - n = 0; - v = 0; - } - } else if (bitstream->cnt_ > 0 && bitstream->cnt_ < 8) { - n = bitstream->cnt_; - v = filldata >> (7 - n); - } else { - n = 0; - v = 0; - return 0; - } - - /* Write the appropriate fill data to the bit stream. */ - if (n > 0) { - if (jpc_bitstream_putbits(bitstream, n, v)) { - return -1; - } - } - if (bitstream->cnt_ < 8) { - assert(bitstream->cnt_ >= 0 && bitstream->cnt_ < 8); - assert((bitstream->buf_ & 0xff) != 0xff); - /* Force the pending byte of output to be written to the - underlying (character) stream. */ - if (jas_stream_putc(bitstream->stream_, bitstream->buf_ & 0xff) == EOF) { - return -1; - } - bitstream->cnt_ = 8; - bitstream->buf_ = (bitstream->buf_ << 8) & 0xffff; - } - - return 0; + int n; + int v; + + /* Ensure that this bit stream is open for writing. */ + assert(bitstream->openmode_ & JPC_BITSTREAM_WRITE); + + /* Ensure that the first bit of fill data is zero. */ + /* Note: The first bit of fill data must be zero. If this were not + the case, the fill data itself could cause further bit stuffing to + be required (which would cause numerous complications). */ + assert(!(filldata & (~0x3f))); + + if (!bitstream->cnt_) { + if ((bitstream->buf_ & 0xff) == 0xff) { + n = 7; + v = filldata; + } else { + n = 0; + v = 0; + } + } else if (bitstream->cnt_ > 0 && bitstream->cnt_ < 8) { + n = bitstream->cnt_; + v = filldata >> (7 - n); + } else { + n = 0; + v = 0; + return 0; + } + + /* Write the appropriate fill data to the bit stream. */ + if (n > 0) { + if (jpc_bitstream_putbits(bitstream, n, v)) { + return -1; + } + } + if (bitstream->cnt_ < 8) { + assert(bitstream->cnt_ >= 0 && bitstream->cnt_ < 8); + assert((bitstream->buf_ & 0xff) != 0xff); + /* Force the pending byte of output to be written to the + underlying (character) stream. */ + if (jas_stream_putc(bitstream->stream_, bitstream->buf_ & 0xff) == EOF) { + return -1; + } + bitstream->cnt_ = 8; + bitstream->buf_ = (bitstream->buf_ << 8) & 0xffff; + } + + return 0; } diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_bs.h b/converter/other/jpeg2000/libjasper/jpc/jpc_bs.h index edb0a2df..2137a435 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_bs.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_bs.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -137,20 +137,20 @@ */ /* Bit stream open for reading. */ -#define JPC_BITSTREAM_READ 0x01 +#define JPC_BITSTREAM_READ 0x01 /* Bit stream open for writing. */ -#define JPC_BITSTREAM_WRITE 0x02 +#define JPC_BITSTREAM_WRITE 0x02 /* * Bit stream flags. */ /* Do not close underlying character stream. */ -#define JPC_BITSTREAM_NOCLOSE 0x01 +#define JPC_BITSTREAM_NOCLOSE 0x01 /* End of file has been reached while reading. */ -#define JPC_BITSTREAM_EOF 0x02 +#define JPC_BITSTREAM_EOF 0x02 /* An I/O error has occurred. */ -#define JPC_BITSTREAM_ERR 0x04 +#define JPC_BITSTREAM_ERR 0x04 /******************************************************************************\ * Types. @@ -160,20 +160,20 @@ typedef struct { - /* Some miscellaneous flags. */ - int flags_; + /* Some miscellaneous flags. */ + int flags_; - /* The input/output buffer. */ - uint_fast16_t buf_; + /* The input/output buffer. */ + uint_fast16_t buf_; - /* The number of bits remaining in the byte being read/written. */ - int cnt_; + /* The number of bits remaining in the byte being read/written. */ + int cnt_; - /* The underlying stream associated with this bit stream. */ - jas_stream_t *stream_; + /* The underlying stream associated with this bit stream. */ + jas_stream_t *stream_; - /* The mode in which this bit stream was opened. */ - int openmode_; + /* The mode in which this bit stream was opened. */ + int openmode_; } jpc_bitstream_t; @@ -193,20 +193,20 @@ int jpc_bitstream_close(jpc_bitstream_t *bitstream); /* Read a bit from a bit stream. */ #if defined(DEBUG) -#define jpc_bitstream_getbit(bitstream) \ - jpc_bitstream_getbit_func(bitstream) +#define jpc_bitstream_getbit(bitstream) \ + jpc_bitstream_getbit_func(bitstream) #else #define jpc_bitstream_getbit(bitstream) \ - jpc_bitstream_getbit_macro(bitstream) + jpc_bitstream_getbit_macro(bitstream) #endif /* Write a bit to a bit stream. */ #if defined(DEBUG) -#define jpc_bitstream_putbit(bitstream, v) \ - jpc_bitstream_putbit_func(bitstream, v) +#define jpc_bitstream_putbit(bitstream, v) \ + jpc_bitstream_putbit_func(bitstream, v) #else -#define jpc_bitstream_putbit(bitstream, v) \ - jpc_bitstream_putbit_macro(bitstream, v) +#define jpc_bitstream_putbit(bitstream, v) \ + jpc_bitstream_putbit_macro(bitstream, v) #endif /* Read one or more bits from a bit stream. */ @@ -245,7 +245,7 @@ int jpc_bitstream_pending(jpc_bitstream_t *bitstream); /* Has EOF been encountered on a bit stream? */ #define jpc_bitstream_eof(bitstream) \ - ((bitstream)->flags_ & JPC_BITSTREAM_EOF) + ((bitstream)->flags_ & JPC_BITSTREAM_EOF) /******************************************************************************\ * Internals. @@ -260,21 +260,21 @@ int jpc_bitstream_putbit_func(jpc_bitstream_t *bitstream, int v); int jpc_bitstream_fillbuf(jpc_bitstream_t *bitstream); -#define jpc_bitstream_getbit_macro(bitstream) \ - (assert((bitstream)->openmode_ & JPC_BITSTREAM_READ), \ - (--(bitstream)->cnt_ >= 0) ? \ - (((bitstream)->buf_ >> (bitstream)->cnt_) & 1) : \ - jpc_bitstream_fillbuf(bitstream)) +#define jpc_bitstream_getbit_macro(bitstream) \ + (assert((bitstream)->openmode_ & JPC_BITSTREAM_READ), \ + (--(bitstream)->cnt_ >= 0) ? \ + (((bitstream)->buf_ >> (bitstream)->cnt_) & 1) : \ + jpc_bitstream_fillbuf(bitstream)) #define jpc_bitstream_putbit_macro(bitstream, bit) \ - (assert((bitstream)->openmode_ & JPC_BITSTREAM_WRITE), \ - (--(bitstream)->cnt_ < 0) ? \ - ((bitstream)->buf_ = ((bitstream)->buf_ << 8) & 0xffff, \ - (bitstream)->cnt_ = ((bitstream)->buf_ == 0xff00) ? 6 : 7, \ - (bitstream)->buf_ |= ((bit) & 1) << (bitstream)->cnt_, \ - (jas_stream_putc((bitstream)->stream_, (bitstream)->buf_ >> 8) == EOF) \ - ? (EOF) : ((bit) & 1)) : \ - ((bitstream)->buf_ |= ((bit) & 1) << (bitstream)->cnt_, \ - (bit) & 1)) + (assert((bitstream)->openmode_ & JPC_BITSTREAM_WRITE), \ + (--(bitstream)->cnt_ < 0) ? \ + ((bitstream)->buf_ = ((bitstream)->buf_ << 8) & 0xffff, \ + (bitstream)->cnt_ = ((bitstream)->buf_ == 0xff00) ? 6 : 7, \ + (bitstream)->buf_ |= ((bit) & 1) << (bitstream)->cnt_, \ + (jas_stream_putc((bitstream)->stream_, (bitstream)->buf_ >> 8) == EOF) \ + ? (EOF) : ((bit) & 1)) : \ + ((bitstream)->buf_ |= ((bit) & 1) << (bitstream)->cnt_, \ + (bit) & 1)) #endif diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_cod.h b/converter/other/jpeg2000/libjasper/jpc/jpc_cod.h index 9b3ddbee..cff7e72b 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_cod.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_cod.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -122,6 +122,6 @@ \******************************************************************************/ /* The nominal word size used by this implementation. */ -#define JPC_PREC 32 +#define JPC_PREC 32 #endif diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_cs.c b/converter/other/jpeg2000/libjasper/jpc/jpc_cs.c index 559f36cf..441f8995 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_cs.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_cs.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_cs.h b/converter/other/jpeg2000/libjasper/jpc/jpc_cs.h index 4bff677c..13787d40 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_cs.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_cs.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -133,13 +133,13 @@ \******************************************************************************/ /* The maximum number of resolution levels. */ -#define JPC_MAXRLVLS 33 +#define JPC_MAXRLVLS 33 /* The maximum number of bands. */ -#define JPC_MAXBANDS (3 * JPC_MAXRLVLS + 1) +#define JPC_MAXBANDS (3 * JPC_MAXRLVLS + 1) /* The maximum number of layers. */ -#define JPC_MAXLYRS 16384 +#define JPC_MAXLYRS 16384 /**************************************\ * Code stream. @@ -150,15 +150,15 @@ */ /* Initial. */ -#define JPC_CS_INIT 0 +#define JPC_CS_INIT 0 /* Main header. */ -#define JPC_CS_MHDR 1 +#define JPC_CS_MHDR 1 /* Tile-part header. */ -#define JPC_CS_THDR 2 +#define JPC_CS_THDR 2 /* Main trailer. */ -#define JPC_CS_MTLR 3 +#define JPC_CS_MTLR 3 /* Tile-part data. */ -#define JPC_CS_TDATA 4 +#define JPC_CS_TDATA 4 /* * Unfortunately, the code stream syntax was not designed in such a way that @@ -174,8 +174,8 @@ typedef struct { - /* The number of components. */ - int numcomps; + /* The number of components. */ + int numcomps; } jpc_cstate_t; @@ -185,18 +185,18 @@ typedef struct { typedef struct { - /* The tile number. */ - uint_fast16_t tileno; + /* The tile number. */ + uint_fast16_t tileno; - /* The combined length of the marker segment and its auxiliary data - (i.e., packet data). */ - uint_fast32_t len; + /* The combined length of the marker segment and its auxiliary data + (i.e., packet data). */ + uint_fast32_t len; - /* The tile-part instance. */ - uint_fast8_t partno; + /* The tile-part instance. */ + uint_fast8_t partno; - /* The number of tile-parts. */ - uint_fast8_t numparts; + /* The number of tile-parts. */ + uint_fast8_t numparts; } jpc_sot_t; @@ -208,19 +208,19 @@ typedef struct { typedef struct { - /* The precision of the samples. */ - uint_fast8_t prec; + /* The precision of the samples. */ + uint_fast8_t prec; - /* The signedness of the samples. */ - uint_fast8_t sgnd; + /* The signedness of the samples. */ + uint_fast8_t sgnd; - /* The horizontal separation of samples with respect to the reference - grid. */ - uint_fast8_t hsamp; + /* The horizontal separation of samples with respect to the reference + grid. */ + uint_fast8_t hsamp; - /* The vertical separation of samples with respect to the reference - grid. */ - uint_fast8_t vsamp; + /* The vertical separation of samples with respect to the reference + grid. */ + uint_fast8_t vsamp; } jpc_sizcomp_t; @@ -228,42 +228,42 @@ typedef struct { typedef struct { - /* The code stream capabilities. */ - uint_fast16_t caps; + /* The code stream capabilities. */ + uint_fast16_t caps; - /* The width of the image in units of the reference grid. */ - uint_fast32_t width; + /* The width of the image in units of the reference grid. */ + uint_fast32_t width; - /* The height of the image in units of the reference grid. */ - uint_fast32_t height; + /* The height of the image in units of the reference grid. */ + uint_fast32_t height; - /* The horizontal offset from the origin of the reference grid to the - left side of the image area. */ - uint_fast32_t xoff; + /* The horizontal offset from the origin of the reference grid to the + left side of the image area. */ + uint_fast32_t xoff; - /* The vertical offset from the origin of the reference grid to the - top side of the image area. */ - uint_fast32_t yoff; + /* The vertical offset from the origin of the reference grid to the + top side of the image area. */ + uint_fast32_t yoff; - /* The nominal width of a tile in units of the reference grid. */ - uint_fast32_t tilewidth; + /* The nominal width of a tile in units of the reference grid. */ + uint_fast32_t tilewidth; - /* The nominal height of a tile in units of the reference grid. */ - uint_fast32_t tileheight; + /* The nominal height of a tile in units of the reference grid. */ + uint_fast32_t tileheight; - /* The horizontal offset from the origin of the reference grid to the - left side of the first tile. */ - uint_fast32_t tilexoff; + /* The horizontal offset from the origin of the reference grid to the + left side of the first tile. */ + uint_fast32_t tilexoff; - /* The vertical offset from the origin of the reference grid to the - top side of the first tile. */ - uint_fast32_t tileyoff; + /* The vertical offset from the origin of the reference grid to the + top side of the first tile. */ + uint_fast32_t tileyoff; - /* The number of components. */ - uint_fast16_t numcomps; + /* The number of components. */ + uint_fast16_t numcomps; - /* The per-component information. */ - jpc_sizcomp_t *comps; + /* The per-component information. */ + jpc_sizcomp_t *comps; } jpc_siz_t; @@ -276,11 +276,11 @@ typedef struct { */ /* Precincts may be used. */ -#define JPC_COX_PRT 0x01 +#define JPC_COX_PRT 0x01 /* SOP marker segments may be used. */ -#define JPC_COD_SOP 0x02 +#define JPC_COD_SOP 0x02 /* EPH marker segments may be used. */ -#define JPC_COD_EPH 0x04 +#define JPC_COD_EPH 0x04 /* * Progression order constants. @@ -288,50 +288,50 @@ typedef struct { /* Layer-resolution-component-precinct progressive (i.e., progressive by fidelity). */ -#define JPC_COD_LRCPPRG 0 +#define JPC_COD_LRCPPRG 0 /* Resolution-layer-component-precinct progressive (i.e., progressive by resolution). */ -#define JPC_COD_RLCPPRG 1 +#define JPC_COD_RLCPPRG 1 /* Resolution-precinct-component-layer progressive. */ -#define JPC_COD_RPCLPRG 2 +#define JPC_COD_RPCLPRG 2 /* Precinct-component-resolution-layer progressive. */ -#define JPC_COD_PCRLPRG 3 +#define JPC_COD_PCRLPRG 3 /* Component-position-resolution-layer progressive. */ -#define JPC_COD_CPRLPRG 4 +#define JPC_COD_CPRLPRG 4 /* * Code block style constants. */ -#define JPC_COX_LAZY 0x01 /* Selective arithmetic coding bypass. */ -#define JPC_COX_RESET 0x02 /* Reset context probabilities. */ -#define JPC_COX_TERMALL 0x04 /* Terminate all coding passes. */ -#define JPC_COX_VSC 0x08 /* Vertical stripe causal context formation. */ -#define JPC_COX_PTERM 0x10 /* Predictable termination. */ -#define JPC_COX_SEGSYM 0x20 /* Use segmentation symbols. */ +#define JPC_COX_LAZY 0x01 /* Selective arithmetic coding bypass. */ +#define JPC_COX_RESET 0x02 /* Reset context probabilities. */ +#define JPC_COX_TERMALL 0x04 /* Terminate all coding passes. */ +#define JPC_COX_VSC 0x08 /* Vertical stripe causal context formation. */ +#define JPC_COX_PTERM 0x10 /* Predictable termination. */ +#define JPC_COX_SEGSYM 0x20 /* Use segmentation symbols. */ /* Transform constants. */ -#define JPC_COX_INS 0x00 /* Irreversible 9/7. */ -#define JPC_COX_RFT 0x01 /* Reversible 5/3. */ +#define JPC_COX_INS 0x00 /* Irreversible 9/7. */ +#define JPC_COX_RFT 0x01 /* Reversible 5/3. */ /* Multicomponent transform constants. */ -#define JPC_COD_NOMCT 0x00 /* No multicomponent transform. */ -#define JPC_COD_MCT 0x01 /* Multicomponent transform. */ +#define JPC_COD_NOMCT 0x00 /* No multicomponent transform. */ +#define JPC_COD_MCT 0x01 /* Multicomponent transform. */ /* Get the code block size value from the code block size exponent. */ -#define JPC_COX_CBLKSIZEEXPN(x) ((x) - 2) +#define JPC_COX_CBLKSIZEEXPN(x) ((x) - 2) /* Get the code block size exponent from the code block size value. */ -#define JPC_COX_GETCBLKSIZEEXPN(x) ((x) + 2) +#define JPC_COX_GETCBLKSIZEEXPN(x) ((x) + 2) /* Per resolution-level information. */ typedef struct { - /* The packet partition width. */ - uint_fast8_t parwidthval; + /* The packet partition width. */ + uint_fast8_t parwidthval; - /* The packet partition height. */ - uint_fast8_t parheightval; + /* The packet partition height. */ + uint_fast8_t parheightval; } jpc_coxrlvl_t; @@ -339,29 +339,29 @@ typedef struct { typedef struct { - /* The coding style. */ - uint_fast8_t csty; + /* The coding style. */ + uint_fast8_t csty; - /* The number of decomposition levels. */ - uint_fast8_t numdlvls; + /* The number of decomposition levels. */ + uint_fast8_t numdlvls; - /* The nominal code block width specifier. */ - uint_fast8_t cblkwidthval; + /* The nominal code block width specifier. */ + uint_fast8_t cblkwidthval; - /* The nominal code block height specifier. */ - uint_fast8_t cblkheightval; + /* The nominal code block height specifier. */ + uint_fast8_t cblkheightval; - /* The style of coding passes. */ - uint_fast8_t cblksty; + /* The style of coding passes. */ + uint_fast8_t cblksty; - /* The QMFB employed. */ - uint_fast8_t qmfbid; + /* The QMFB employed. */ + uint_fast8_t qmfbid; - /* The number of resolution levels. */ - int numrlvls; + /* The number of resolution levels. */ + int numrlvls; - /* The per-resolution-level information. */ - jpc_coxrlvl_t rlvls[JPC_MAXRLVLS]; + /* The per-resolution-level information. */ + jpc_coxrlvl_t rlvls[JPC_MAXRLVLS]; } jpc_coxcp_t; @@ -369,20 +369,20 @@ typedef struct { typedef struct { - /* The general coding style. */ - uint_fast8_t csty; + /* The general coding style. */ + uint_fast8_t csty; - /* The progression order. */ - uint_fast8_t prg; + /* The progression order. */ + uint_fast8_t prg; - /* The number of layers. */ - uint_fast16_t numlyrs; + /* The number of layers. */ + uint_fast16_t numlyrs; - /* The multicomponent transform. */ - uint_fast8_t mctrans; + /* The multicomponent transform. */ + uint_fast8_t mctrans; - /* Component-related parameters. */ - jpc_coxcp_t compparms; + /* Component-related parameters. */ + jpc_coxcp_t compparms; } jpc_cod_t; @@ -390,11 +390,11 @@ typedef struct { typedef struct { - /* The component number. */ - uint_fast16_t compno; + /* The component number. */ + uint_fast16_t compno; - /* Component-related parameters. */ - jpc_coxcp_t compparms; + /* Component-related parameters. */ + jpc_coxcp_t compparms; } jpc_coc_t; @@ -403,18 +403,18 @@ typedef struct { \**************************************/ /* The maxshift ROI style. */ -#define JPC_RGN_MAXSHIFT 0x00 +#define JPC_RGN_MAXSHIFT 0x00 typedef struct { - /* The component to which the marker applies. */ - uint_fast16_t compno; + /* The component to which the marker applies. */ + uint_fast16_t compno; - /* The ROI style. */ - uint_fast8_t roisty; + /* The ROI style. */ + uint_fast8_t roisty; - /* The ROI shift value. */ - uint_fast8_t roishift; + /* The ROI shift value. */ + uint_fast8_t roishift; } jpc_rgn_t; @@ -426,34 +426,34 @@ typedef struct { * Quantization style constants. */ -#define JPC_QCX_NOQNT 0 /* No quantization. */ -#define JPC_QCX_SIQNT 1 /* Scalar quantization, implicit. */ -#define JPC_QCX_SEQNT 2 /* Scalar quantization, explicit. */ +#define JPC_QCX_NOQNT 0 /* No quantization. */ +#define JPC_QCX_SIQNT 1 /* Scalar quantization, implicit. */ +#define JPC_QCX_SEQNT 2 /* Scalar quantization, explicit. */ /* * Stepsize manipulation macros. */ -#define JPC_QCX_GETEXPN(x) ((x) >> 11) -#define JPC_QCX_GETMANT(x) ((x) & 0x07ff) -#define JPC_QCX_EXPN(x) (assert(!((x) & (~0x1f))), (((x) & 0x1f) << 11)) -#define JPC_QCX_MANT(x) (assert(!((x) & (~0x7ff))), ((x) & 0x7ff)) +#define JPC_QCX_GETEXPN(x) ((x) >> 11) +#define JPC_QCX_GETMANT(x) ((x) & 0x07ff) +#define JPC_QCX_EXPN(x) (assert(!((x) & (~0x1f))), (((x) & 0x1f) << 11)) +#define JPC_QCX_MANT(x) (assert(!((x) & (~0x7ff))), ((x) & 0x7ff)) /* Per component information. */ typedef struct { - /* The quantization style. */ - uint_fast8_t qntsty; + /* The quantization style. */ + uint_fast8_t qntsty; - /* The number of step sizes. */ - int numstepsizes; + /* The number of step sizes. */ + int numstepsizes; - /* The step sizes. */ - uint_fast16_t *stepsizes; + /* The step sizes. */ + uint_fast16_t *stepsizes; - /* The number of guard bits. */ - uint_fast8_t numguard; + /* The number of guard bits. */ + uint_fast8_t numguard; } jpc_qcxcp_t; @@ -461,11 +461,11 @@ typedef struct { typedef struct { - /* The component associated with this marker segment. */ - uint_fast16_t compno; + /* The component associated with this marker segment. */ + uint_fast16_t compno; - /* The parameters. */ - jpc_qcxcp_t compparms; + /* The parameters. */ + jpc_qcxcp_t compparms; } jpc_qcc_t; @@ -473,8 +473,8 @@ typedef struct { typedef struct { - /* The parameters. */ - jpc_qcxcp_t compparms; + /* The parameters. */ + jpc_qcxcp_t compparms; } jpc_qcd_t; @@ -484,28 +484,28 @@ typedef struct { typedef struct { - /* The progression order. */ - uint_fast8_t prgord; + /* The progression order. */ + uint_fast8_t prgord; - /* The lower bound (inclusive) on the resolution level for the - progression order volume. */ - uint_fast8_t rlvlnostart; + /* The lower bound (inclusive) on the resolution level for the + progression order volume. */ + uint_fast8_t rlvlnostart; - /* The upper bound (exclusive) on the resolution level for the - progression order volume. */ - uint_fast8_t rlvlnoend; + /* The upper bound (exclusive) on the resolution level for the + progression order volume. */ + uint_fast8_t rlvlnoend; - /* The lower bound (inclusive) on the component for the progression - order volume. */ - uint_fast16_t compnostart; + /* The lower bound (inclusive) on the component for the progression + order volume. */ + uint_fast16_t compnostart; - /* The upper bound (exclusive) on the component for the progression - order volume. */ - uint_fast16_t compnoend; + /* The upper bound (exclusive) on the component for the progression + order volume. */ + uint_fast16_t compnoend; - /* The upper bound (exclusive) on the layer for the progression - order volume. */ - uint_fast16_t lyrnoend; + /* The upper bound (exclusive) on the layer for the progression + order volume. */ + uint_fast16_t lyrnoend; } jpc_pocpchg_t; @@ -516,11 +516,11 @@ typedef jpc_pocpchg_t jpc_pchg_t; typedef struct { - /* The number of progression order changes. */ - int numpchgs; + /* The number of progression order changes. */ + int numpchgs; - /* The per-progression-order-change information. */ - jpc_pocpchg_t *pchgs; + /* The per-progression-order-change information. */ + jpc_pocpchg_t *pchgs; } jpc_poc_t; @@ -532,14 +532,14 @@ typedef struct { typedef struct { - /* The index. */ - uint_fast8_t ind; + /* The index. */ + uint_fast8_t ind; - /* The length. */ - uint_fast16_t len; + /* The length. */ + uint_fast16_t len; - /* The data. */ - unsigned char *data; + /* The data. */ + unsigned char *data; } jpc_ppm_t; @@ -547,14 +547,14 @@ typedef struct { typedef struct { - /* The index. */ - uint_fast8_t ind; + /* The index. */ + uint_fast8_t ind; - /* The length. */ - uint_fast32_t len; + /* The length. */ + uint_fast32_t len; - /* The data. */ - unsigned char *data; + /* The data. */ + unsigned char *data; } jpc_ppt_t; @@ -566,19 +566,19 @@ typedef struct { * Registration IDs. */ -#define JPC_COM_BIN 0x00 -#define JPC_COM_LATIN 0x01 +#define JPC_COM_BIN 0x00 +#define JPC_COM_LATIN 0x01 typedef struct { - /* The registration ID. */ - uint_fast16_t regid; + /* The registration ID. */ + uint_fast16_t regid; - /* The length of the data in bytes. */ - uint_fast16_t len; + /* The length of the data in bytes. */ + uint_fast16_t len; - /* The data. */ - unsigned char *data; + /* The data. */ + unsigned char *data; } jpc_com_t; @@ -588,8 +588,8 @@ typedef struct { typedef struct { - /* The sequence number. */ - uint_fast16_t seqno; + /* The sequence number. */ + uint_fast16_t seqno; } jpc_sop_t; @@ -601,21 +601,21 @@ typedef struct { typedef struct { - /* The horizontal offset. */ - uint_fast16_t hoff; + /* The horizontal offset. */ + uint_fast16_t hoff; - /* The vertical offset. */ - uint_fast16_t voff; + /* The vertical offset. */ + uint_fast16_t voff; } jpc_crgcomp_t; typedef struct { - /* The number of components. */ - int numcomps; + /* The number of components. */ + int numcomps; - /* Per component information. */ - jpc_crgcomp_t *comps; + /* Per component information. */ + jpc_crgcomp_t *comps; } jpc_crg_t; @@ -625,11 +625,11 @@ typedef struct { typedef struct { - /* The data. */ - unsigned char *data; + /* The data. */ + unsigned char *data; - /* The length. */ - uint_fast16_t len; + /* The length. */ + uint_fast16_t len; } jpc_unk_t; @@ -638,26 +638,26 @@ typedef struct { \**************************************/ typedef union { - int soc; /* unused */ - jpc_sot_t sot; - int sod; /* unused */ - int eoc; /* unused */ - jpc_siz_t siz; - jpc_cod_t cod; - jpc_coc_t coc; - jpc_rgn_t rgn; - jpc_qcd_t qcd; - jpc_qcc_t qcc; - jpc_poc_t poc; - /* jpc_plm_t plm; */ - /* jpc_plt_t plt; */ - jpc_ppm_t ppm; - jpc_ppt_t ppt; - jpc_sop_t sop; - int eph; /* unused */ - jpc_com_t com; - jpc_crg_t crg; - jpc_unk_t unk; + int soc; /* unused */ + jpc_sot_t sot; + int sod; /* unused */ + int eoc; /* unused */ + jpc_siz_t siz; + jpc_cod_t cod; + jpc_coc_t coc; + jpc_rgn_t rgn; + jpc_qcd_t qcd; + jpc_qcc_t qcc; + jpc_poc_t poc; + /* jpc_plm_t plm; */ + /* jpc_plt_t plt; */ + jpc_ppm_t ppm; + jpc_ppt_t ppt; + jpc_sop_t sop; + int eph; /* unused */ + jpc_com_t com; + jpc_crg_t crg; + jpc_unk_t unk; } jpc_msparms_t; /**************************************\ @@ -667,47 +667,47 @@ typedef union { /* Marker segment IDs. */ /* The smallest valid marker value. */ -#define JPC_MS_MIN 0xff00 +#define JPC_MS_MIN 0xff00 /* The largest valid marker value. */ -#define JPC_MS_MAX 0xffff +#define JPC_MS_MAX 0xffff /* The minimum marker value that cannot occur within packet data. */ -#define JPC_MS_INMIN 0xff80 +#define JPC_MS_INMIN 0xff80 /* The maximum marker value that cannot occur within packet data. */ -#define JPC_MS_INMAX 0xffff +#define JPC_MS_INMAX 0xffff /* Delimiting marker segments. */ -#define JPC_MS_SOC 0xff4f /* Start of code stream (SOC). */ -#define JPC_MS_SOT 0xff90 /* Start of tile-part (SOT). */ -#define JPC_MS_SOD 0xff93 /* Start of data (SOD). */ -#define JPC_MS_EOC 0xffd9 /* End of code stream (EOC). */ +#define JPC_MS_SOC 0xff4f /* Start of code stream (SOC). */ +#define JPC_MS_SOT 0xff90 /* Start of tile-part (SOT). */ +#define JPC_MS_SOD 0xff93 /* Start of data (SOD). */ +#define JPC_MS_EOC 0xffd9 /* End of code stream (EOC). */ /* Fixed information marker segments. */ -#define JPC_MS_SIZ 0xff51 /* Image and tile size (SIZ). */ +#define JPC_MS_SIZ 0xff51 /* Image and tile size (SIZ). */ /* Functional marker segments. */ -#define JPC_MS_COD 0xff52 /* Coding style default (COD). */ -#define JPC_MS_COC 0xff53 /* Coding style component (COC). */ -#define JPC_MS_RGN 0xff5e /* Region of interest (RGN). */ -#define JPC_MS_QCD 0xff5c /* Quantization default (QCD). */ -#define JPC_MS_QCC 0xff5d /* Quantization component (QCC). */ -#define JPC_MS_POC 0xff5f /* Progression order default (POC). */ +#define JPC_MS_COD 0xff52 /* Coding style default (COD). */ +#define JPC_MS_COC 0xff53 /* Coding style component (COC). */ +#define JPC_MS_RGN 0xff5e /* Region of interest (RGN). */ +#define JPC_MS_QCD 0xff5c /* Quantization default (QCD). */ +#define JPC_MS_QCC 0xff5d /* Quantization component (QCC). */ +#define JPC_MS_POC 0xff5f /* Progression order default (POC). */ /* Pointer marker segments. */ -#define JPC_MS_TLM 0xff55 /* Tile-part lengths, main header (TLM). */ -#define JPC_MS_PLM 0xff57 /* Packet length, main header (PLM). */ -#define JPC_MS_PLT 0xff58 /* Packet length, tile-part header (PLT). */ -#define JPC_MS_PPM 0xff60 /* Packed packet headers, main header (PPM). */ -#define JPC_MS_PPT 0xff61 /* Packet packet headers, tile-part header (PPT). */ +#define JPC_MS_TLM 0xff55 /* Tile-part lengths, main header (TLM). */ +#define JPC_MS_PLM 0xff57 /* Packet length, main header (PLM). */ +#define JPC_MS_PLT 0xff58 /* Packet length, tile-part header (PLT). */ +#define JPC_MS_PPM 0xff60 /* Packed packet headers, main header (PPM). */ +#define JPC_MS_PPT 0xff61 /* Packet packet headers, tile-part header (PPT). */ /* In bit stream marker segments. */ -#define JPC_MS_SOP 0xff91 /* Start of packet (SOP). */ -#define JPC_MS_EPH 0xff92 /* End of packet header (EPH). */ +#define JPC_MS_SOP 0xff91 /* Start of packet (SOP). */ +#define JPC_MS_EPH 0xff92 /* End of packet header (EPH). */ /* Informational marker segments. */ -#define JPC_MS_CRG 0xff63 /* Component registration (CRG). */ -#define JPC_MS_COM 0xff64 /* Comment (COM). */ +#define JPC_MS_CRG 0xff63 /* Component registration (CRG). */ +#define JPC_MS_COM 0xff64 /* Comment (COM). */ /* Forward declaration. */ struct jpc_msops_s; @@ -716,20 +716,20 @@ struct jpc_msops_s; typedef struct { - /* The type of marker segment. */ - uint_fast16_t id; + /* The type of marker segment. */ + uint_fast16_t id; - /* The length of the marker segment. */ - uint_fast16_t len; + /* The length of the marker segment. */ + uint_fast16_t len; - /* The starting offset within the stream. */ - uint_fast32_t off; + /* The starting offset within the stream. */ + uint_fast32_t off; - /* The parameters of the marker segment. */ - jpc_msparms_t parms; + /* The parameters of the marker segment. */ + jpc_msparms_t parms; - /* The marker segment operations. */ - struct jpc_msops_s *ops; + /* The marker segment operations. */ + struct jpc_msops_s *ops; } jpc_ms_t; @@ -737,17 +737,17 @@ typedef struct { typedef struct jpc_msops_s { - /* Destroy the marker segment parameters. */ - void (*destroyparms)(jpc_ms_t *ms); + /* Destroy the marker segment parameters. */ + void (*destroyparms)(jpc_ms_t *ms); - /* Get the marker segment parameters from a stream. */ - int (*getparms)(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in); + /* Get the marker segment parameters from a stream. */ + int (*getparms)(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in); - /* Put the marker segment parameters to a stream. */ - int (*putparms)(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out); + /* Put the marker segment parameters to a stream. */ + int (*putparms)(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out); - /* Dump the marker segment parameters (for debugging). */ - int (*dumpparms)(jpc_ms_t *ms, FILE *out); + /* Dump the marker segment parameters (for debugging). */ + int (*dumpparms)(jpc_ms_t *ms, FILE *out); } jpc_msops_t; @@ -768,13 +768,13 @@ jpc_ms_t *jpc_ms_create(int type); void jpc_ms_destroy(jpc_ms_t *ms); /* Does a marker segment have parameters? */ -#define JPC_MS_HASPARMS(x) \ - (!((x) == JPC_MS_SOC || (x) == JPC_MS_SOD || (x) == JPC_MS_EOC || \ - (x) == JPC_MS_EPH || ((x) >= 0xff30 && (x) <= 0xff3f))) +#define JPC_MS_HASPARMS(x) \ + (!((x) == JPC_MS_SOC || (x) == JPC_MS_SOD || (x) == JPC_MS_EOC || \ + (x) == JPC_MS_EPH || ((x) >= 0xff30 && (x) <= 0xff3f))) /* Get the marker segment type. */ -#define jpc_ms_gettype(ms) \ - ((ms)->id) +#define jpc_ms_gettype(ms) \ + ((ms)->id) /* Read a marker segment from a stream. */ jpc_ms_t *jpc_getms(jas_stream_t *in, jpc_cstate_t *cstate); diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_dec.c b/converter/other/jpeg2000/libjasper/jpc/jpc_dec.c index 140169ec..1cca46b7 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_dec.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_dec.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -793,7 +793,7 @@ rlvl->bands = 0; rlvl->numhprcs = 0; rlvl->numvprcs = 0; continue; - } + } if (!rlvlno) { tlcbgxstart = tlprcxstart; tlcbgystart = tlprcystart; diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_dec.h b/converter/other/jpeg2000/libjasper/jpc/jpc_dec.h index fe0e9616..11fceb36 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_dec.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_dec.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -141,14 +141,14 @@ typedef struct { - /* The index for this entry. */ - uint_fast16_t ind; + /* The index for this entry. */ + uint_fast16_t ind; - /* The data length. */ - uint_fast32_t len; + /* The data length. */ + uint_fast32_t len; - /* The data. */ - unsigned char *data; + /* The data. */ + unsigned char *data; } jpc_ppxstabent_t; @@ -156,15 +156,15 @@ typedef struct { typedef struct { - /* The number of entries. */ - int numents; + /* The number of entries. */ + int numents; - /* The maximum number of entries (i.e., the allocated size of the array - below). */ - int maxents; + /* The maximum number of entries (i.e., the allocated size of the array + below). */ + int maxents; - /* The table entries. */ - jpc_ppxstabent_t **ents; + /* The table entries. */ + jpc_ppxstabent_t **ents; } jpc_ppxstab_t; @@ -172,15 +172,15 @@ typedef struct { typedef struct { - /* The number of streams in this list. */ - int numstreams; + /* The number of streams in this list. */ + int numstreams; - /* The maximum number of streams that can be accommodated without - growing the streams array. */ - int maxstreams; + /* The maximum number of streams that can be accommodated without + growing the streams array. */ + int maxstreams; - /* The streams. */ - jas_stream_t **streams; + /* The streams. */ + jas_stream_t **streams; } jpc_streamlist_t; @@ -192,47 +192,47 @@ typedef struct { typedef struct { - /* How were various coding parameters set? */ - int flags; + /* How were various coding parameters set? */ + int flags; - /* Per-component coding style parameters (e.g., explicit precinct sizes) */ - uint_fast8_t csty; + /* Per-component coding style parameters (e.g., explicit precinct sizes) */ + uint_fast8_t csty; - /* The number of resolution levels. */ - uint_fast8_t numrlvls; + /* The number of resolution levels. */ + uint_fast8_t numrlvls; - /* The code block width exponent. */ - uint_fast8_t cblkwidthexpn; + /* The code block width exponent. */ + uint_fast8_t cblkwidthexpn; - /* The code block height exponent. */ - uint_fast8_t cblkheightexpn; + /* The code block height exponent. */ + uint_fast8_t cblkheightexpn; - /* The QMFB ID. */ - uint_fast8_t qmfbid; + /* The QMFB ID. */ + uint_fast8_t qmfbid; - /* The quantization style. */ - uint_fast8_t qsty; + /* The quantization style. */ + uint_fast8_t qsty; - /* The number of quantizer step sizes. */ - uint_fast16_t numstepsizes; + /* The number of quantizer step sizes. */ + uint_fast16_t numstepsizes; - /* The step sizes. */ - uint_fast16_t stepsizes[3 * JPC_MAXRLVLS + 1]; + /* The step sizes. */ + uint_fast16_t stepsizes[3 * JPC_MAXRLVLS + 1]; - /* The number of guard bits. */ - uint_fast8_t numguardbits; + /* The number of guard bits. */ + uint_fast8_t numguardbits; - /* The ROI shift value. */ - uint_fast8_t roishift; + /* The ROI shift value. */ + uint_fast8_t roishift; - /* The code block parameters. */ - uint_fast8_t cblkctx; + /* The code block parameters. */ + uint_fast8_t cblkctx; - /* The precinct width exponents. */ - uint_fast8_t prcwidthexpns[JPC_MAXRLVLS]; + /* The precinct width exponents. */ + uint_fast8_t prcwidthexpns[JPC_MAXRLVLS]; - /* The precinct height exponents. */ - uint_fast8_t prcheightexpns[JPC_MAXRLVLS]; + /* The precinct height exponents. */ + uint_fast8_t prcheightexpns[JPC_MAXRLVLS]; } jpc_dec_ccp_t; @@ -240,29 +240,29 @@ typedef struct { typedef struct { - /* How were these coding parameters set? */ - int flags; + /* How were these coding parameters set? */ + int flags; - /* Progression change list. */ - jpc_pchglist_t *pchglist; + /* Progression change list. */ + jpc_pchglist_t *pchglist; - /* Progression order. */ - uint_fast8_t prgord; + /* Progression order. */ + uint_fast8_t prgord; - /* The number of layers. */ - uint_fast16_t numlyrs; + /* The number of layers. */ + uint_fast16_t numlyrs; - /* The MCT ID. */ - uint_fast8_t mctid; + /* The MCT ID. */ + uint_fast8_t mctid; - /* The coding style parameters (e.g., SOP, EPH). */ - uint_fast8_t csty; + /* The coding style parameters (e.g., SOP, EPH). */ + uint_fast8_t csty; - /* The number of components. */ - uint_fast16_t numcomps; + /* The number of components. */ + uint_fast16_t numcomps; - /* The per-component coding parameters. */ - jpc_dec_ccp_t *ccps; + /* The per-component coding parameters. */ + jpc_dec_ccp_t *ccps; } jpc_dec_cp_t; @@ -274,38 +274,38 @@ typedef struct { typedef struct jpc_dec_seg_s { - /* The next segment in the list. */ - struct jpc_dec_seg_s *next; + /* The next segment in the list. */ + struct jpc_dec_seg_s *next; - /* The previous segment in the list. */ - struct jpc_dec_seg_s *prev; + /* The previous segment in the list. */ + struct jpc_dec_seg_s *prev; - /* The starting pass number for this segment. */ - int passno; + /* The starting pass number for this segment. */ + int passno; - /* The number of passes in this segment. */ - int numpasses; + /* The number of passes in this segment. */ + int numpasses; - /* The maximum number of passes in this segment. */ - int maxpasses; + /* The maximum number of passes in this segment. */ + int maxpasses; - /* The type of data in this segment (i.e., MQ or raw). */ - int type; + /* The type of data in this segment (i.e., MQ or raw). */ + int type; - /* A stream containing the data for this segment. */ - jas_stream_t *stream; + /* A stream containing the data for this segment. */ + jas_stream_t *stream; - /* The number of bytes destined for this segment from the packet - currently being decoded. */ - int cnt; + /* The number of bytes destined for this segment from the packet + currently being decoded. */ + int cnt; - /* A flag indicating if this segment has been terminated. */ - int complete; + /* A flag indicating if this segment has been terminated. */ + int complete; - /* The layer number to which this segment belongs. */ - /* If the segment spans multiple layers, then the largest layer number - spanned by the segment is used. */ - int lyrno; + /* The layer number to which this segment belongs. */ + /* If the segment spans multiple layers, then the largest layer number + spanned by the segment is used. */ + int lyrno; } jpc_dec_seg_t; @@ -313,11 +313,11 @@ typedef struct jpc_dec_seg_s { typedef struct { - /* The first entry in the list. */ - jpc_dec_seg_t *head; + /* The first entry in the list. */ + jpc_dec_seg_t *head; - /* The last entry in the list. */ - jpc_dec_seg_t *tail; + /* The last entry in the list. */ + jpc_dec_seg_t *tail; } jpc_dec_seglist_t; @@ -325,35 +325,35 @@ typedef struct { typedef struct { - /* The number of passes. */ - int numpasses; + /* The number of passes. */ + int numpasses; - /* A list of segments that still need to be decoded. */ - jpc_dec_seglist_t segs; + /* A list of segments that still need to be decoded. */ + jpc_dec_seglist_t segs; - /* The first incomplete/partial segment. */ - jpc_dec_seg_t *curseg; + /* The first incomplete/partial segment. */ + jpc_dec_seg_t *curseg; - /* The number of leading insignificant bit planes for this code block. */ - int numimsbs; + /* The number of leading insignificant bit planes for this code block. */ + int numimsbs; - /* The number of bits used to encode pass data lengths. */ - int numlenbits; + /* The number of bits used to encode pass data lengths. */ + int numlenbits; - /* The first pass number containing data for this code block. */ - int firstpassno; + /* The first pass number containing data for this code block. */ + int firstpassno; - /* The MQ decoder. */ - jpc_mqdec_t *mqdec; + /* The MQ decoder. */ + jpc_mqdec_t *mqdec; - /* The raw bit stream decoder. */ - jpc_bitstream_t *nulldec; + /* The raw bit stream decoder. */ + jpc_bitstream_t *nulldec; - /* The per-sample state information for this code block. */ - jas_matrix_t *flags; + /* The per-sample state information for this code block. */ + jas_matrix_t *flags; - /* The sample data associated with this code block. */ - jas_matrix_t *data; + /* The sample data associated with this code block. */ + jas_matrix_t *data; } jpc_dec_cblk_t; @@ -361,39 +361,39 @@ typedef struct { typedef struct { - /* The x-coordinate of the top-left corner of the precinct. */ - uint_fast32_t xstart; + /* The x-coordinate of the top-left corner of the precinct. */ + uint_fast32_t xstart; - /* The y-coordinate of the top-left corner of the precinct. */ - uint_fast32_t ystart; + /* The y-coordinate of the top-left corner of the precinct. */ + uint_fast32_t ystart; - /* The x-coordinate of the bottom-right corner of the precinct - (plus one). */ - uint_fast32_t xend; + /* The x-coordinate of the bottom-right corner of the precinct + (plus one). */ + uint_fast32_t xend; - /* The y-coordinate of the bottom-right corner of the precinct - (plus one). */ - uint_fast32_t yend; + /* The y-coordinate of the bottom-right corner of the precinct + (plus one). */ + uint_fast32_t yend; - /* The number of code blocks spanning this precinct in the horizontal - direction. */ - int numhcblks; + /* The number of code blocks spanning this precinct in the horizontal + direction. */ + int numhcblks; - /* The number of code blocks spanning this precinct in the vertical - direction. */ - int numvcblks; + /* The number of code blocks spanning this precinct in the vertical + direction. */ + int numvcblks; - /* The total number of code blocks in this precinct. */ - int numcblks; + /* The total number of code blocks in this precinct. */ + int numcblks; - /* The per code block information. */ - jpc_dec_cblk_t *cblks; + /* The per code block information. */ + jpc_dec_cblk_t *cblks; - /* The inclusion tag tree. */ - jpc_tagtree_t *incltagtree; + /* The inclusion tag tree. */ + jpc_tagtree_t *incltagtree; - /* The insignificant MSBs tag tree. */ - jpc_tagtree_t *numimsbstagtree; + /* The insignificant MSBs tag tree. */ + jpc_tagtree_t *numimsbstagtree; } jpc_dec_prc_t; @@ -401,29 +401,29 @@ typedef struct { typedef struct { - /* The per-code-block-group state information. */ - jpc_dec_prc_t *prcs; + /* The per-code-block-group state information. */ + jpc_dec_prc_t *prcs; - /* The sample data associated with this band. */ - jas_matrix_t *data; + /* The sample data associated with this band. */ + jas_matrix_t *data; - /* The orientation of this band (i.e., LL, LH, HL, or HH). */ - int orient; + /* The orientation of this band (i.e., LL, LH, HL, or HH). */ + int orient; - /* The encoded quantizer step size. */ - int stepsize; + /* The encoded quantizer step size. */ + int stepsize; - /* The absolute quantizer step size. */ - jpc_fix_t absstepsize; + /* The absolute quantizer step size. */ + jpc_fix_t absstepsize; - /* The number of bit planes for this band. */ - int numbps; + /* The number of bit planes for this band. */ + int numbps; - /* The analysis gain associated with this band. */ - int analgain; + /* The analysis gain associated with this band. */ + int analgain; - /* The ROI shift value for this band. */ - int roishift; + /* The ROI shift value for this band. */ + int roishift; } jpc_dec_band_t; @@ -431,60 +431,60 @@ typedef struct { typedef struct { - /* The number of bands associated with this resolution level. */ - int numbands; + /* The number of bands associated with this resolution level. */ + int numbands; - /* The per-band information. */ - jpc_dec_band_t *bands; + /* The per-band information. */ + jpc_dec_band_t *bands; - /* The x-coordinate of the top-left corner of the tile-component - at this resolution. */ - uint_fast32_t xstart; + /* The x-coordinate of the top-left corner of the tile-component + at this resolution. */ + uint_fast32_t xstart; - /* The y-coordinate of the top-left corner of the tile-component - at this resolution. */ - uint_fast32_t ystart; + /* The y-coordinate of the top-left corner of the tile-component + at this resolution. */ + uint_fast32_t ystart; - /* The x-coordinate of the bottom-right corner of the tile-component - at this resolution (plus one). */ - uint_fast32_t xend; + /* The x-coordinate of the bottom-right corner of the tile-component + at this resolution (plus one). */ + uint_fast32_t xend; - /* The y-coordinate of the bottom-right corner of the tile-component - at this resolution (plus one). */ - uint_fast32_t yend; + /* The y-coordinate of the bottom-right corner of the tile-component + at this resolution (plus one). */ + uint_fast32_t yend; - /* The exponent value for the nominal precinct width measured - relative to the associated LL band. */ - int prcwidthexpn; + /* The exponent value for the nominal precinct width measured + relative to the associated LL band. */ + int prcwidthexpn; - /* The exponent value for the nominal precinct height measured - relative to the associated LL band. */ - int prcheightexpn; + /* The exponent value for the nominal precinct height measured + relative to the associated LL band. */ + int prcheightexpn; - /* The number of precincts in the horizontal direction. */ - int numhprcs; + /* The number of precincts in the horizontal direction. */ + int numhprcs; - /* The number of precincts in the vertical direction. */ - int numvprcs; + /* The number of precincts in the vertical direction. */ + int numvprcs; - /* The total number of precincts. */ - int numprcs; + /* The total number of precincts. */ + int numprcs; - /* The exponent value for the nominal code block group width. - This quantity is associated with the next lower resolution level - (assuming that there is one). */ - int cbgwidthexpn; + /* The exponent value for the nominal code block group width. + This quantity is associated with the next lower resolution level + (assuming that there is one). */ + int cbgwidthexpn; - /* The exponent value for the nominal code block group height - This quantity is associated with the next lower resolution level - (assuming that there is one). */ - int cbgheightexpn; + /* The exponent value for the nominal code block group height + This quantity is associated with the next lower resolution level + (assuming that there is one). */ + int cbgheightexpn; - /* The exponent value for the code block width. */ - uint_fast16_t cblkwidthexpn; + /* The exponent value for the code block width. */ + uint_fast16_t cblkwidthexpn; - /* The exponent value for the code block height. */ - uint_fast16_t cblkheightexpn; + /* The exponent value for the code block height. */ + uint_fast16_t cblkheightexpn; } jpc_dec_rlvl_t; @@ -492,33 +492,33 @@ typedef struct { typedef struct { - /* The x-coordinate of the top-left corner of the tile-component - in the coordinate system of the tile-component. */ - uint_fast32_t xstart; + /* The x-coordinate of the top-left corner of the tile-component + in the coordinate system of the tile-component. */ + uint_fast32_t xstart; - /* The y-coordinate of the top-left corner of the tile-component - in the coordinate system of the tile-component. */ - uint_fast32_t ystart; + /* The y-coordinate of the top-left corner of the tile-component + in the coordinate system of the tile-component. */ + uint_fast32_t ystart; - /* The x-coordinate of the bottom-right corner of the tile-component - in the coordinate system of the tile-component (plus one). */ - uint_fast32_t xend; + /* The x-coordinate of the bottom-right corner of the tile-component + in the coordinate system of the tile-component (plus one). */ + uint_fast32_t xend; - /* The y-coordinate of the bottom-right corner of the tile-component - in the coordinate system of the tile-component (plus one). */ - uint_fast32_t yend; + /* The y-coordinate of the bottom-right corner of the tile-component + in the coordinate system of the tile-component (plus one). */ + uint_fast32_t yend; - /* The component data for the current tile. */ - jas_matrix_t *data; + /* The component data for the current tile. */ + jas_matrix_t *data; - /* The number of resolution levels. */ - uint_fast16_t numrlvls; + /* The number of resolution levels. */ + uint_fast16_t numrlvls; - /* The per resolution level information. */ - jpc_dec_rlvl_t *rlvls; + /* The per resolution level information. */ + jpc_dec_rlvl_t *rlvls; - /* The TSFB. */ - jpc_tsfb_t *tsfb; + /* The TSFB. */ + jpc_tsfb_t *tsfb; } jpc_dec_tcomp_t; @@ -526,60 +526,60 @@ typedef struct { * Tile states. */ -#define JPC_TILE_INIT 0 -#define JPC_TILE_ACTIVE 1 -#define JPC_TILE_ACTIVELAST 2 -#define JPC_TILE_DONE 3 +#define JPC_TILE_INIT 0 +#define JPC_TILE_ACTIVE 1 +#define JPC_TILE_ACTIVELAST 2 +#define JPC_TILE_DONE 3 /* Decoder per-tile state information. */ typedef struct { - /* The processing state for this tile. */ - int state; + /* The processing state for this tile. */ + int state; - /* The x-coordinate of the top-left corner of the tile on the reference - grid. */ - uint_fast32_t xstart; + /* The x-coordinate of the top-left corner of the tile on the reference + grid. */ + uint_fast32_t xstart; - /* The y-coordinate of the top-left corner of the tile on the reference - grid. */ - uint_fast32_t ystart; + /* The y-coordinate of the top-left corner of the tile on the reference + grid. */ + uint_fast32_t ystart; - /* The x-coordinate of the bottom-right corner of the tile on the - reference grid (plus one). */ - uint_fast32_t xend; + /* The x-coordinate of the bottom-right corner of the tile on the + reference grid (plus one). */ + uint_fast32_t xend; - /* The y-coordinate of the bottom-right corner of the tile on the - reference grid (plus one). */ - uint_fast32_t yend; + /* The y-coordinate of the bottom-right corner of the tile on the + reference grid (plus one). */ + uint_fast32_t yend; - /* The packed packet header data for this tile. */ - jpc_ppxstab_t *pptstab; + /* The packed packet header data for this tile. */ + jpc_ppxstab_t *pptstab; - /* A stream containing the packed packet header data for this tile. */ - jas_stream_t *pkthdrstream; + /* A stream containing the packed packet header data for this tile. */ + jas_stream_t *pkthdrstream; - /* The current position within the packed packet header stream. */ - long pkthdrstreampos; + /* The current position within the packed packet header stream. */ + long pkthdrstreampos; - /* The coding parameters for this tile. */ - jpc_dec_cp_t *cp; + /* The coding parameters for this tile. */ + jpc_dec_cp_t *cp; - /* The per tile-component information. */ - jpc_dec_tcomp_t *tcomps; + /* The per tile-component information. */ + jpc_dec_tcomp_t *tcomps; - /* The next expected tile-part number. */ - int partno; + /* The next expected tile-part number. */ + int partno; - /* The number of tile-parts. */ - int numparts; + /* The number of tile-parts. */ + int numparts; - /* The coding mode. */ - int realmode; + /* The coding mode. */ + int realmode; - /* The packet iterator for this tile. */ - jpc_pi_t *pi; + /* The packet iterator for this tile. */ + jpc_pi_t *pi; } jpc_dec_tile_t; @@ -587,29 +587,29 @@ typedef struct { typedef struct { - /* The horizontal sampling period. */ - uint_fast32_t hstep; + /* The horizontal sampling period. */ + uint_fast32_t hstep; - /* The vertical sampling period. */ - uint_fast32_t vstep; + /* The vertical sampling period. */ + uint_fast32_t vstep; - /* The number of samples in the horizontal direction. */ - uint_fast32_t width; + /* The number of samples in the horizontal direction. */ + uint_fast32_t width; - /* The number of samples in the vertical direction. */ - uint_fast32_t height; + /* The number of samples in the vertical direction. */ + uint_fast32_t height; - /* The precision of the sample data. */ - uint_fast16_t prec; + /* The precision of the sample data. */ + uint_fast16_t prec; - /* The signedness of the sample data. */ - bool sgnd; + /* The signedness of the sample data. */ + bool sgnd; - /* The sample alignment horizontal offset. */ - uint_fast32_t hsubstep; - - /* The sample alignment vertical offset. */ - uint_fast32_t vsubstep; + /* The sample alignment horizontal offset. */ + uint_fast32_t hsubstep; + + /* The sample alignment vertical offset. */ + uint_fast32_t vsubstep; } jpc_dec_cmpt_t; @@ -617,96 +617,96 @@ typedef struct { typedef struct { - /* The decoded image. */ - jas_image_t *image; + /* The decoded image. */ + jas_image_t *image; - /* The x-coordinate of the top-left corner of the image area on - the reference grid. */ - uint_fast32_t xstart; + /* The x-coordinate of the top-left corner of the image area on + the reference grid. */ + uint_fast32_t xstart; - /* The y-coordinate of the top-left corner of the image area on - the reference grid. */ - uint_fast32_t ystart; + /* The y-coordinate of the top-left corner of the image area on + the reference grid. */ + uint_fast32_t ystart; - /* The x-coordinate of the bottom-right corner of the image area on - the reference grid (plus one). */ - uint_fast32_t xend; + /* The x-coordinate of the bottom-right corner of the image area on + the reference grid (plus one). */ + uint_fast32_t xend; - /* The y-coordinate of the bottom-right corner of the image area on - the reference grid (plus one). */ - uint_fast32_t yend; + /* The y-coordinate of the bottom-right corner of the image area on + the reference grid (plus one). */ + uint_fast32_t yend; - /* The nominal tile width in units of the image reference grid. */ - uint_fast32_t tilewidth; + /* The nominal tile width in units of the image reference grid. */ + uint_fast32_t tilewidth; - /* The nominal tile height in units of the image reference grid. */ - uint_fast32_t tileheight; + /* The nominal tile height in units of the image reference grid. */ + uint_fast32_t tileheight; - /* The horizontal offset from the origin of the reference grid to the - left side of the first tile. */ - uint_fast32_t tilexoff; + /* The horizontal offset from the origin of the reference grid to the + left side of the first tile. */ + uint_fast32_t tilexoff; - /* The vertical offset from the origin of the reference grid to the - top side of the first tile. */ - uint_fast32_t tileyoff; + /* The vertical offset from the origin of the reference grid to the + top side of the first tile. */ + uint_fast32_t tileyoff; - /* The number of tiles spanning the image area in the vertical - direction. */ - int numhtiles; + /* The number of tiles spanning the image area in the vertical + direction. */ + int numhtiles; - /* The number of tiles spanning the image area in the horizontal - direction. */ - int numvtiles; + /* The number of tiles spanning the image area in the horizontal + direction. */ + int numvtiles; - /* The total number of tiles. */ - int numtiles; + /* The total number of tiles. */ + int numtiles; - /* The per-tile information. */ - jpc_dec_tile_t *tiles; + /* The per-tile information. */ + jpc_dec_tile_t *tiles; - /* The tile currently being processed. */ - jpc_dec_tile_t *curtile; + /* The tile currently being processed. */ + jpc_dec_tile_t *curtile; - /* The number of components. */ - int numcomps; + /* The number of components. */ + int numcomps; - /* The stream containing the input JPEG-2000 code stream data. */ - jas_stream_t *in; + /* The stream containing the input JPEG-2000 code stream data. */ + jas_stream_t *in; - /* The default coding parameters for all tiles. */ - jpc_dec_cp_t *cp; + /* The default coding parameters for all tiles. */ + jpc_dec_cp_t *cp; - /* The maximum number of layers that may be decoded. */ - int maxlyrs; + /* The maximum number of layers that may be decoded. */ + int maxlyrs; - /* The maximum number of packets that may be decoded. */ - int maxpkts; + /* The maximum number of packets that may be decoded. */ + int maxpkts; - /* The number of packets decoded so far in the processing of the entire - code stream. */ - int numpkts; + /* The number of packets decoded so far in the processing of the entire + code stream. */ + int numpkts; - /* The next expected PPM marker segment sequence number. */ - int ppmseqno; + /* The next expected PPM marker segment sequence number. */ + int ppmseqno; - /* The current state for code stream processing. */ - int state; + /* The current state for code stream processing. */ + int state; - /* The per-component information. */ - jpc_dec_cmpt_t *cmpts; + /* The per-component information. */ + jpc_dec_cmpt_t *cmpts; - /* The information from PPM marker segments. */ - jpc_ppxstab_t *ppmstab; + /* The information from PPM marker segments. */ + jpc_ppxstab_t *ppmstab; - /* A list of streams containing packet header data from PPM marker - segments. */ - jpc_streamlist_t *pkthdrstreams; + /* A list of streams containing packet header data from PPM marker + segments. */ + jpc_streamlist_t *pkthdrstreams; - /* The expected ending offset for a tile-part. */ - long curtileendoff; + /* The expected ending offset for a tile-part. */ + long curtileendoff; - /* This is required by the tier-2 decoder. */ - jpc_cstate_t *cstate; + /* This is required by the tier-2 decoder. */ + jpc_cstate_t *cstate; } jpc_dec_t; @@ -714,14 +714,14 @@ typedef struct { typedef struct { - /* The debug level for the decoder. */ - int debug; + /* The debug level for the decoder. */ + int debug; - /* The maximum number of layers to decode. */ - int maxlyrs; + /* The maximum number of layers to decode. */ + int maxlyrs; - /* The maximum number of packets to decode. */ - int maxpkts; + /* The maximum number of packets to decode. */ + int maxpkts; } jpc_dec_importopts_t; diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_enc.c b/converter/other/jpeg2000/libjasper/jpc/jpc_enc.c index 0c77a94e..c964eeff 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_enc.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_enc.c @@ -2835,14 +2835,14 @@ jpc_enc_dump(jpc_enc_t *enc) { */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -2850,22 +2850,22 @@ jpc_enc_dump(jpc_enc_t *enc) { * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -2885,17 +2885,17 @@ jpc_enc_dump(jpc_enc_t *enc) { * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -2935,7 +2935,7 @@ jpc_enc_dump(jpc_enc_t *enc) { * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_enc.h b/converter/other/jpeg2000/libjasper/jpc/jpc_enc.h index 86a8e59c..1e3887aa 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_enc.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_enc.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -136,10 +136,10 @@ \******************************************************************************/ /* The number of bits used in various lookup tables. */ -#define JPC_NUMEXTRABITS JPC_NMSEDEC_FRACBITS +#define JPC_NUMEXTRABITS JPC_NMSEDEC_FRACBITS /* An invalid R-D slope value. */ -#define JPC_BADRDSLOPE (-1) +#define JPC_BADRDSLOPE (-1) /******************************************************************************\ * Coding parameters types. @@ -149,29 +149,29 @@ typedef struct { - /* The horizontal sampling period. */ - uint_fast8_t sampgrdstepx; + /* The horizontal sampling period. */ + uint_fast8_t sampgrdstepx; - /* The vertical sampling period. */ - uint_fast8_t sampgrdstepy; + /* The vertical sampling period. */ + uint_fast8_t sampgrdstepy; - /* The sample alignment horizontal offset. */ - uint_fast8_t sampgrdsubstepx; + /* The sample alignment horizontal offset. */ + uint_fast8_t sampgrdsubstepx; - /* The sample alignment vertical offset. */ - uint_fast8_t sampgrdsubstepy; + /* The sample alignment vertical offset. */ + uint_fast8_t sampgrdsubstepy; - /* The precision of the samples. */ - uint_fast8_t prec; + /* The precision of the samples. */ + uint_fast8_t prec; - /* The signedness of the samples. */ - bool sgnd; + /* The signedness of the samples. */ + bool sgnd; - /* The number of step sizes. */ - uint_fast16_t numstepsizes; + /* The number of step sizes. */ + uint_fast16_t numstepsizes; - /* The quantizer step sizes. */ - uint_fast16_t stepsizes[JPC_MAXBANDS]; + /* The quantizer step sizes. */ + uint_fast16_t stepsizes[JPC_MAXBANDS]; } jpc_enc_ccp_t; @@ -179,24 +179,24 @@ typedef struct { typedef struct { - /* The coding mode. */ - bool intmode; + /* The coding mode. */ + bool intmode; - /* The coding style (i.e., SOP, EPH). */ - uint_fast8_t csty; + /* The coding style (i.e., SOP, EPH). */ + uint_fast8_t csty; - /* The progression order. */ - uint_fast8_t prg; + /* The progression order. */ + uint_fast8_t prg; - /* The multicomponent transform. */ - uint_fast8_t mctid; + /* The multicomponent transform. */ + uint_fast8_t mctid; - /* The number of layers. */ - uint_fast16_t numlyrs; + /* The number of layers. */ + uint_fast16_t numlyrs; - /* The normalized bit rates associated with the various - intermediate layers. */ - jpc_fix_t *ilyrrates; + /* The normalized bit rates associated with the various + intermediate layers. */ + jpc_fix_t *ilyrrates; } jpc_enc_tcp_t; @@ -204,33 +204,33 @@ typedef struct { typedef struct { - /* The coding style (i.e., explicit precinct sizes). */ - uint_fast8_t csty; + /* The coding style (i.e., explicit precinct sizes). */ + uint_fast8_t csty; - /* The maximum number of resolution levels allowed. */ - uint_fast8_t maxrlvls; + /* The maximum number of resolution levels allowed. */ + uint_fast8_t maxrlvls; - /* The exponent for the nominal code block width. */ - uint_fast16_t cblkwidthexpn; + /* The exponent for the nominal code block width. */ + uint_fast16_t cblkwidthexpn; - /* The exponent for the nominal code block height. */ - uint_fast16_t cblkheightexpn; + /* The exponent for the nominal code block height. */ + uint_fast16_t cblkheightexpn; - /* The code block style parameters (e.g., lazy, terminate all, - segmentation symbols, causal, reset probability models). */ - uint_fast8_t cblksty; + /* The code block style parameters (e.g., lazy, terminate all, + segmentation symbols, causal, reset probability models). */ + uint_fast8_t cblksty; - /* The QMFB. */ - uint_fast8_t qmfbid; + /* The QMFB. */ + uint_fast8_t qmfbid; - /* The precinct width values. */ - uint_fast16_t prcwidthexpns[JPC_MAXRLVLS]; + /* The precinct width values. */ + uint_fast16_t prcwidthexpns[JPC_MAXRLVLS]; - /* The precinct height values. */ - uint_fast16_t prcheightexpns[JPC_MAXRLVLS]; + /* The precinct height values. */ + uint_fast16_t prcheightexpns[JPC_MAXRLVLS]; - /* The number of guard bits. */ - uint_fast8_t numgbits; + /* The number of guard bits. */ + uint_fast8_t numgbits; } jpc_enc_tccp_t; @@ -238,67 +238,67 @@ typedef struct { typedef struct { - /* The debug level. */ - int debug; + /* The debug level. */ + int debug; - /* The horizontal offset from the origin of the reference grid to the - left edge of the image area. */ - uint_fast32_t imgareatlx; + /* The horizontal offset from the origin of the reference grid to the + left edge of the image area. */ + uint_fast32_t imgareatlx; - /* The vertical offset from the origin of the reference grid to the - top edge of the image area. */ - uint_fast32_t imgareatly; + /* The vertical offset from the origin of the reference grid to the + top edge of the image area. */ + uint_fast32_t imgareatly; - /* The horizontal offset from the origin of the reference grid to the - right edge of the image area (plus one). */ - uint_fast32_t refgrdwidth; + /* The horizontal offset from the origin of the reference grid to the + right edge of the image area (plus one). */ + uint_fast32_t refgrdwidth; - /* The vertical offset from the origin of the reference grid to the - bottom edge of the image area (plus one). */ - uint_fast32_t refgrdheight; + /* The vertical offset from the origin of the reference grid to the + bottom edge of the image area (plus one). */ + uint_fast32_t refgrdheight; - /* The horizontal offset from the origin of the tile grid to the - origin of the reference grid. */ - uint_fast32_t tilegrdoffx; + /* The horizontal offset from the origin of the tile grid to the + origin of the reference grid. */ + uint_fast32_t tilegrdoffx; - /* The vertical offset from the origin of the tile grid to the - origin of the reference grid. */ - uint_fast32_t tilegrdoffy; + /* The vertical offset from the origin of the tile grid to the + origin of the reference grid. */ + uint_fast32_t tilegrdoffy; - /* The nominal tile width in units of the image reference grid. */ - uint_fast32_t tilewidth; + /* The nominal tile width in units of the image reference grid. */ + uint_fast32_t tilewidth; - /* The nominal tile height in units of the image reference grid. */ - uint_fast32_t tileheight; + /* The nominal tile height in units of the image reference grid. */ + uint_fast32_t tileheight; - /* The number of tiles spanning the image area in the horizontal - direction. */ - uint_fast32_t numhtiles; + /* The number of tiles spanning the image area in the horizontal + direction. */ + uint_fast32_t numhtiles; - /* The number of tiles spanning the image area in the vertical - direction. */ - uint_fast32_t numvtiles; + /* The number of tiles spanning the image area in the vertical + direction. */ + uint_fast32_t numvtiles; - /* The number of tiles. */ - uint_fast32_t numtiles; + /* The number of tiles. */ + uint_fast32_t numtiles; - /* The number of components. */ - uint_fast16_t numcmpts; + /* The number of components. */ + uint_fast16_t numcmpts; - /* The per-component coding parameters. */ - jpc_enc_ccp_t *ccps; + /* The per-component coding parameters. */ + jpc_enc_ccp_t *ccps; - /* The per-tile coding parameters. */ - jpc_enc_tcp_t tcp; + /* The per-tile coding parameters. */ + jpc_enc_tcp_t tcp; - /* The per-tile-component coding parameters. */ - jpc_enc_tccp_t tccp; + /* The per-tile-component coding parameters. */ + jpc_enc_tccp_t tccp; - /* The target code stream length in bytes. */ - uint_fast32_t totalsize; + /* The target code stream length in bytes. */ + uint_fast32_t totalsize; - /* The raw (i.e., uncompressed) size of the image in bytes. */ - uint_fast32_t rawsize; + /* The raw (i.e., uncompressed) size of the image in bytes. */ + uint_fast32_t rawsize; } jpc_enc_cp_t; @@ -310,35 +310,35 @@ typedef struct { typedef struct { - /* The starting offset for this pass. */ - int start; + /* The starting offset for this pass. */ + int start; - /* The ending offset for this pass. */ - int end; + /* The ending offset for this pass. */ + int end; - /* The type of data in this pass (i.e., MQ or raw). */ - int type; + /* The type of data in this pass (i.e., MQ or raw). */ + int type; - /* Flag indicating that this pass is terminated. */ - int term; + /* Flag indicating that this pass is terminated. */ + int term; - /* The entropy coder state after coding this pass. */ - jpc_mqencstate_t mqencstate; + /* The entropy coder state after coding this pass. */ + jpc_mqencstate_t mqencstate; - /* The layer to which this pass has been assigned. */ - int lyrno; + /* The layer to which this pass has been assigned. */ + int lyrno; - /* The R-D slope for this pass. */ - jpc_flt_t rdslope; + /* The R-D slope for this pass. */ + jpc_flt_t rdslope; - /* The weighted MSE reduction associated with this pass. */ - jpc_flt_t wmsedec; + /* The weighted MSE reduction associated with this pass. */ + jpc_flt_t wmsedec; - /* The cumulative weighted MSE reduction. */ - jpc_flt_t cumwmsedec; + /* The cumulative weighted MSE reduction. */ + jpc_flt_t cumwmsedec; - /* The normalized MSE reduction. */ - long nmsedec; + /* The normalized MSE reduction. */ + long nmsedec; } jpc_enc_pass_t; @@ -346,53 +346,53 @@ typedef struct { typedef struct { - /* The number of passes. */ - int numpasses; + /* The number of passes. */ + int numpasses; - /* The per-pass information. */ - jpc_enc_pass_t *passes; + /* The per-pass information. */ + jpc_enc_pass_t *passes; - /* The number of passes encoded so far. */ - int numencpasses; + /* The number of passes encoded so far. */ + int numencpasses; - /* The number of insignificant MSBs. */ - int numimsbs; + /* The number of insignificant MSBs. */ + int numimsbs; - /* The number of bits used to encode pass data lengths. */ - int numlenbits; + /* The number of bits used to encode pass data lengths. */ + int numlenbits; - /* The byte stream for this code block. */ - jas_stream_t *stream; + /* The byte stream for this code block. */ + jas_stream_t *stream; - /* The entropy encoder. */ - jpc_mqenc_t *mqenc; + /* The entropy encoder. */ + jpc_mqenc_t *mqenc; - /* The data for this code block. */ - jas_matrix_t *data; + /* The data for this code block. */ + jas_matrix_t *data; - /* The state for this code block. */ - jas_matrix_t *flags; + /* The state for this code block. */ + jas_matrix_t *flags; - /* The number of bit planes required for this code block. */ - int numbps; + /* The number of bit planes required for this code block. */ + int numbps; - /* The next pass to be encoded. */ - jpc_enc_pass_t *curpass; + /* The next pass to be encoded. */ + jpc_enc_pass_t *curpass; - /* The per-code-block-group state information. */ - struct jpc_enc_prc_s *prc; + /* The per-code-block-group state information. */ + struct jpc_enc_prc_s *prc; - /* The saved current pass. */ - /* This is used by the rate control code. */ - jpc_enc_pass_t *savedcurpass; + /* The saved current pass. */ + /* This is used by the rate control code. */ + jpc_enc_pass_t *savedcurpass; - /* The saved length indicator size. */ - /* This is used by the rate control code. */ - int savednumlenbits; + /* The saved length indicator size. */ + /* This is used by the rate control code. */ + int savednumlenbits; - /* The saved number of encoded passes. */ - /* This is used by the rate control code. */ - int savednumencpasses; + /* The saved number of encoded passes. */ + /* This is used by the rate control code. */ + int savednumencpasses; } jpc_enc_cblk_t; @@ -400,50 +400,50 @@ typedef struct { typedef struct jpc_enc_prc_s { - /* The x-coordinate of the top-left corner of the precinct. */ - uint_fast32_t tlx; + /* The x-coordinate of the top-left corner of the precinct. */ + uint_fast32_t tlx; - /* The y-coordinate of the top-left corner of the precinct. */ - uint_fast32_t tly; + /* The y-coordinate of the top-left corner of the precinct. */ + uint_fast32_t tly; - /* The x-coordinate of the bottom-right corner of the precinct - (plus one). */ - uint_fast32_t brx; + /* The x-coordinate of the bottom-right corner of the precinct + (plus one). */ + uint_fast32_t brx; - /* The y-coordinate of the bottom-right corner of the precinct - (plus one). */ - uint_fast32_t bry; + /* The y-coordinate of the bottom-right corner of the precinct + (plus one). */ + uint_fast32_t bry; - /* The number of code blocks spanning the precinct in the horizontal - direction. */ - int numhcblks; + /* The number of code blocks spanning the precinct in the horizontal + direction. */ + int numhcblks; - /* The number of code blocks spanning the precinct in the vertical - direction. */ - int numvcblks; + /* The number of code blocks spanning the precinct in the vertical + direction. */ + int numvcblks; - /* The total number of code blocks. */ - int numcblks; + /* The total number of code blocks. */ + int numcblks; - /* The per-code-block information. */ - jpc_enc_cblk_t *cblks; + /* The per-code-block information. */ + jpc_enc_cblk_t *cblks; - /* The inclusion tag tree. */ - jpc_tagtree_t *incltree; + /* The inclusion tag tree. */ + jpc_tagtree_t *incltree; - /* The insignifcant MSBs tag tree. */ - jpc_tagtree_t *nlibtree; + /* The insignifcant MSBs tag tree. */ + jpc_tagtree_t *nlibtree; - /* The per-band information. */ - struct jpc_enc_band_s *band; + /* The per-band information. */ + struct jpc_enc_band_s *band; - /* The saved inclusion tag tree. */ - /* This is used by rate control. */ - jpc_tagtree_t *savincltree; + /* The saved inclusion tag tree. */ + /* This is used by rate control. */ + jpc_tagtree_t *savincltree; - /* The saved leading-insignificant-bit-planes tag tree. */ - /* This is used by rate control. */ - jpc_tagtree_t *savnlibtree; + /* The saved leading-insignificant-bit-planes tag tree. */ + /* This is used by rate control. */ + jpc_tagtree_t *savnlibtree; } jpc_enc_prc_t; @@ -451,33 +451,33 @@ typedef struct jpc_enc_prc_s { typedef struct jpc_enc_band_s { - /* The per precinct information. */ - jpc_enc_prc_t *prcs; + /* The per precinct information. */ + jpc_enc_prc_t *prcs; - /* The coefficient data for this band. */ - jas_matrix_t *data; + /* The coefficient data for this band. */ + jas_matrix_t *data; - /* The orientation of this band (i.e., LL, LH, HL, or HH). */ - int orient; + /* The orientation of this band (i.e., LL, LH, HL, or HH). */ + int orient; - /* The number of bit planes associated with this band. */ - int numbps; + /* The number of bit planes associated with this band. */ + int numbps; - /* The quantizer step size. */ - jpc_fix_t absstepsize; + /* The quantizer step size. */ + jpc_fix_t absstepsize; - /* The encoded quantizer step size. */ - int stepsize; + /* The encoded quantizer step size. */ + int stepsize; - /* The L2 norm of the synthesis basis functions associated with - this band. (The MCT is not considered in this value.) */ - jpc_fix_t synweight; + /* The L2 norm of the synthesis basis functions associated with + this band. (The MCT is not considered in this value.) */ + jpc_fix_t synweight; - /* The analysis gain for this band. */ - int analgain; + /* The analysis gain for this band. */ + int analgain; - /* The per-resolution-level information. */ - struct jpc_enc_rlvl_s *rlvl; + /* The per-resolution-level information. */ + struct jpc_enc_rlvl_s *rlvl; } jpc_enc_band_t; @@ -485,65 +485,65 @@ typedef struct jpc_enc_band_s { typedef struct jpc_enc_rlvl_s { - /* The x-coordinate of the top-left corner of the tile-component - at this resolution. */ - uint_fast32_t tlx; + /* The x-coordinate of the top-left corner of the tile-component + at this resolution. */ + uint_fast32_t tlx; - /* The y-coordinate of the top-left corner of the tile-component - at this resolution. */ - uint_fast32_t tly; + /* The y-coordinate of the top-left corner of the tile-component + at this resolution. */ + uint_fast32_t tly; - /* The x-coordinate of the bottom-right corner of the tile-component - at this resolution (plus one). */ - uint_fast32_t brx; + /* The x-coordinate of the bottom-right corner of the tile-component + at this resolution (plus one). */ + uint_fast32_t brx; - /* The y-coordinate of the bottom-right corner of the tile-component - at this resolution (plus one). */ - uint_fast32_t bry; + /* The y-coordinate of the bottom-right corner of the tile-component + at this resolution (plus one). */ + uint_fast32_t bry; - /* The exponent value for the nominal precinct width measured - relative to the associated LL band. */ - int prcwidthexpn; + /* The exponent value for the nominal precinct width measured + relative to the associated LL band. */ + int prcwidthexpn; - /* The exponent value for the nominal precinct height measured - relative to the associated LL band. */ - int prcheightexpn; + /* The exponent value for the nominal precinct height measured + relative to the associated LL band. */ + int prcheightexpn; - /* The number of precincts spanning the resolution level in the - horizontal direction. */ - int numhprcs; + /* The number of precincts spanning the resolution level in the + horizontal direction. */ + int numhprcs; - /* The number of precincts spanning the resolution level in the - vertical direction. */ - int numvprcs; + /* The number of precincts spanning the resolution level in the + vertical direction. */ + int numvprcs; - /* The total number of precincts. */ - int numprcs; + /* The total number of precincts. */ + int numprcs; - /* The exponent value for the nominal code block group width. - This quantity is associated with the next lower resolution level - (assuming that there is one). */ - int cbgwidthexpn; + /* The exponent value for the nominal code block group width. + This quantity is associated with the next lower resolution level + (assuming that there is one). */ + int cbgwidthexpn; - /* The exponent value for the nominal code block group height. - This quantity is associated with the next lower resolution level - (assuming that there is one). */ - int cbgheightexpn; + /* The exponent value for the nominal code block group height. + This quantity is associated with the next lower resolution level + (assuming that there is one). */ + int cbgheightexpn; - /* The exponent value for the code block width. */ - uint_fast16_t cblkwidthexpn; + /* The exponent value for the code block width. */ + uint_fast16_t cblkwidthexpn; - /* The exponent value for the code block height. */ - uint_fast16_t cblkheightexpn; + /* The exponent value for the code block height. */ + uint_fast16_t cblkheightexpn; - /* The number of bands associated with this resolution level. */ - int numbands; + /* The number of bands associated with this resolution level. */ + int numbands; - /* The per-band information. */ - jpc_enc_band_t *bands; + /* The per-band information. */ + jpc_enc_band_t *bands; - /* The parent tile-component. */ - struct jpc_enc_tcmpt_s *tcmpt; + /* The parent tile-component. */ + struct jpc_enc_tcmpt_s *tcmpt; } jpc_enc_rlvl_t; @@ -551,53 +551,53 @@ typedef struct jpc_enc_rlvl_s { typedef struct jpc_enc_tcmpt_s { - /* The number of resolution levels. */ - uint_fast16_t numrlvls; + /* The number of resolution levels. */ + uint_fast16_t numrlvls; - /* The per-resolution-level information. */ - jpc_enc_rlvl_t *rlvls; + /* The per-resolution-level information. */ + jpc_enc_rlvl_t *rlvls; - /* The tile-component data. */ - jas_matrix_t *data; + /* The tile-component data. */ + jas_matrix_t *data; - /* The QMFB. */ - int qmfbid; + /* The QMFB. */ + int qmfbid; - /* The number of bands. */ - int numbands; + /* The number of bands. */ + int numbands; - /* The TSFB. */ - jpc_tsfb_t *tsfb; + /* The TSFB. */ + jpc_tsfb_t *tsfb; - /* The synthesis energy weight (for the MCT). */ - jpc_fix_t synweight; + /* The synthesis energy weight (for the MCT). */ + jpc_fix_t synweight; - /* The precinct width exponents. */ - int prcwidthexpns[JPC_MAXRLVLS]; + /* The precinct width exponents. */ + int prcwidthexpns[JPC_MAXRLVLS]; - /* The precinct height exponents. */ - int prcheightexpns[JPC_MAXRLVLS]; + /* The precinct height exponents. */ + int prcheightexpns[JPC_MAXRLVLS]; - /* The code block width exponent. */ - int cblkwidthexpn; + /* The code block width exponent. */ + int cblkwidthexpn; - /* The code block height exponent. */ - int cblkheightexpn; + /* The code block height exponent. */ + int cblkheightexpn; - /* Coding style (i.e., explicit precinct sizes). */ - int csty; + /* Coding style (i.e., explicit precinct sizes). */ + int csty; - /* Code block style. */ - int cblksty; + /* Code block style. */ + int cblksty; - /* The number of quantizer step sizes. */ - uint_fast16_t numstepsizes; + /* The number of quantizer step sizes. */ + uint_fast16_t numstepsizes; - /* The encoded quantizer step sizes. */ - uint_fast16_t stepsizes[JPC_MAXBANDS]; + /* The encoded quantizer step sizes. */ + uint_fast16_t stepsizes[JPC_MAXBANDS]; - /* The parent tile. */ - struct jpc_enc_tile_s *tile; + /* The parent tile. */ + struct jpc_enc_tile_s *tile; } jpc_enc_tcmpt_t; @@ -605,55 +605,55 @@ typedef struct jpc_enc_tcmpt_s { typedef struct jpc_enc_tile_s { - /* The tile number. */ - uint_fast32_t tileno; + /* The tile number. */ + uint_fast32_t tileno; - /* The x-coordinate of the top-left corner of the tile measured with - respect to the reference grid. */ - uint_fast32_t tlx; + /* The x-coordinate of the top-left corner of the tile measured with + respect to the reference grid. */ + uint_fast32_t tlx; - /* The y-coordinate of the top-left corner of the tile measured with - respect to the reference grid. */ - uint_fast32_t tly; + /* The y-coordinate of the top-left corner of the tile measured with + respect to the reference grid. */ + uint_fast32_t tly; - /* The x-coordinate of the bottom-right corner of the tile measured - with respect to the reference grid (plus one). */ - uint_fast32_t brx; + /* The x-coordinate of the bottom-right corner of the tile measured + with respect to the reference grid (plus one). */ + uint_fast32_t brx; - /* The y-coordinate of the bottom-right corner of the tile measured - with respect to the reference grid (plus one). */ - uint_fast32_t bry; + /* The y-coordinate of the bottom-right corner of the tile measured + with respect to the reference grid (plus one). */ + uint_fast32_t bry; - /* The coding style. */ - uint_fast8_t csty; + /* The coding style. */ + uint_fast8_t csty; - /* The progression order. */ - uint_fast8_t prg; + /* The progression order. */ + uint_fast8_t prg; - /* The number of layers. */ - uint_fast16_t numlyrs; + /* The number of layers. */ + uint_fast16_t numlyrs; - /* The MCT to employ (if any). */ - uint_fast8_t mctid; + /* The MCT to employ (if any). */ + uint_fast8_t mctid; - /* The packet iterator (used to determine the order of packet - generation). */ - jpc_pi_t *pi; + /* The packet iterator (used to determine the order of packet + generation). */ + jpc_pi_t *pi; - /* The coding mode (i.e., integer or real). */ - bool intmode; + /* The coding mode (i.e., integer or real). */ + bool intmode; - /* The number of bytes to allocate to the various layers. */ - uint_fast32_t *lyrsizes; + /* The number of bytes to allocate to the various layers. */ + uint_fast32_t *lyrsizes; - /* The number of tile-components. */ - int numtcmpts; + /* The number of tile-components. */ + int numtcmpts; - /* The per tile-component information. */ - jpc_enc_tcmpt_t *tcmpts; + /* The per tile-component information. */ + jpc_enc_tcmpt_t *tcmpts; - /* The raw (i.e., uncompressed) size of this tile. */ - uint_fast32_t rawsize; + /* The raw (i.e., uncompressed) size of this tile. */ + uint_fast32_t rawsize; } jpc_enc_tile_t; @@ -661,34 +661,34 @@ typedef struct jpc_enc_tile_s { typedef struct jpc_enc_s { - /* The image being encoded. */ - jas_image_t *image; + /* The image being encoded. */ + jas_image_t *image; - /* The output stream. */ - jas_stream_t *out; + /* The output stream. */ + jas_stream_t *out; - /* The coding parameters. */ - jpc_enc_cp_t *cp; + /* The coding parameters. */ + jpc_enc_cp_t *cp; - /* The tile currently being processed. */ - jpc_enc_tile_t *curtile; + /* The tile currently being processed. */ + jpc_enc_tile_t *curtile; - /* The code stream state. */ - jpc_cstate_t *cstate; + /* The code stream state. */ + jpc_cstate_t *cstate; - /* The number of bytes output so far. */ - uint_fast32_t len; + /* The number of bytes output so far. */ + uint_fast32_t len; - /* The number of bytes available for the main body of the code stream. */ - /* This is used for rate allocation purposes. */ - uint_fast32_t mainbodysize; + /* The number of bytes available for the main body of the code stream. */ + /* This is used for rate allocation purposes. */ + uint_fast32_t mainbodysize; - /* The marker segment currently being processed. */ - /* This member is a convenience for making cleanup easier. */ - jpc_ms_t *mrk; + /* The marker segment currently being processed. */ + /* This member is a convenience for making cleanup easier. */ + jpc_ms_t *mrk; - /* The stream used to temporarily hold tile-part data. */ - jas_stream_t *tmpstream; + /* The stream used to temporarily hold tile-part data. */ + jas_stream_t *tmpstream; } jpc_enc_t; diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_fix.h b/converter/other/jpeg2000/libjasper/jpc/jpc_fix.h index 5ff0c9f8..2083cdc6 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_fix.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_fix.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -141,7 +141,7 @@ typedef int_fast32_t jpc_fix_t; typedef int_fast64_t jpc_fix_big_t; /* The number of bits used for the fractional part of a fixed-point number. */ -#define JPC_FIX_FRACBITS 13 +#define JPC_FIX_FRACBITS 13 /******************************************************************************\ * Instantiations of the generic fixed-point number macros for the @@ -150,44 +150,44 @@ typedef int_fast64_t jpc_fix_big_t; * corresponding macros in the jasper/jas_fix.h header file. \******************************************************************************/ -#define JPC_FIX_ZERO JAS_FIX_ZERO(jpc_fix_t, JPC_FIX_FRACBITS) -#define JPC_FIX_ONE JAS_FIX_ONE(jpc_fix_t, JPC_FIX_FRACBITS) -#define JPC_FIX_HALF JAS_FIX_HALF(jpc_fix_t, JPC_FIX_FRACBITS) - -#define jpc_inttofix(x) JAS_INTTOFIX(jpc_fix_t, JPC_FIX_FRACBITS, x) -#define jpc_fixtoint(x) JAS_FIXTOINT(jpc_fix_t, JPC_FIX_FRACBITS, x) -#define jpc_fixtodbl(x) JAS_FIXTODBL(jpc_fix_t, JPC_FIX_FRACBITS, x) -#define jpc_dbltofix(x) JAS_DBLTOFIX(jpc_fix_t, JPC_FIX_FRACBITS, x) - -#define jpc_fix_add(x, y) JAS_FIX_ADD(jpc_fix_t, JPC_FIX_FRACBITS, x, y) -#define jpc_fix_sub(x, y) JAS_FIX_SUB(jpc_fix_t, JPC_FIX_FRACBITS, x, y) -#define jpc_fix_mul(x, y) \ - JAS_FIX_MUL(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y) -#define jpc_fix_mulbyint(x, y) \ - JAS_FIX_MULBYINT(jpc_fix_t, JPC_FIX_FRACBITS, x, y) -#define jpc_fix_div(x, y) \ - JAS_FIX_DIV(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y) -#define jpc_fix_neg(x) JAS_FIX_NEG(jpc_fix_t, JPC_FIX_FRACBITS, x) -#define jpc_fix_asl(x, n) JAS_FIX_ASL(jpc_fix_t, JPC_FIX_FRACBITS, x, n) -#define jpc_fix_asr(x, n) JAS_FIX_ASR(jpc_fix_t, JPC_FIX_FRACBITS, x, n) - -#define jpc_fix_pluseq(x, y) JAS_FIX_PLUSEQ(jpc_fix_t, JPC_FIX_FRACBITS, x, y) -#define jpc_fix_minuseq(x, y) JAS_FIX_MINUSEQ(jpc_fix_t, JPC_FIX_FRACBITS, x, y) -#define jpc_fix_muleq(x, y) \ - JAS_FIX_MULEQ(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y) - -#define jpc_fix_abs(x) JAS_FIX_ABS(jpc_fix_t, JPC_FIX_FRACBITS, x) -#define jpc_fix_isint(x) JAS_FIX_ISINT(jpc_fix_t, JPC_FIX_FRACBITS, x) -#define jpc_fix_sgn(x) JAS_FIX_SGN(jpc_fix_t, JPC_FIX_FRACBITS, x) -#define jpc_fix_round(x) JAS_FIX_ROUND(jpc_fix_t, JPC_FIX_FRACBITS, x) -#define jpc_fix_floor(x) JAS_FIX_FLOOR(jpc_fix_t, JPC_FIX_FRACBITS, x) -#define jpc_fix_trunc(x) JAS_FIX_TRUNC(jpc_fix_t, JPC_FIX_FRACBITS, x) +#define JPC_FIX_ZERO JAS_FIX_ZERO(jpc_fix_t, JPC_FIX_FRACBITS) +#define JPC_FIX_ONE JAS_FIX_ONE(jpc_fix_t, JPC_FIX_FRACBITS) +#define JPC_FIX_HALF JAS_FIX_HALF(jpc_fix_t, JPC_FIX_FRACBITS) + +#define jpc_inttofix(x) JAS_INTTOFIX(jpc_fix_t, JPC_FIX_FRACBITS, x) +#define jpc_fixtoint(x) JAS_FIXTOINT(jpc_fix_t, JPC_FIX_FRACBITS, x) +#define jpc_fixtodbl(x) JAS_FIXTODBL(jpc_fix_t, JPC_FIX_FRACBITS, x) +#define jpc_dbltofix(x) JAS_DBLTOFIX(jpc_fix_t, JPC_FIX_FRACBITS, x) + +#define jpc_fix_add(x, y) JAS_FIX_ADD(jpc_fix_t, JPC_FIX_FRACBITS, x, y) +#define jpc_fix_sub(x, y) JAS_FIX_SUB(jpc_fix_t, JPC_FIX_FRACBITS, x, y) +#define jpc_fix_mul(x, y) \ + JAS_FIX_MUL(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y) +#define jpc_fix_mulbyint(x, y) \ + JAS_FIX_MULBYINT(jpc_fix_t, JPC_FIX_FRACBITS, x, y) +#define jpc_fix_div(x, y) \ + JAS_FIX_DIV(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y) +#define jpc_fix_neg(x) JAS_FIX_NEG(jpc_fix_t, JPC_FIX_FRACBITS, x) +#define jpc_fix_asl(x, n) JAS_FIX_ASL(jpc_fix_t, JPC_FIX_FRACBITS, x, n) +#define jpc_fix_asr(x, n) JAS_FIX_ASR(jpc_fix_t, JPC_FIX_FRACBITS, x, n) + +#define jpc_fix_pluseq(x, y) JAS_FIX_PLUSEQ(jpc_fix_t, JPC_FIX_FRACBITS, x, y) +#define jpc_fix_minuseq(x, y) JAS_FIX_MINUSEQ(jpc_fix_t, JPC_FIX_FRACBITS, x, y) +#define jpc_fix_muleq(x, y) \ + JAS_FIX_MULEQ(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y) + +#define jpc_fix_abs(x) JAS_FIX_ABS(jpc_fix_t, JPC_FIX_FRACBITS, x) +#define jpc_fix_isint(x) JAS_FIX_ISINT(jpc_fix_t, JPC_FIX_FRACBITS, x) +#define jpc_fix_sgn(x) JAS_FIX_SGN(jpc_fix_t, JPC_FIX_FRACBITS, x) +#define jpc_fix_round(x) JAS_FIX_ROUND(jpc_fix_t, JPC_FIX_FRACBITS, x) +#define jpc_fix_floor(x) JAS_FIX_FLOOR(jpc_fix_t, JPC_FIX_FRACBITS, x) +#define jpc_fix_trunc(x) JAS_FIX_TRUNC(jpc_fix_t, JPC_FIX_FRACBITS, x) /******************************************************************************\ * Extra macros for convenience. \******************************************************************************/ /* Compute the sum of three fixed-point numbers. */ -#define jpc_fix_add3(x, y, z) jpc_fix_add(jpc_fix_add(x, y), z) +#define jpc_fix_add3(x, y, z) jpc_fix_add(jpc_fix_add(x, y), z) #endif diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_flt.h b/converter/other/jpeg2000/libjasper/jpc/jpc_flt.h index 088eb00c..dc1950e3 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_flt.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_flt.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_math.c b/converter/other/jpeg2000/libjasper/jpc/jpc_math.c index a884ed4d..420e0857 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_math.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_math.c @@ -14,18 +14,18 @@ int jpc_floorlog2(int_fast32_t const arg) { - int y; + int y; int x; - assert(arg > 0); + assert(arg > 0); - y = 0; + y = 0; x = arg; - while (x > 1) { - x >>= 1; - ++y; - } - return y; + while (x > 1) { + x >>= 1; + ++y; + } + return y; } @@ -34,12 +34,12 @@ jpc_floorlog2(int_fast32_t const arg) { jpc_floorlog2() and jpc_firstone() do the same thing. The only difference is how input 0 is handled. -n : 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 -ceil(log2(n)) : x 0 1 2 2 3 3 3 3 4 4 4 4 4 4 4 4 5 5 5 -floor(log2(n)) : x 0 1 1 2 2 2 2 3 3 3 3 3 3 3 3 4 4 4 4 -31-__builtin_clz(n): x 0 1 1 2 2 2 2 3 3 3 3 3 3 3 3 4 4 4 4 -jpc_floorlog2(n) : x 0 1 1 2 2 2 2 3 3 3 3 3 3 3 3 4 4 4 4 -jpc_firstone(n) :-1 0 1 1 2 2 2 2 3 3 3 3 3 3 3 3 4 4 4 4 +n : 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 +ceil(log2(n)) : x 0 1 2 2 3 3 3 3 4 4 4 4 4 4 4 4 5 5 5 +floor(log2(n)) : x 0 1 1 2 2 2 2 3 3 3 3 3 3 3 3 4 4 4 4 +31-__builtin_clz(n): x 0 1 1 2 2 2 2 3 3 3 3 3 3 3 3 4 4 4 4 +jpc_floorlog2(n) : x 0 1 1 2 2 2 2 3 3 3 3 3 3 3 3 4 4 4 4 +jpc_firstone(n) :-1 0 1 1 2 2 2 2 3 3 3 3 3 3 3 3 4 4 4 4 */ @@ -47,24 +47,24 @@ jpc_firstone(n) :-1 0 1 1 2 2 2 2 3 3 3 3 3 3 3 3 4 4 4 4 int jpc_firstone(int_fast32_t const arg) { -/*---------------------------------------------------------------------------- +/*---------------------------------------------------------------------------- Calculate the bit position of the first leading one in a nonnegative integer. LSB is bit position 0. Iff there are no ones, return -1. -----------------------------------------------------------------------------*/ - int n; + int n; int x; - assert(arg >= 0); + assert(arg >= 0); - n = -1; + n = -1; x = arg; - while (x > 0) { - x >>= 1; - ++n; - } - return n; + while (x > 0) { + x >>= 1; + ++n; + } + return n; } @@ -77,14 +77,14 @@ jpc_firstone(int_fast32_t const arg) { */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -92,22 +92,22 @@ jpc_firstone(int_fast32_t const arg) { * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -127,17 +127,17 @@ jpc_firstone(int_fast32_t const arg) { * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -177,6 +177,6 @@ jpc_firstone(int_fast32_t const arg) { * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_math.h b/converter/other/jpeg2000/libjasper/jpc/jpc_math.h index cd24c6a6..e08db334 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_math.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_math.h @@ -4,14 +4,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -19,22 +19,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -54,17 +54,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -104,12 +104,12 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ -#ifndef JPC_MATH_H -#define JPC_MATH_H +#ifndef JPC_MATH_H +#define JPC_MATH_H /******************************************************************************\ * Includes @@ -123,23 +123,23 @@ \******************************************************************************/ /* Compute the floor of the quotient of two integers. */ -#define JPC_FLOORDIV(x, y) (assert(x >= 0 && y > 0), (x) / (y)) +#define JPC_FLOORDIV(x, y) (assert(x >= 0 && y > 0), (x) / (y)) /* Compute the ceiling of the quotient of two integers. */ -#define JPC_CEILDIV(x, y) (assert(x >= 0 && y > 0), ((x) + (y) - 1) / (y)) +#define JPC_CEILDIV(x, y) (assert(x >= 0 && y > 0), ((x) + (y) - 1) / (y)) /* Compute the floor of (x / 2^y). */ -#define JPC_FLOORDIVPOW2(x, y) \ - (assert(x >= 0 && y > 0), (x) >> (y)) +#define JPC_FLOORDIVPOW2(x, y) \ + (assert(x >= 0 && y > 0), (x) >> (y)) /* Compute the ceiling of (x / 2^y). */ -#define JPC_CEILDIVPOW2(x, y) \ - (assert(x >= 0 && y >= 0), ((x) + (1 << (y)) - 1) >> (y)) +#define JPC_CEILDIVPOW2(x, y) \ + (assert(x >= 0 && y >= 0), ((x) + (1 << (y)) - 1) >> (y)) /* JPC_CEILDIVPOW2U is for unsigned arguments (JPC_CEILDIVPOW2 would generate compiler warnings because of its superfluous >= 0 check) */ -#define JPC_CEILDIVPOW2U(x, y) \ - (((x) + (1 << (y)) - 1) >> (y)) +#define JPC_CEILDIVPOW2U(x, y) \ + (((x) + (1 << (y)) - 1) >> (y)) /******************************************************************************\ * Functions. diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_mct.c b/converter/other/jpeg2000/libjasper/jpc/jpc_mct.c index 7c16c3e5..2d7ea47c 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_mct.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_mct.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -135,203 +135,203 @@ void jpc_rct(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2) { - int numrows; - int numcols; - int i; - int j; - jpc_fix_t *c0p; - jpc_fix_t *c1p; - jpc_fix_t *c2p; + int numrows; + int numcols; + int i; + int j; + jpc_fix_t *c0p; + jpc_fix_t *c1p; + jpc_fix_t *c2p; - numrows = jas_matrix_numrows(c0); - numcols = jas_matrix_numcols(c0); + numrows = jas_matrix_numrows(c0); + numcols = jas_matrix_numcols(c0); - /* All three matrices must have the same dimensions. */ - assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numcols(c1) == numcols - && jas_matrix_numrows(c2) == numrows && jas_matrix_numcols(c2) == numcols); + /* All three matrices must have the same dimensions. */ + assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numcols(c1) == numcols + && jas_matrix_numrows(c2) == numrows && jas_matrix_numcols(c2) == numcols); - for (i = 0; i < numrows; i++) { - c0p = jas_matrix_getref(c0, i, 0); - c1p = jas_matrix_getref(c1, i, 0); - c2p = jas_matrix_getref(c2, i, 0); - for (j = numcols; j > 0; --j) { - int r; - int g; - int b; - int y; - int u; - int v; - r = *c0p; - g = *c1p; - b = *c2p; - y = (r + (g << 1) + b) >> 2; - u = b - g; - v = r - g; - *c0p++ = y; - *c1p++ = u; - *c2p++ = v; - } - } + for (i = 0; i < numrows; i++) { + c0p = jas_matrix_getref(c0, i, 0); + c1p = jas_matrix_getref(c1, i, 0); + c2p = jas_matrix_getref(c2, i, 0); + for (j = numcols; j > 0; --j) { + int r; + int g; + int b; + int y; + int u; + int v; + r = *c0p; + g = *c1p; + b = *c2p; + y = (r + (g << 1) + b) >> 2; + u = b - g; + v = r - g; + *c0p++ = y; + *c1p++ = u; + *c2p++ = v; + } + } } /* Compute the inverse RCT. */ void jpc_irct(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2) { - int numrows; - int numcols; - int i; - int j; - jpc_fix_t *c0p; - jpc_fix_t *c1p; - jpc_fix_t *c2p; + int numrows; + int numcols; + int i; + int j; + jpc_fix_t *c0p; + jpc_fix_t *c1p; + jpc_fix_t *c2p; - numrows = jas_matrix_numrows(c0); - numcols = jas_matrix_numcols(c0); + numrows = jas_matrix_numrows(c0); + numcols = jas_matrix_numcols(c0); - /* All three matrices must have the same dimensions. */ - assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numcols(c1) == numcols - && jas_matrix_numrows(c2) == numrows && jas_matrix_numcols(c2) == numcols); + /* All three matrices must have the same dimensions. */ + assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numcols(c1) == numcols + && jas_matrix_numrows(c2) == numrows && jas_matrix_numcols(c2) == numcols); - for (i = 0; i < numrows; i++) { - c0p = jas_matrix_getref(c0, i, 0); - c1p = jas_matrix_getref(c1, i, 0); - c2p = jas_matrix_getref(c2, i, 0); - for (j = numcols; j > 0; --j) { - int r; - int g; - int b; - int y; - int u; - int v; - y = *c0p; - u = *c1p; - v = *c2p; - g = y - ((u + v) >> 2); - r = v + g; - b = u + g; - *c0p++ = r; - *c1p++ = g; - *c2p++ = b; - } - } + for (i = 0; i < numrows; i++) { + c0p = jas_matrix_getref(c0, i, 0); + c1p = jas_matrix_getref(c1, i, 0); + c2p = jas_matrix_getref(c2, i, 0); + for (j = numcols; j > 0; --j) { + int r; + int g; + int b; + int y; + int u; + int v; + y = *c0p; + u = *c1p; + v = *c2p; + g = y - ((u + v) >> 2); + r = v + g; + b = u + g; + *c0p++ = r; + *c1p++ = g; + *c2p++ = b; + } + } } void jpc_ict(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2) { - int numrows; - int numcols; - int i; - int j; - jpc_fix_t r; - jpc_fix_t g; - jpc_fix_t b; - jpc_fix_t y; - jpc_fix_t u; - jpc_fix_t v; - jpc_fix_t *c0p; - jpc_fix_t *c1p; - jpc_fix_t *c2p; + int numrows; + int numcols; + int i; + int j; + jpc_fix_t r; + jpc_fix_t g; + jpc_fix_t b; + jpc_fix_t y; + jpc_fix_t u; + jpc_fix_t v; + jpc_fix_t *c0p; + jpc_fix_t *c1p; + jpc_fix_t *c2p; - numrows = jas_matrix_numrows(c0); - assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numrows(c2) == numrows); - numcols = jas_matrix_numcols(c0); - assert(jas_matrix_numcols(c1) == numcols && jas_matrix_numcols(c2) == numcols); - for (i = 0; i < numrows; ++i) { - c0p = jas_matrix_getref(c0, i, 0); - c1p = jas_matrix_getref(c1, i, 0); - c2p = jas_matrix_getref(c2, i, 0); - for (j = numcols; j > 0; --j) { - r = *c0p; - g = *c1p; - b = *c2p; - y = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(0.299), r), jpc_fix_mul(jpc_dbltofix(0.587), g), - jpc_fix_mul(jpc_dbltofix(0.114), b)); - u = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(-0.16875), r), jpc_fix_mul(jpc_dbltofix(-0.33126), g), - jpc_fix_mul(jpc_dbltofix(0.5), b)); - v = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(0.5), r), jpc_fix_mul(jpc_dbltofix(-0.41869), g), - jpc_fix_mul(jpc_dbltofix(-0.08131), b)); - *c0p++ = y; - *c1p++ = u; - *c2p++ = v; - } - } + numrows = jas_matrix_numrows(c0); + assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numrows(c2) == numrows); + numcols = jas_matrix_numcols(c0); + assert(jas_matrix_numcols(c1) == numcols && jas_matrix_numcols(c2) == numcols); + for (i = 0; i < numrows; ++i) { + c0p = jas_matrix_getref(c0, i, 0); + c1p = jas_matrix_getref(c1, i, 0); + c2p = jas_matrix_getref(c2, i, 0); + for (j = numcols; j > 0; --j) { + r = *c0p; + g = *c1p; + b = *c2p; + y = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(0.299), r), jpc_fix_mul(jpc_dbltofix(0.587), g), + jpc_fix_mul(jpc_dbltofix(0.114), b)); + u = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(-0.16875), r), jpc_fix_mul(jpc_dbltofix(-0.33126), g), + jpc_fix_mul(jpc_dbltofix(0.5), b)); + v = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(0.5), r), jpc_fix_mul(jpc_dbltofix(-0.41869), g), + jpc_fix_mul(jpc_dbltofix(-0.08131), b)); + *c0p++ = y; + *c1p++ = u; + *c2p++ = v; + } + } } void jpc_iict(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2) { - int numrows; - int numcols; - int i; - int j; - jpc_fix_t r; - jpc_fix_t g; - jpc_fix_t b; - jpc_fix_t y; - jpc_fix_t u; - jpc_fix_t v; - jpc_fix_t *c0p; - jpc_fix_t *c1p; - jpc_fix_t *c2p; + int numrows; + int numcols; + int i; + int j; + jpc_fix_t r; + jpc_fix_t g; + jpc_fix_t b; + jpc_fix_t y; + jpc_fix_t u; + jpc_fix_t v; + jpc_fix_t *c0p; + jpc_fix_t *c1p; + jpc_fix_t *c2p; - numrows = jas_matrix_numrows(c0); - assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numrows(c2) == numrows); - numcols = jas_matrix_numcols(c0); - assert(jas_matrix_numcols(c1) == numcols && jas_matrix_numcols(c2) == numcols); - for (i = 0; i < numrows; ++i) { - c0p = jas_matrix_getref(c0, i, 0); - c1p = jas_matrix_getref(c1, i, 0); - c2p = jas_matrix_getref(c2, i, 0); - for (j = numcols; j > 0; --j) { - y = *c0p; - u = *c1p; - v = *c2p; - r = jpc_fix_add(y, jpc_fix_mul(jpc_dbltofix(1.402), v)); - g = jpc_fix_add3(y, jpc_fix_mul(jpc_dbltofix(-0.34413), u), - jpc_fix_mul(jpc_dbltofix(-0.71414), v)); - b = jpc_fix_add(y, jpc_fix_mul(jpc_dbltofix(1.772), u)); - *c0p++ = r; - *c1p++ = g; - *c2p++ = b; - } - } + numrows = jas_matrix_numrows(c0); + assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numrows(c2) == numrows); + numcols = jas_matrix_numcols(c0); + assert(jas_matrix_numcols(c1) == numcols && jas_matrix_numcols(c2) == numcols); + for (i = 0; i < numrows; ++i) { + c0p = jas_matrix_getref(c0, i, 0); + c1p = jas_matrix_getref(c1, i, 0); + c2p = jas_matrix_getref(c2, i, 0); + for (j = numcols; j > 0; --j) { + y = *c0p; + u = *c1p; + v = *c2p; + r = jpc_fix_add(y, jpc_fix_mul(jpc_dbltofix(1.402), v)); + g = jpc_fix_add3(y, jpc_fix_mul(jpc_dbltofix(-0.34413), u), + jpc_fix_mul(jpc_dbltofix(-0.71414), v)); + b = jpc_fix_add(y, jpc_fix_mul(jpc_dbltofix(1.772), u)); + *c0p++ = r; + *c1p++ = g; + *c2p++ = b; + } + } } jpc_fix_t jpc_mct_getsynweight(int mctid, int cmptno) { - jpc_fix_t synweight; + jpc_fix_t synweight; - switch (mctid) { - case JPC_MCT_RCT: - switch (cmptno) { - case 0: - synweight = jpc_dbltofix(sqrt(3.0)); - break; - case 1: - synweight = jpc_dbltofix(sqrt(0.6875)); - break; - case 2: - synweight = jpc_dbltofix(sqrt(0.6875)); - break; - } - break; - case JPC_MCT_ICT: - switch (cmptno) { - case 0: - synweight = jpc_dbltofix(sqrt(3.0000)); - break; - case 1: - synweight = jpc_dbltofix(sqrt(3.2584)); - break; - case 2: - synweight = jpc_dbltofix(sqrt(2.4755)); - break; - } - break; - default: - synweight = JPC_FIX_ONE; - break; - } + switch (mctid) { + case JPC_MCT_RCT: + switch (cmptno) { + case 0: + synweight = jpc_dbltofix(sqrt(3.0)); + break; + case 1: + synweight = jpc_dbltofix(sqrt(0.6875)); + break; + case 2: + synweight = jpc_dbltofix(sqrt(0.6875)); + break; + } + break; + case JPC_MCT_ICT: + switch (cmptno) { + case 0: + synweight = jpc_dbltofix(sqrt(3.0000)); + break; + case 1: + synweight = jpc_dbltofix(sqrt(3.2584)); + break; + case 2: + synweight = jpc_dbltofix(sqrt(2.4755)); + break; + } + break; + default: + synweight = JPC_FIX_ONE; + break; + } - return synweight; + return synweight; } diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_mct.h b/converter/other/jpeg2000/libjasper/jpc/jpc_mct.h index d03d6ce1..bb424900 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_mct.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_mct.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -134,9 +134,9 @@ * Multicomponent transform IDs. */ -#define JPC_MCT_NONE 0 -#define JPC_MCT_ICT 1 -#define JPC_MCT_RCT 2 +#define JPC_MCT_NONE 0 +#define JPC_MCT_ICT 1 +#define JPC_MCT_RCT 2 /******************************************************************************\ * Functions. diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_mqcod.c b/converter/other/jpeg2000/libjasper/jpc/jpc_mqcod.c index 535eaa2d..e19f94ad 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_mqcod.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_mqcod.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -131,98 +131,98 @@ /* MQ coder per-state information. */ jpc_mqstate_t jpc_mqstates[47 * 2] = { - {0x5601, 0, &jpc_mqstates[ 2], &jpc_mqstates[ 3]}, - {0x5601, 1, &jpc_mqstates[ 3], &jpc_mqstates[ 2]}, - {0x3401, 0, &jpc_mqstates[ 4], &jpc_mqstates[12]}, - {0x3401, 1, &jpc_mqstates[ 5], &jpc_mqstates[13]}, - {0x1801, 0, &jpc_mqstates[ 6], &jpc_mqstates[18]}, - {0x1801, 1, &jpc_mqstates[ 7], &jpc_mqstates[19]}, - {0x0ac1, 0, &jpc_mqstates[ 8], &jpc_mqstates[24]}, - {0x0ac1, 1, &jpc_mqstates[ 9], &jpc_mqstates[25]}, - {0x0521, 0, &jpc_mqstates[10], &jpc_mqstates[58]}, - {0x0521, 1, &jpc_mqstates[11], &jpc_mqstates[59]}, - {0x0221, 0, &jpc_mqstates[76], &jpc_mqstates[66]}, - {0x0221, 1, &jpc_mqstates[77], &jpc_mqstates[67]}, - {0x5601, 0, &jpc_mqstates[14], &jpc_mqstates[13]}, - {0x5601, 1, &jpc_mqstates[15], &jpc_mqstates[12]}, - {0x5401, 0, &jpc_mqstates[16], &jpc_mqstates[28]}, - {0x5401, 1, &jpc_mqstates[17], &jpc_mqstates[29]}, - {0x4801, 0, &jpc_mqstates[18], &jpc_mqstates[28]}, - {0x4801, 1, &jpc_mqstates[19], &jpc_mqstates[29]}, - {0x3801, 0, &jpc_mqstates[20], &jpc_mqstates[28]}, - {0x3801, 1, &jpc_mqstates[21], &jpc_mqstates[29]}, - {0x3001, 0, &jpc_mqstates[22], &jpc_mqstates[34]}, - {0x3001, 1, &jpc_mqstates[23], &jpc_mqstates[35]}, - {0x2401, 0, &jpc_mqstates[24], &jpc_mqstates[36]}, - {0x2401, 1, &jpc_mqstates[25], &jpc_mqstates[37]}, - {0x1c01, 0, &jpc_mqstates[26], &jpc_mqstates[40]}, - {0x1c01, 1, &jpc_mqstates[27], &jpc_mqstates[41]}, - {0x1601, 0, &jpc_mqstates[58], &jpc_mqstates[42]}, - {0x1601, 1, &jpc_mqstates[59], &jpc_mqstates[43]}, - {0x5601, 0, &jpc_mqstates[30], &jpc_mqstates[29]}, - {0x5601, 1, &jpc_mqstates[31], &jpc_mqstates[28]}, - {0x5401, 0, &jpc_mqstates[32], &jpc_mqstates[28]}, - {0x5401, 1, &jpc_mqstates[33], &jpc_mqstates[29]}, - {0x5101, 0, &jpc_mqstates[34], &jpc_mqstates[30]}, - {0x5101, 1, &jpc_mqstates[35], &jpc_mqstates[31]}, - {0x4801, 0, &jpc_mqstates[36], &jpc_mqstates[32]}, - {0x4801, 1, &jpc_mqstates[37], &jpc_mqstates[33]}, - {0x3801, 0, &jpc_mqstates[38], &jpc_mqstates[34]}, - {0x3801, 1, &jpc_mqstates[39], &jpc_mqstates[35]}, - {0x3401, 0, &jpc_mqstates[40], &jpc_mqstates[36]}, - {0x3401, 1, &jpc_mqstates[41], &jpc_mqstates[37]}, - {0x3001, 0, &jpc_mqstates[42], &jpc_mqstates[38]}, - {0x3001, 1, &jpc_mqstates[43], &jpc_mqstates[39]}, - {0x2801, 0, &jpc_mqstates[44], &jpc_mqstates[38]}, - {0x2801, 1, &jpc_mqstates[45], &jpc_mqstates[39]}, - {0x2401, 0, &jpc_mqstates[46], &jpc_mqstates[40]}, - {0x2401, 1, &jpc_mqstates[47], &jpc_mqstates[41]}, - {0x2201, 0, &jpc_mqstates[48], &jpc_mqstates[42]}, - {0x2201, 1, &jpc_mqstates[49], &jpc_mqstates[43]}, - {0x1c01, 0, &jpc_mqstates[50], &jpc_mqstates[44]}, - {0x1c01, 1, &jpc_mqstates[51], &jpc_mqstates[45]}, - {0x1801, 0, &jpc_mqstates[52], &jpc_mqstates[46]}, - {0x1801, 1, &jpc_mqstates[53], &jpc_mqstates[47]}, - {0x1601, 0, &jpc_mqstates[54], &jpc_mqstates[48]}, - {0x1601, 1, &jpc_mqstates[55], &jpc_mqstates[49]}, - {0x1401, 0, &jpc_mqstates[56], &jpc_mqstates[50]}, - {0x1401, 1, &jpc_mqstates[57], &jpc_mqstates[51]}, - {0x1201, 0, &jpc_mqstates[58], &jpc_mqstates[52]}, - {0x1201, 1, &jpc_mqstates[59], &jpc_mqstates[53]}, - {0x1101, 0, &jpc_mqstates[60], &jpc_mqstates[54]}, - {0x1101, 1, &jpc_mqstates[61], &jpc_mqstates[55]}, - {0x0ac1, 0, &jpc_mqstates[62], &jpc_mqstates[56]}, - {0x0ac1, 1, &jpc_mqstates[63], &jpc_mqstates[57]}, - {0x09c1, 0, &jpc_mqstates[64], &jpc_mqstates[58]}, - {0x09c1, 1, &jpc_mqstates[65], &jpc_mqstates[59]}, - {0x08a1, 0, &jpc_mqstates[66], &jpc_mqstates[60]}, - {0x08a1, 1, &jpc_mqstates[67], &jpc_mqstates[61]}, - {0x0521, 0, &jpc_mqstates[68], &jpc_mqstates[62]}, - {0x0521, 1, &jpc_mqstates[69], &jpc_mqstates[63]}, - {0x0441, 0, &jpc_mqstates[70], &jpc_mqstates[64]}, - {0x0441, 1, &jpc_mqstates[71], &jpc_mqstates[65]}, - {0x02a1, 0, &jpc_mqstates[72], &jpc_mqstates[66]}, - {0x02a1, 1, &jpc_mqstates[73], &jpc_mqstates[67]}, - {0x0221, 0, &jpc_mqstates[74], &jpc_mqstates[68]}, - {0x0221, 1, &jpc_mqstates[75], &jpc_mqstates[69]}, - {0x0141, 0, &jpc_mqstates[76], &jpc_mqstates[70]}, - {0x0141, 1, &jpc_mqstates[77], &jpc_mqstates[71]}, - {0x0111, 0, &jpc_mqstates[78], &jpc_mqstates[72]}, - {0x0111, 1, &jpc_mqstates[79], &jpc_mqstates[73]}, - {0x0085, 0, &jpc_mqstates[80], &jpc_mqstates[74]}, - {0x0085, 1, &jpc_mqstates[81], &jpc_mqstates[75]}, - {0x0049, 0, &jpc_mqstates[82], &jpc_mqstates[76]}, - {0x0049, 1, &jpc_mqstates[83], &jpc_mqstates[77]}, - {0x0025, 0, &jpc_mqstates[84], &jpc_mqstates[78]}, - {0x0025, 1, &jpc_mqstates[85], &jpc_mqstates[79]}, - {0x0015, 0, &jpc_mqstates[86], &jpc_mqstates[80]}, - {0x0015, 1, &jpc_mqstates[87], &jpc_mqstates[81]}, - {0x0009, 0, &jpc_mqstates[88], &jpc_mqstates[82]}, - {0x0009, 1, &jpc_mqstates[89], &jpc_mqstates[83]}, - {0x0005, 0, &jpc_mqstates[90], &jpc_mqstates[84]}, - {0x0005, 1, &jpc_mqstates[91], &jpc_mqstates[85]}, - {0x0001, 0, &jpc_mqstates[90], &jpc_mqstates[86]}, - {0x0001, 1, &jpc_mqstates[91], &jpc_mqstates[87]}, - {0x5601, 0, &jpc_mqstates[92], &jpc_mqstates[92]}, - {0x5601, 1, &jpc_mqstates[93], &jpc_mqstates[93]}, + {0x5601, 0, &jpc_mqstates[ 2], &jpc_mqstates[ 3]}, + {0x5601, 1, &jpc_mqstates[ 3], &jpc_mqstates[ 2]}, + {0x3401, 0, &jpc_mqstates[ 4], &jpc_mqstates[12]}, + {0x3401, 1, &jpc_mqstates[ 5], &jpc_mqstates[13]}, + {0x1801, 0, &jpc_mqstates[ 6], &jpc_mqstates[18]}, + {0x1801, 1, &jpc_mqstates[ 7], &jpc_mqstates[19]}, + {0x0ac1, 0, &jpc_mqstates[ 8], &jpc_mqstates[24]}, + {0x0ac1, 1, &jpc_mqstates[ 9], &jpc_mqstates[25]}, + {0x0521, 0, &jpc_mqstates[10], &jpc_mqstates[58]}, + {0x0521, 1, &jpc_mqstates[11], &jpc_mqstates[59]}, + {0x0221, 0, &jpc_mqstates[76], &jpc_mqstates[66]}, + {0x0221, 1, &jpc_mqstates[77], &jpc_mqstates[67]}, + {0x5601, 0, &jpc_mqstates[14], &jpc_mqstates[13]}, + {0x5601, 1, &jpc_mqstates[15], &jpc_mqstates[12]}, + {0x5401, 0, &jpc_mqstates[16], &jpc_mqstates[28]}, + {0x5401, 1, &jpc_mqstates[17], &jpc_mqstates[29]}, + {0x4801, 0, &jpc_mqstates[18], &jpc_mqstates[28]}, + {0x4801, 1, &jpc_mqstates[19], &jpc_mqstates[29]}, + {0x3801, 0, &jpc_mqstates[20], &jpc_mqstates[28]}, + {0x3801, 1, &jpc_mqstates[21], &jpc_mqstates[29]}, + {0x3001, 0, &jpc_mqstates[22], &jpc_mqstates[34]}, + {0x3001, 1, &jpc_mqstates[23], &jpc_mqstates[35]}, + {0x2401, 0, &jpc_mqstates[24], &jpc_mqstates[36]}, + {0x2401, 1, &jpc_mqstates[25], &jpc_mqstates[37]}, + {0x1c01, 0, &jpc_mqstates[26], &jpc_mqstates[40]}, + {0x1c01, 1, &jpc_mqstates[27], &jpc_mqstates[41]}, + {0x1601, 0, &jpc_mqstates[58], &jpc_mqstates[42]}, + {0x1601, 1, &jpc_mqstates[59], &jpc_mqstates[43]}, + {0x5601, 0, &jpc_mqstates[30], &jpc_mqstates[29]}, + {0x5601, 1, &jpc_mqstates[31], &jpc_mqstates[28]}, + {0x5401, 0, &jpc_mqstates[32], &jpc_mqstates[28]}, + {0x5401, 1, &jpc_mqstates[33], &jpc_mqstates[29]}, + {0x5101, 0, &jpc_mqstates[34], &jpc_mqstates[30]}, + {0x5101, 1, &jpc_mqstates[35], &jpc_mqstates[31]}, + {0x4801, 0, &jpc_mqstates[36], &jpc_mqstates[32]}, + {0x4801, 1, &jpc_mqstates[37], &jpc_mqstates[33]}, + {0x3801, 0, &jpc_mqstates[38], &jpc_mqstates[34]}, + {0x3801, 1, &jpc_mqstates[39], &jpc_mqstates[35]}, + {0x3401, 0, &jpc_mqstates[40], &jpc_mqstates[36]}, + {0x3401, 1, &jpc_mqstates[41], &jpc_mqstates[37]}, + {0x3001, 0, &jpc_mqstates[42], &jpc_mqstates[38]}, + {0x3001, 1, &jpc_mqstates[43], &jpc_mqstates[39]}, + {0x2801, 0, &jpc_mqstates[44], &jpc_mqstates[38]}, + {0x2801, 1, &jpc_mqstates[45], &jpc_mqstates[39]}, + {0x2401, 0, &jpc_mqstates[46], &jpc_mqstates[40]}, + {0x2401, 1, &jpc_mqstates[47], &jpc_mqstates[41]}, + {0x2201, 0, &jpc_mqstates[48], &jpc_mqstates[42]}, + {0x2201, 1, &jpc_mqstates[49], &jpc_mqstates[43]}, + {0x1c01, 0, &jpc_mqstates[50], &jpc_mqstates[44]}, + {0x1c01, 1, &jpc_mqstates[51], &jpc_mqstates[45]}, + {0x1801, 0, &jpc_mqstates[52], &jpc_mqstates[46]}, + {0x1801, 1, &jpc_mqstates[53], &jpc_mqstates[47]}, + {0x1601, 0, &jpc_mqstates[54], &jpc_mqstates[48]}, + {0x1601, 1, &jpc_mqstates[55], &jpc_mqstates[49]}, + {0x1401, 0, &jpc_mqstates[56], &jpc_mqstates[50]}, + {0x1401, 1, &jpc_mqstates[57], &jpc_mqstates[51]}, + {0x1201, 0, &jpc_mqstates[58], &jpc_mqstates[52]}, + {0x1201, 1, &jpc_mqstates[59], &jpc_mqstates[53]}, + {0x1101, 0, &jpc_mqstates[60], &jpc_mqstates[54]}, + {0x1101, 1, &jpc_mqstates[61], &jpc_mqstates[55]}, + {0x0ac1, 0, &jpc_mqstates[62], &jpc_mqstates[56]}, + {0x0ac1, 1, &jpc_mqstates[63], &jpc_mqstates[57]}, + {0x09c1, 0, &jpc_mqstates[64], &jpc_mqstates[58]}, + {0x09c1, 1, &jpc_mqstates[65], &jpc_mqstates[59]}, + {0x08a1, 0, &jpc_mqstates[66], &jpc_mqstates[60]}, + {0x08a1, 1, &jpc_mqstates[67], &jpc_mqstates[61]}, + {0x0521, 0, &jpc_mqstates[68], &jpc_mqstates[62]}, + {0x0521, 1, &jpc_mqstates[69], &jpc_mqstates[63]}, + {0x0441, 0, &jpc_mqstates[70], &jpc_mqstates[64]}, + {0x0441, 1, &jpc_mqstates[71], &jpc_mqstates[65]}, + {0x02a1, 0, &jpc_mqstates[72], &jpc_mqstates[66]}, + {0x02a1, 1, &jpc_mqstates[73], &jpc_mqstates[67]}, + {0x0221, 0, &jpc_mqstates[74], &jpc_mqstates[68]}, + {0x0221, 1, &jpc_mqstates[75], &jpc_mqstates[69]}, + {0x0141, 0, &jpc_mqstates[76], &jpc_mqstates[70]}, + {0x0141, 1, &jpc_mqstates[77], &jpc_mqstates[71]}, + {0x0111, 0, &jpc_mqstates[78], &jpc_mqstates[72]}, + {0x0111, 1, &jpc_mqstates[79], &jpc_mqstates[73]}, + {0x0085, 0, &jpc_mqstates[80], &jpc_mqstates[74]}, + {0x0085, 1, &jpc_mqstates[81], &jpc_mqstates[75]}, + {0x0049, 0, &jpc_mqstates[82], &jpc_mqstates[76]}, + {0x0049, 1, &jpc_mqstates[83], &jpc_mqstates[77]}, + {0x0025, 0, &jpc_mqstates[84], &jpc_mqstates[78]}, + {0x0025, 1, &jpc_mqstates[85], &jpc_mqstates[79]}, + {0x0015, 0, &jpc_mqstates[86], &jpc_mqstates[80]}, + {0x0015, 1, &jpc_mqstates[87], &jpc_mqstates[81]}, + {0x0009, 0, &jpc_mqstates[88], &jpc_mqstates[82]}, + {0x0009, 1, &jpc_mqstates[89], &jpc_mqstates[83]}, + {0x0005, 0, &jpc_mqstates[90], &jpc_mqstates[84]}, + {0x0005, 1, &jpc_mqstates[91], &jpc_mqstates[85]}, + {0x0001, 0, &jpc_mqstates[90], &jpc_mqstates[86]}, + {0x0001, 1, &jpc_mqstates[91], &jpc_mqstates[87]}, + {0x5601, 0, &jpc_mqstates[92], &jpc_mqstates[92]}, + {0x5601, 1, &jpc_mqstates[93], &jpc_mqstates[93]}, }; diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_mqcod.h b/converter/other/jpeg2000/libjasper/jpc/jpc_mqcod.h index 5f99e021..f32fc7fc 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_mqcod.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_mqcod.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -136,11 +136,11 @@ typedef struct { - /* The most probable symbol (MPS). */ - bool mps; + /* The most probable symbol (MPS). */ + bool mps; - /* The state index. */ - int_fast16_t ind; + /* The state index. */ + int_fast16_t ind; } jpc_mqctx_t; @@ -150,17 +150,17 @@ typedef struct { typedef struct jpc_mqstate_s { - /* The Qe value. */ - uint_fast16_t qeval; + /* The Qe value. */ + uint_fast16_t qeval; - /* The MPS. */ - uint_fast16_t mps; + /* The MPS. */ + uint_fast16_t mps; - /* The NMPS state. */ - struct jpc_mqstate_s *nmps; + /* The NMPS state. */ + struct jpc_mqstate_s *nmps; - /* The NLPS state. */ - struct jpc_mqstate_s *nlps; + /* The NLPS state. */ + struct jpc_mqstate_s *nlps; } jpc_mqstate_t; diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_mqdec.c b/converter/other/jpeg2000/libjasper/jpc/jpc_mqdec.c index f58a1c7d..2d419522 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_mqdec.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_mqdec.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -136,10 +136,10 @@ \******************************************************************************/ #if defined(DEBUG) -#define MQDEC_CALL(n, x) \ - ((jas_getdbglevel() >= (n)) ? ((void)(x)) : ((void)0)) +#define MQDEC_CALL(n, x) \ + ((jas_getdbglevel() >= (n)) ? ((void)(x)) : ((void)0)) #else -#define MQDEC_CALL(n, x) +#define MQDEC_CALL(n, x) #endif /******************************************************************************\ @@ -155,49 +155,49 @@ static void jpc_mqdec_bytein(jpc_mqdec_t *mqdec); /* Create a MQ decoder. */ jpc_mqdec_t *jpc_mqdec_create(int maxctxs, jas_stream_t *in) { - jpc_mqdec_t *mqdec; - - /* There must be at least one context. */ - assert(maxctxs > 0); - - /* Allocate memory for the MQ decoder. */ - if (!(mqdec = jas_malloc(sizeof(jpc_mqdec_t)))) { - goto error; - } - mqdec->in = in; - mqdec->maxctxs = maxctxs; - /* Allocate memory for the per-context state information. */ - if (!(mqdec->ctxs = jas_malloc(mqdec->maxctxs * sizeof(jpc_mqstate_t *)))) { - goto error; - } - /* Set the current context to the first context. */ - mqdec->curctx = mqdec->ctxs; - - /* If an input stream has been associated with the MQ decoder, - initialize the decoder state from the stream. */ - if (mqdec->in) { - jpc_mqdec_init(mqdec); - } - /* Initialize the per-context state information. */ - jpc_mqdec_setctxs(mqdec, 0, 0); - - return mqdec; + jpc_mqdec_t *mqdec; + + /* There must be at least one context. */ + assert(maxctxs > 0); + + /* Allocate memory for the MQ decoder. */ + if (!(mqdec = jas_malloc(sizeof(jpc_mqdec_t)))) { + goto error; + } + mqdec->in = in; + mqdec->maxctxs = maxctxs; + /* Allocate memory for the per-context state information. */ + if (!(mqdec->ctxs = jas_malloc(mqdec->maxctxs * sizeof(jpc_mqstate_t *)))) { + goto error; + } + /* Set the current context to the first context. */ + mqdec->curctx = mqdec->ctxs; + + /* If an input stream has been associated with the MQ decoder, + initialize the decoder state from the stream. */ + if (mqdec->in) { + jpc_mqdec_init(mqdec); + } + /* Initialize the per-context state information. */ + jpc_mqdec_setctxs(mqdec, 0, 0); + + return mqdec; error: - /* Oops... Something has gone wrong. */ - if (mqdec) { - jpc_mqdec_destroy(mqdec); - } - return 0; + /* Oops... Something has gone wrong. */ + if (mqdec) { + jpc_mqdec_destroy(mqdec); + } + return 0; } /* Destroy a MQ decoder. */ void jpc_mqdec_destroy(jpc_mqdec_t *mqdec) { - if (mqdec->ctxs) { - jas_free(mqdec->ctxs); - } - jas_free(mqdec); + if (mqdec->ctxs) { + jas_free(mqdec->ctxs); + } + jas_free(mqdec); } /******************************************************************************\ @@ -208,59 +208,59 @@ void jpc_mqdec_destroy(jpc_mqdec_t *mqdec) void jpc_mqdec_init(jpc_mqdec_t *mqdec) { - int c; - - mqdec->eof = 0; - mqdec->creg = 0; - /* Get the next byte from the input stream. */ - if ((c = jas_stream_getc(mqdec->in)) == EOF) { - /* We have encountered an I/O error or EOF. */ - c = 0xff; - mqdec->eof = 1; - } - mqdec->inbuffer = c; - mqdec->creg += mqdec->inbuffer << 16; - jpc_mqdec_bytein(mqdec); - mqdec->creg <<= 7; - mqdec->ctreg -= 7; - mqdec->areg = 0x8000; + int c; + + mqdec->eof = 0; + mqdec->creg = 0; + /* Get the next byte from the input stream. */ + if ((c = jas_stream_getc(mqdec->in)) == EOF) { + /* We have encountered an I/O error or EOF. */ + c = 0xff; + mqdec->eof = 1; + } + mqdec->inbuffer = c; + mqdec->creg += mqdec->inbuffer << 16; + jpc_mqdec_bytein(mqdec); + mqdec->creg <<= 7; + mqdec->ctreg -= 7; + mqdec->areg = 0x8000; } /* Set the input stream for a MQ decoder. */ void jpc_mqdec_setinput(jpc_mqdec_t *mqdec, jas_stream_t *in) { - mqdec->in = in; + mqdec->in = in; } /* Initialize one or more contexts. */ void jpc_mqdec_setctxs(jpc_mqdec_t *mqdec, int numctxs, jpc_mqctx_t *ctxs) { - jpc_mqstate_t **ctx; - int n; - - ctx = mqdec->ctxs; - n = JAS_MIN(mqdec->maxctxs, numctxs); - while (--n >= 0) { - *ctx = &jpc_mqstates[2 * ctxs->ind + ctxs->mps]; - ++ctx; - ++ctxs; - } - n = mqdec->maxctxs - numctxs; - while (--n >= 0) { - *ctx = &jpc_mqstates[0]; - ++ctx; - } + jpc_mqstate_t **ctx; + int n; + + ctx = mqdec->ctxs; + n = JAS_MIN(mqdec->maxctxs, numctxs); + while (--n >= 0) { + *ctx = &jpc_mqstates[2 * ctxs->ind + ctxs->mps]; + ++ctx; + ++ctxs; + } + n = mqdec->maxctxs - numctxs; + while (--n >= 0) { + *ctx = &jpc_mqstates[0]; + ++ctx; + } } /* Initialize a context. */ void jpc_mqdec_setctx(jpc_mqdec_t *mqdec, int ctxno, jpc_mqctx_t *ctx) { - jpc_mqstate_t **ctxi; - ctxi = &mqdec->ctxs[ctxno]; - *ctxi = &jpc_mqstates[2 * ctx->ind + ctx->mps]; + jpc_mqstate_t **ctxi; + ctxi = &mqdec->ctxs[ctxno]; + *ctxi = &jpc_mqstates[2 * ctx->ind + ctx->mps]; } /******************************************************************************\ @@ -271,36 +271,36 @@ void jpc_mqdec_setctx(jpc_mqdec_t *mqdec, int ctxno, jpc_mqctx_t *ctx) int jpc_mqdec_getbit_func(register jpc_mqdec_t *mqdec) { - int bit; - JAS_DBGLOG(100, ("jpc_mqdec_getbit_func(%p)\n", mqdec)); - MQDEC_CALL(100, jpc_mqdec_dump(mqdec, stderr)); - bit = jpc_mqdec_getbit_macro(mqdec); - MQDEC_CALL(100, jpc_mqdec_dump(mqdec, stderr)); - JAS_DBGLOG(100, ("ctx = %d, decoded %d\n", mqdec->curctx - - mqdec->ctxs, bit)); - return bit; + int bit; + JAS_DBGLOG(100, ("jpc_mqdec_getbit_func(%p)\n", mqdec)); + MQDEC_CALL(100, jpc_mqdec_dump(mqdec, stderr)); + bit = jpc_mqdec_getbit_macro(mqdec); + MQDEC_CALL(100, jpc_mqdec_dump(mqdec, stderr)); + JAS_DBGLOG(100, ("ctx = %d, decoded %d\n", mqdec->curctx - + mqdec->ctxs, bit)); + return bit; } /* Apply MPS_EXCHANGE algorithm (with RENORMD). */ int jpc_mqdec_mpsexchrenormd(register jpc_mqdec_t *mqdec) { - int ret; - register jpc_mqstate_t *state = *mqdec->curctx; - jpc_mqdec_mpsexchange(mqdec->areg, state->qeval, mqdec->curctx, ret); - jpc_mqdec_renormd(mqdec->areg, mqdec->creg, mqdec->ctreg, mqdec->in, - mqdec->eof, mqdec->inbuffer); - return ret; + int ret; + register jpc_mqstate_t *state = *mqdec->curctx; + jpc_mqdec_mpsexchange(mqdec->areg, state->qeval, mqdec->curctx, ret); + jpc_mqdec_renormd(mqdec->areg, mqdec->creg, mqdec->ctreg, mqdec->in, + mqdec->eof, mqdec->inbuffer); + return ret; } /* Apply LPS_EXCHANGE algorithm (with RENORMD). */ int jpc_mqdec_lpsexchrenormd(register jpc_mqdec_t *mqdec) { - int ret; - register jpc_mqstate_t *state = *mqdec->curctx; - jpc_mqdec_lpsexchange(mqdec->areg, state->qeval, mqdec->curctx, ret); - jpc_mqdec_renormd(mqdec->areg, mqdec->creg, mqdec->ctreg, mqdec->in, - mqdec->eof, mqdec->inbuffer); - return ret; + int ret; + register jpc_mqstate_t *state = *mqdec->curctx; + jpc_mqdec_lpsexchange(mqdec->areg, state->qeval, mqdec->curctx, ret); + jpc_mqdec_renormd(mqdec->areg, mqdec->creg, mqdec->ctreg, mqdec->in, + mqdec->eof, mqdec->inbuffer); + return ret; } /******************************************************************************\ @@ -310,30 +310,30 @@ int jpc_mqdec_lpsexchrenormd(register jpc_mqdec_t *mqdec) /* Apply the BYTEIN algorithm. */ static void jpc_mqdec_bytein(jpc_mqdec_t *mqdec) { - int c; - unsigned char prevbuf; - - if (!mqdec->eof) { - if ((c = jas_stream_getc(mqdec->in)) == EOF) { - mqdec->eof = 1; - c = 0xff; - } - prevbuf = mqdec->inbuffer; - mqdec->inbuffer = c; - if (prevbuf == 0xff) { - if (c > 0x8f) { - mqdec->creg += 0xff00; - mqdec->ctreg = 8; - } else { - mqdec->creg += c << 9; - mqdec->ctreg = 7; - } - } else { - mqdec->creg += c << 8; - mqdec->ctreg = 8; - } - } else { - mqdec->creg += 0xff00; - mqdec->ctreg = 8; - } + int c; + unsigned char prevbuf; + + if (!mqdec->eof) { + if ((c = jas_stream_getc(mqdec->in)) == EOF) { + mqdec->eof = 1; + c = 0xff; + } + prevbuf = mqdec->inbuffer; + mqdec->inbuffer = c; + if (prevbuf == 0xff) { + if (c > 0x8f) { + mqdec->creg += 0xff00; + mqdec->ctreg = 8; + } else { + mqdec->creg += c << 9; + mqdec->ctreg = 7; + } + } else { + mqdec->creg += c << 8; + mqdec->ctreg = 8; + } + } else { + mqdec->creg += 0xff00; + mqdec->ctreg = 8; + } } diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_mqdec.h b/converter/other/jpeg2000/libjasper/jpc/jpc_mqdec.h index 30185506..b207c92b 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_mqdec.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_mqdec.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -136,32 +136,32 @@ typedef struct { - /* The C register. */ - uint_fast32_t creg; + /* The C register. */ + uint_fast32_t creg; - /* The A register. */ - uint_fast32_t areg; + /* The A register. */ + uint_fast32_t areg; - /* The CT register. */ - uint_fast32_t ctreg; + /* The CT register. */ + uint_fast32_t ctreg; - /* The current context. */ - jpc_mqstate_t **curctx; + /* The current context. */ + jpc_mqstate_t **curctx; - /* The per-context information. */ - jpc_mqstate_t **ctxs; + /* The per-context information. */ + jpc_mqstate_t **ctxs; - /* The maximum number of contexts. */ - int maxctxs; + /* The maximum number of contexts. */ + int maxctxs; - /* The stream from which to read data. */ - jas_stream_t *in; + /* The stream from which to read data. */ + jas_stream_t *in; - /* The last character read. */ - unsigned char inbuffer; + /* The last character read. */ + unsigned char inbuffer; - /* The EOF indicator. */ - int eof; + /* The EOF indicator. */ + int eof; } jpc_mqdec_t; @@ -190,8 +190,8 @@ void jpc_mqdec_init(jpc_mqdec_t *dec); \******************************************************************************/ /* Set the current context for a MQ decoder. */ -#define jpc_mqdec_setcurctx(dec, ctxno) \ - ((mqdec)->curctx = &(mqdec)->ctxs[ctxno]); +#define jpc_mqdec_setcurctx(dec, ctxno) \ + ((mqdec)->curctx = &(mqdec)->ctxs[ctxno]); /* Set the state information for a particular context of a MQ decoder. */ void jpc_mqdec_setctx(jpc_mqdec_t *dec, int ctxno, jpc_mqctx_t *ctx); @@ -205,20 +205,20 @@ void jpc_mqdec_setctxs(jpc_mqdec_t *dec, int numctxs, jpc_mqctx_t *ctxs); /* Decode a symbol. */ #if !defined(DEBUG) -#define jpc_mqdec_getbit(dec) \ - jpc_mqdec_getbit_macro(dec) +#define jpc_mqdec_getbit(dec) \ + jpc_mqdec_getbit_macro(dec) #else -#define jpc_mqdec_getbit(dec) \ - jpc_mqdec_getbit_func(dec) +#define jpc_mqdec_getbit(dec) \ + jpc_mqdec_getbit_func(dec) #endif /* Decode a symbol (assuming an unskewed probability distribution). */ #if !defined(DEBUG) -#define jpc_mqdec_getbitnoskew(dec) \ - jpc_mqdec_getbit_macro(dec) +#define jpc_mqdec_getbitnoskew(dec) \ + jpc_mqdec_getbit_macro(dec) #else -#define jpc_mqdec_getbitnoskew(dec) \ - jpc_mqdec_getbit_func(dec) +#define jpc_mqdec_getbitnoskew(dec) \ + jpc_mqdec_getbit_func(dec) #endif /******************************************************************************\ @@ -234,83 +234,83 @@ void mqdec_dump(jpc_mqdec_t *dec, FILE *out); * GIVEN BELOW. \******************************************************************************/ -#define jpc_mqdec_getbit_macro(dec) \ - ((((dec)->areg -= (*(dec)->curctx)->qeval), \ - (dec)->creg >> 16 >= (*(dec)->curctx)->qeval) ? \ - ((((dec)->creg -= (*(dec)->curctx)->qeval << 16), \ - (dec)->areg & 0x8000) ? (*(dec)->curctx)->mps : \ - jpc_mqdec_mpsexchrenormd(dec)) : \ - jpc_mqdec_lpsexchrenormd(dec)) +#define jpc_mqdec_getbit_macro(dec) \ + ((((dec)->areg -= (*(dec)->curctx)->qeval), \ + (dec)->creg >> 16 >= (*(dec)->curctx)->qeval) ? \ + ((((dec)->creg -= (*(dec)->curctx)->qeval << 16), \ + (dec)->areg & 0x8000) ? (*(dec)->curctx)->mps : \ + jpc_mqdec_mpsexchrenormd(dec)) : \ + jpc_mqdec_lpsexchrenormd(dec)) -#define jpc_mqdec_mpsexchange(areg, delta, curctx, bit) \ +#define jpc_mqdec_mpsexchange(areg, delta, curctx, bit) \ { \ - if ((areg) < (delta)) { \ - register jpc_mqstate_t *state = *(curctx); \ - /* LPS decoded. */ \ - (bit) = state->mps ^ 1; \ - *(curctx) = state->nlps; \ - } else { \ - register jpc_mqstate_t *state = *(curctx); \ - /* MPS decoded. */ \ - (bit) = state->mps; \ - *(curctx) = state->nmps; \ - } \ + if ((areg) < (delta)) { \ + register jpc_mqstate_t *state = *(curctx); \ + /* LPS decoded. */ \ + (bit) = state->mps ^ 1; \ + *(curctx) = state->nlps; \ + } else { \ + register jpc_mqstate_t *state = *(curctx); \ + /* MPS decoded. */ \ + (bit) = state->mps; \ + *(curctx) = state->nmps; \ + } \ } -#define jpc_mqdec_lpsexchange(areg, delta, curctx, bit) \ +#define jpc_mqdec_lpsexchange(areg, delta, curctx, bit) \ { \ - if ((areg) >= (delta)) { \ - register jpc_mqstate_t *state = *(curctx); \ - (areg) = (delta); \ - (bit) = state->mps ^ 1; \ - *(curctx) = state->nlps; \ - } else { \ - register jpc_mqstate_t *state = *(curctx); \ - (areg) = (delta); \ - (bit) = state->mps; \ - *(curctx) = state->nmps; \ - } \ + if ((areg) >= (delta)) { \ + register jpc_mqstate_t *state = *(curctx); \ + (areg) = (delta); \ + (bit) = state->mps ^ 1; \ + *(curctx) = state->nlps; \ + } else { \ + register jpc_mqstate_t *state = *(curctx); \ + (areg) = (delta); \ + (bit) = state->mps; \ + *(curctx) = state->nmps; \ + } \ } -#define jpc_mqdec_renormd(areg, creg, ctreg, in, eof, inbuf) \ +#define jpc_mqdec_renormd(areg, creg, ctreg, in, eof, inbuf) \ { \ - do { \ - if (!(ctreg)) { \ - jpc_mqdec_bytein2(creg, ctreg, in, eof, inbuf); \ - } \ - (areg) <<= 1; \ - (creg) <<= 1; \ - --(ctreg); \ - } while (!((areg) & 0x8000)); \ + do { \ + if (!(ctreg)) { \ + jpc_mqdec_bytein2(creg, ctreg, in, eof, inbuf); \ + } \ + (areg) <<= 1; \ + (creg) <<= 1; \ + --(ctreg); \ + } while (!((areg) & 0x8000)); \ } -#define jpc_mqdec_bytein2(creg, ctreg, in, eof, inbuf) \ +#define jpc_mqdec_bytein2(creg, ctreg, in, eof, inbuf) \ { \ - int c; \ - unsigned char prevbuf; \ - if (!(eof)) { \ - if ((c = jas_stream_getc(in)) == EOF) { \ - (eof) = 1; \ - c = 0xff; \ - } \ - prevbuf = (inbuf); \ - (inbuf) = c; \ - if (prevbuf == 0xff) { \ - if (c > 0x8f) { \ - (creg) += 0xff00; \ - (ctreg) = 8; \ - } else { \ - (creg) += c << 9; \ - (ctreg) = 7; \ - } \ - } else { \ - (creg) += c << 8; \ - (ctreg) = 8; \ - } \ - } else { \ - (creg) += 0xff00; \ - (ctreg) = 8; \ - } \ + int c; \ + unsigned char prevbuf; \ + if (!(eof)) { \ + if ((c = jas_stream_getc(in)) == EOF) { \ + (eof) = 1; \ + c = 0xff; \ + } \ + prevbuf = (inbuf); \ + (inbuf) = c; \ + if (prevbuf == 0xff) { \ + if (c > 0x8f) { \ + (creg) += 0xff00; \ + (ctreg) = 8; \ + } else { \ + (creg) += c << 9; \ + (ctreg) = 7; \ + } \ + } else { \ + (creg) += c << 8; \ + (ctreg) = 8; \ + } \ + } else { \ + (creg) += 0xff00; \ + (ctreg) = 8; \ + } \ } int jpc_mqdec_getbit_func(jpc_mqdec_t *dec); diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_mqenc.h b/converter/other/jpeg2000/libjasper/jpc/jpc_mqenc.h index 1421ae4d..4a1be355 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_mqenc.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_mqenc.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -136,8 +136,8 @@ * Termination modes. */ -#define JPC_MQENC_DEFTERM 0 /* default termination */ -#define JPC_MQENC_PTERM 1 /* predictable termination */ +#define JPC_MQENC_DEFTERM 0 /* default termination */ +#define JPC_MQENC_PTERM 1 /* predictable termination */ /******************************************************************************\ * Types. @@ -147,53 +147,53 @@ typedef struct { - /* The C register. */ - uint_fast32_t creg; + /* The C register. */ + uint_fast32_t creg; - /* The A register. */ - uint_fast32_t areg; + /* The A register. */ + uint_fast32_t areg; - /* The CT register. */ - uint_fast32_t ctreg; + /* The CT register. */ + uint_fast32_t ctreg; - /* The maximum number of contexts. */ - int maxctxs; + /* The maximum number of contexts. */ + int maxctxs; - /* The per-context information. */ - jpc_mqstate_t **ctxs; + /* The per-context information. */ + jpc_mqstate_t **ctxs; - /* The current context. */ - jpc_mqstate_t **curctx; + /* The current context. */ + jpc_mqstate_t **curctx; - /* The stream for encoder output. */ - jas_stream_t *out; + /* The stream for encoder output. */ + jas_stream_t *out; - /* The byte buffer (i.e., the B variable in the standard). */ - int_fast16_t outbuf; + /* The byte buffer (i.e., the B variable in the standard). */ + int_fast16_t outbuf; - /* The last byte output. */ - int_fast16_t lastbyte; + /* The last byte output. */ + int_fast16_t lastbyte; - /* The error indicator. */ - int err; - + /* The error indicator. */ + int err; + } jpc_mqenc_t; /* MQ arithmetic encoder state information. */ typedef struct { - /* The A register. */ - unsigned areg; + /* The A register. */ + unsigned areg; - /* The C register. */ - unsigned creg; + /* The C register. */ + unsigned creg; - /* The CT register. */ - unsigned ctreg; + /* The CT register. */ + unsigned ctreg; - /* The last byte output by the encoder. */ - int lastbyte; + /* The last byte output by the encoder. */ + int lastbyte; } jpc_mqencstate_t; @@ -219,7 +219,7 @@ void jpc_mqenc_init(jpc_mqenc_t *enc); \******************************************************************************/ /* Set the current context. */ -#define jpc_mqenc_setcurctx(enc, ctxno) \ +#define jpc_mqenc_setcurctx(enc, ctxno) \ ((enc)->curctx = &(enc)->ctxs[ctxno]); /* Set the state information for a particular context. */ @@ -233,8 +233,8 @@ void jpc_mqenc_setctxs(jpc_mqenc_t *enc, int numctxs, jpc_mqctx_t *ctxs); \******************************************************************************/ /* Get the error state of a MQ encoder. */ -#define jpc_mqenc_error(enc) \ - ((enc)->err) +#define jpc_mqenc_error(enc) \ + ((enc)->err) /* Get the current encoder state. */ void jpc_mqenc_getstate(jpc_mqenc_t *enc, jpc_mqencstate_t *state); @@ -248,9 +248,9 @@ int jpc_mqenc_flush(jpc_mqenc_t *enc, int termmode); /* Encode a bit. */ #if !defined(DEBUG) -#define jpc_mqenc_putbit(enc, bit) jpc_mqenc_putbit_macro(enc, bit) +#define jpc_mqenc_putbit(enc, bit) jpc_mqenc_putbit_macro(enc, bit) #else -#define jpc_mqenc_putbit(enc, bit) jpc_mqenc_putbit_func(enc, bit) +#define jpc_mqenc_putbit(enc, bit) jpc_mqenc_putbit_func(enc, bit) #endif /******************************************************************************\ @@ -265,12 +265,12 @@ int jpc_mqenc_dump(jpc_mqenc_t *mqenc, FILE *out); /* Note: This macro is included only to satisfy the needs of the mqenc_putbit macro. */ -#define jpc_mqenc_putbit_macro(enc, bit) \ - (((*((enc)->curctx))->mps == (bit)) ? \ - (((enc)->areg -= (*(enc)->curctx)->qeval), \ - ((!((enc)->areg & 0x8000)) ? (jpc_mqenc_codemps2(enc)) : \ - ((enc)->creg += (*(enc)->curctx)->qeval))) : \ - jpc_mqenc_codelps(enc)) +#define jpc_mqenc_putbit_macro(enc, bit) \ + (((*((enc)->curctx))->mps == (bit)) ? \ + (((enc)->areg -= (*(enc)->curctx)->qeval), \ + ((!((enc)->areg & 0x8000)) ? (jpc_mqenc_codemps2(enc)) : \ + ((enc)->creg += (*(enc)->curctx)->qeval))) : \ + jpc_mqenc_codelps(enc)) /* Note: These function prototypes are included only to satisfy the needs of the mqenc_putbit_macro macro. Do not call any of these diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_qmfb.c b/converter/other/jpeg2000/libjasper/jpc/jpc_qmfb.c index 80bc5aa5..3962f5ad 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_qmfb.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_qmfb.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -153,19 +153,19 @@ static void jpc_ns_synthesize(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x); \******************************************************************************/ jpc_qmfb1dops_t jpc_ft_ops = { - jpc_ft_getnumchans, - jpc_ft_getanalfilters, - jpc_ft_getsynfilters, - jpc_ft_analyze, - jpc_ft_synthesize + jpc_ft_getnumchans, + jpc_ft_getanalfilters, + jpc_ft_getsynfilters, + jpc_ft_analyze, + jpc_ft_synthesize }; jpc_qmfb1dops_t jpc_ns_ops = { - jpc_ns_getnumchans, - jpc_ns_getanalfilters, - jpc_ns_getsynfilters, - jpc_ns_analyze, - jpc_ns_synthesize + jpc_ns_getnumchans, + jpc_ns_getanalfilters, + jpc_ns_getsynfilters, + jpc_ns_analyze, + jpc_ns_synthesize }; /******************************************************************************\ @@ -176,12 +176,12 @@ static void jpc_qmfb1d_setup(jpc_fix_t *startptr, int startind, int endind, int intrastep, jpc_fix_t **lstartptr, int *lstartind, int *lendind, jpc_fix_t **hstartptr, int *hstartind, int *hendind) { - *lstartind = JPC_CEILDIVPOW2(startind, 1); - *lendind = JPC_CEILDIVPOW2(endind, 1); - *hstartind = JPC_FLOORDIVPOW2(startind, 1); - *hendind = JPC_FLOORDIVPOW2(endind, 1); - *lstartptr = startptr; - *hstartptr = &startptr[(*lendind - *lstartind) * intrastep]; + *lstartind = JPC_CEILDIVPOW2(startind, 1); + *lendind = JPC_CEILDIVPOW2(endind, 1); + *hstartind = JPC_FLOORDIVPOW2(startind, 1); + *hendind = JPC_FLOORDIVPOW2(endind, 1); + *lstartptr = startptr; + *hstartptr = &startptr[(*lendind - *lstartind) * intrastep]; } static void jpc_qmfb1d_split(jpc_fix_t *startptr, int startind, int endind, @@ -189,204 +189,204 @@ static void jpc_qmfb1d_split(jpc_fix_t *startptr, int startind, int endind, jpc_fix_t *hstartptr, int hstartind, int hendind) { #define QMFB_SPLITBUFSIZE 4096 - jpc_fix_t splitbuf[QMFB_SPLITBUFSIZE]; - jpc_fix_t *buf = splitbuf; - int llen; - int hlen; - int twostep; - jpc_fix_t *tmpptr; - register jpc_fix_t *ptr; - register jpc_fix_t *hptr; - register jpc_fix_t *lptr; - register int n; - int state; - - twostep = step << 1; - llen = lendind - lstartind; - hlen = hendind - hstartind; - - if (hstartind < lstartind) { - /* The first sample in the input signal is to appear - in the highpass subband signal. */ - /* Copy the appropriate samples into the lowpass subband - signal, saving any samples destined for the highpass subband - signal as they are overwritten. */ - tmpptr = buf; - ptr = &startptr[step]; - lptr = lstartptr; - n = llen; - state = 1; - while (n-- > 0) { - if (state) { - *tmpptr = *lptr; - ++tmpptr; - } - *lptr = *ptr; - ptr += twostep; - lptr += step; - state ^= 1; - } - /* Copy the appropriate samples into the highpass subband - signal. */ - /* Handle the nonoverwritten samples. */ - hptr = &hstartptr[(hlen - 1) * step]; - ptr = &startptr[(((llen + hlen - 1) >> 1) << 1) * step]; - n = hlen - (tmpptr - buf); - while (n-- > 0) { - *hptr = *ptr; - hptr -= step; - ptr -= twostep; - } - /* Handle the overwritten samples. */ - n = tmpptr - buf; - while (n-- > 0) { - --tmpptr; - *hptr = *tmpptr; - hptr -= step; - } - } else { - /* The first sample in the input signal is to appear - in the lowpass subband signal. */ - /* Copy the appropriate samples into the lowpass subband - signal, saving any samples for the highpass subband - signal as they are overwritten. */ - state = 0; - ptr = startptr; - lptr = lstartptr; - tmpptr = buf; - n = llen; - while (n-- > 0) { - if (state) { - *tmpptr = *lptr; - ++tmpptr; - } - *lptr = *ptr; - ptr += twostep; - lptr += step; - state ^= 1; - } - /* Copy the appropriate samples into the highpass subband - signal. */ - /* Handle the nonoverwritten samples. */ - ptr = &startptr[((((llen + hlen) >> 1) << 1) - 1) * step]; - hptr = &hstartptr[(hlen - 1) * step]; - n = hlen - (tmpptr - buf); - while (n-- > 0) { - *hptr = *ptr; - ptr -= twostep; - hptr -= step; - } - /* Handle the overwritten samples. */ - n = tmpptr - buf; - while (n-- > 0) { - --tmpptr; - *hptr = *tmpptr; - hptr -= step; - } - } + jpc_fix_t splitbuf[QMFB_SPLITBUFSIZE]; + jpc_fix_t *buf = splitbuf; + int llen; + int hlen; + int twostep; + jpc_fix_t *tmpptr; + register jpc_fix_t *ptr; + register jpc_fix_t *hptr; + register jpc_fix_t *lptr; + register int n; + int state; + + twostep = step << 1; + llen = lendind - lstartind; + hlen = hendind - hstartind; + + if (hstartind < lstartind) { + /* The first sample in the input signal is to appear + in the highpass subband signal. */ + /* Copy the appropriate samples into the lowpass subband + signal, saving any samples destined for the highpass subband + signal as they are overwritten. */ + tmpptr = buf; + ptr = &startptr[step]; + lptr = lstartptr; + n = llen; + state = 1; + while (n-- > 0) { + if (state) { + *tmpptr = *lptr; + ++tmpptr; + } + *lptr = *ptr; + ptr += twostep; + lptr += step; + state ^= 1; + } + /* Copy the appropriate samples into the highpass subband + signal. */ + /* Handle the nonoverwritten samples. */ + hptr = &hstartptr[(hlen - 1) * step]; + ptr = &startptr[(((llen + hlen - 1) >> 1) << 1) * step]; + n = hlen - (tmpptr - buf); + while (n-- > 0) { + *hptr = *ptr; + hptr -= step; + ptr -= twostep; + } + /* Handle the overwritten samples. */ + n = tmpptr - buf; + while (n-- > 0) { + --tmpptr; + *hptr = *tmpptr; + hptr -= step; + } + } else { + /* The first sample in the input signal is to appear + in the lowpass subband signal. */ + /* Copy the appropriate samples into the lowpass subband + signal, saving any samples for the highpass subband + signal as they are overwritten. */ + state = 0; + ptr = startptr; + lptr = lstartptr; + tmpptr = buf; + n = llen; + while (n-- > 0) { + if (state) { + *tmpptr = *lptr; + ++tmpptr; + } + *lptr = *ptr; + ptr += twostep; + lptr += step; + state ^= 1; + } + /* Copy the appropriate samples into the highpass subband + signal. */ + /* Handle the nonoverwritten samples. */ + ptr = &startptr[((((llen + hlen) >> 1) << 1) - 1) * step]; + hptr = &hstartptr[(hlen - 1) * step]; + n = hlen - (tmpptr - buf); + while (n-- > 0) { + *hptr = *ptr; + ptr -= twostep; + hptr -= step; + } + /* Handle the overwritten samples. */ + n = tmpptr - buf; + while (n-- > 0) { + --tmpptr; + *hptr = *tmpptr; + hptr -= step; + } + } } static void jpc_qmfb1d_join(jpc_fix_t *startptr, int startind, int endind, register int step, jpc_fix_t *lstartptr, int lstartind, int lendind, jpc_fix_t *hstartptr, int hstartind, int hendind) { -#define QMFB_JOINBUFSIZE 4096 - jpc_fix_t joinbuf[QMFB_JOINBUFSIZE]; - jpc_fix_t *buf = joinbuf; - int llen; - int hlen; - int twostep; - jpc_fix_t *tmpptr; - register jpc_fix_t *ptr; - register jpc_fix_t *hptr; - register jpc_fix_t *lptr; - register int n; - int state; - - twostep = step << 1; - llen = lendind - lstartind; - hlen = hendind - hstartind; - - if (hstartind < lstartind) { - /* The first sample in the highpass subband signal is to - appear first in the output signal. */ - /* Copy the appropriate samples into the first phase of the - output signal. */ - tmpptr = buf; - hptr = hstartptr; - ptr = startptr; - n = (llen + 1) >> 1; - while (n-- > 0) { - *tmpptr = *ptr; - *ptr = *hptr; - ++tmpptr; - ptr += twostep; - hptr += step; - } - n = hlen - ((llen + 1) >> 1); - while (n-- > 0) { - *ptr = *hptr; - ptr += twostep; - hptr += step; - } - /* Copy the appropriate samples into the second phase of - the output signal. */ - ptr -= (lendind > hendind) ? (step) : (step + twostep); - state = !((llen - 1) & 1); - lptr = &lstartptr[(llen - 1) * step]; - n = llen; - while (n-- > 0) { - if (state) { - --tmpptr; - *ptr = *tmpptr; - } else { - *ptr = *lptr; - } - lptr -= step; - ptr -= twostep; - state ^= 1; - } - } else { - /* The first sample in the lowpass subband signal is to - appear first in the output signal. */ - /* Copy the appropriate samples into the first phase of the - output signal (corresponding to even indexed samples). */ - lptr = &lstartptr[(llen - 1) * step]; - ptr = &startptr[((llen - 1) << 1) * step]; - n = llen >> 1; - tmpptr = buf; - while (n-- > 0) { - *tmpptr = *ptr; - *ptr = *lptr; - ++tmpptr; - ptr -= twostep; - lptr -= step; - } - n = llen - (llen >> 1); - while (n-- > 0) { - *ptr = *lptr; - ptr -= twostep; - lptr -= step; - } - /* Copy the appropriate samples into the second phase of - the output signal (corresponding to odd indexed - samples). */ - ptr = &startptr[step]; - hptr = hstartptr; - state = !(llen & 1); - n = hlen; - while (n-- > 0) { - if (state) { - --tmpptr; - *ptr = *tmpptr; - } else { - *ptr = *hptr; - } - hptr += step; - ptr += twostep; - state ^= 1; - } - } +#define QMFB_JOINBUFSIZE 4096 + jpc_fix_t joinbuf[QMFB_JOINBUFSIZE]; + jpc_fix_t *buf = joinbuf; + int llen; + int hlen; + int twostep; + jpc_fix_t *tmpptr; + register jpc_fix_t *ptr; + register jpc_fix_t *hptr; + register jpc_fix_t *lptr; + register int n; + int state; + + twostep = step << 1; + llen = lendind - lstartind; + hlen = hendind - hstartind; + + if (hstartind < lstartind) { + /* The first sample in the highpass subband signal is to + appear first in the output signal. */ + /* Copy the appropriate samples into the first phase of the + output signal. */ + tmpptr = buf; + hptr = hstartptr; + ptr = startptr; + n = (llen + 1) >> 1; + while (n-- > 0) { + *tmpptr = *ptr; + *ptr = *hptr; + ++tmpptr; + ptr += twostep; + hptr += step; + } + n = hlen - ((llen + 1) >> 1); + while (n-- > 0) { + *ptr = *hptr; + ptr += twostep; + hptr += step; + } + /* Copy the appropriate samples into the second phase of + the output signal. */ + ptr -= (lendind > hendind) ? (step) : (step + twostep); + state = !((llen - 1) & 1); + lptr = &lstartptr[(llen - 1) * step]; + n = llen; + while (n-- > 0) { + if (state) { + --tmpptr; + *ptr = *tmpptr; + } else { + *ptr = *lptr; + } + lptr -= step; + ptr -= twostep; + state ^= 1; + } + } else { + /* The first sample in the lowpass subband signal is to + appear first in the output signal. */ + /* Copy the appropriate samples into the first phase of the + output signal (corresponding to even indexed samples). */ + lptr = &lstartptr[(llen - 1) * step]; + ptr = &startptr[((llen - 1) << 1) * step]; + n = llen >> 1; + tmpptr = buf; + while (n-- > 0) { + *tmpptr = *ptr; + *ptr = *lptr; + ++tmpptr; + ptr -= twostep; + lptr -= step; + } + n = llen - (llen >> 1); + while (n-- > 0) { + *ptr = *lptr; + ptr -= twostep; + lptr -= step; + } + /* Copy the appropriate samples into the second phase of + the output signal (corresponding to odd indexed + samples). */ + ptr = &startptr[step]; + hptr = hstartptr; + state = !(llen & 1); + n = hlen; + while (n-- > 0) { + if (state) { + --tmpptr; + *ptr = *tmpptr; + } else { + *ptr = *hptr; + } + hptr += step; + ptr += twostep; + state ^= 1; + } + } } /******************************************************************************\ @@ -395,310 +395,310 @@ static void jpc_qmfb1d_join(jpc_fix_t *startptr, int startind, int endind, static int jpc_ft_getnumchans(jpc_qmfb1d_t *qmfb) { - return 2; + return 2; } static int jpc_ft_getanalfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters) { - abort(); - return -1; + abort(); + return -1; } static int jpc_ft_getsynfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters) { - jas_seq_t *lf; - jas_seq_t *hf; - - lf = 0; - hf = 0; - - if (len > 1 || (!len)) { - if (!(lf = jas_seq_create(-1, 2))) { - goto error; - } - jas_seq_set(lf, -1, jpc_dbltofix(0.5)); - jas_seq_set(lf, 0, jpc_dbltofix(1.0)); - jas_seq_set(lf, 1, jpc_dbltofix(0.5)); - if (!(hf = jas_seq_create(-1, 4))) { - goto error; - } - jas_seq_set(hf, -1, jpc_dbltofix(-0.125)); - jas_seq_set(hf, 0, jpc_dbltofix(-0.25)); - jas_seq_set(hf, 1, jpc_dbltofix(0.75)); - jas_seq_set(hf, 2, jpc_dbltofix(-0.25)); - jas_seq_set(hf, 3, jpc_dbltofix(-0.125)); - } else if (len == 1) { - if (!(lf = jas_seq_create(0, 1))) { - goto error; - } - jas_seq_set(lf, 0, jpc_dbltofix(1.0)); - if (!(hf = jas_seq_create(0, 1))) { - goto error; - } - jas_seq_set(hf, 0, jpc_dbltofix(2.0)); - } else { - abort(); - } - - filters[0] = lf; - filters[1] = hf; - - return 0; + jas_seq_t *lf; + jas_seq_t *hf; + + lf = 0; + hf = 0; + + if (len > 1 || (!len)) { + if (!(lf = jas_seq_create(-1, 2))) { + goto error; + } + jas_seq_set(lf, -1, jpc_dbltofix(0.5)); + jas_seq_set(lf, 0, jpc_dbltofix(1.0)); + jas_seq_set(lf, 1, jpc_dbltofix(0.5)); + if (!(hf = jas_seq_create(-1, 4))) { + goto error; + } + jas_seq_set(hf, -1, jpc_dbltofix(-0.125)); + jas_seq_set(hf, 0, jpc_dbltofix(-0.25)); + jas_seq_set(hf, 1, jpc_dbltofix(0.75)); + jas_seq_set(hf, 2, jpc_dbltofix(-0.25)); + jas_seq_set(hf, 3, jpc_dbltofix(-0.125)); + } else if (len == 1) { + if (!(lf = jas_seq_create(0, 1))) { + goto error; + } + jas_seq_set(lf, 0, jpc_dbltofix(1.0)); + if (!(hf = jas_seq_create(0, 1))) { + goto error; + } + jas_seq_set(hf, 0, jpc_dbltofix(2.0)); + } else { + abort(); + } + + filters[0] = lf; + filters[1] = hf; + + return 0; error: - if (lf) { - jas_seq_destroy(lf); - } - if (hf) { - jas_seq_destroy(hf); - } - return -1; + if (lf) { + jas_seq_destroy(lf); + } + if (hf) { + jas_seq_destroy(hf); + } + return -1; } -#define NFT_LIFT0(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, pluseq) \ +#define NFT_LIFT0(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, pluseq) \ { \ - register jpc_fix_t *lptr = (lstartptr); \ - register jpc_fix_t *hptr = (hstartptr); \ - register int n = (hendind) - (hstartind); \ - if ((hstartind) < (lstartind)) { \ - pluseq(*hptr, *lptr); \ - hptr += (step); \ - --n; \ - } \ - if ((hendind) >= (lendind)) { \ - --n; \ - } \ - while (n-- > 0) { \ - pluseq(*hptr, jpc_fix_asr(jpc_fix_add(*lptr, lptr[(step)]), 1)); \ - hptr += (step); \ - lptr += (step); \ - } \ - if ((hendind) >= (lendind)) { \ - pluseq(*hptr, *lptr); \ - } \ + register jpc_fix_t *lptr = (lstartptr); \ + register jpc_fix_t *hptr = (hstartptr); \ + register int n = (hendind) - (hstartind); \ + if ((hstartind) < (lstartind)) { \ + pluseq(*hptr, *lptr); \ + hptr += (step); \ + --n; \ + } \ + if ((hendind) >= (lendind)) { \ + --n; \ + } \ + while (n-- > 0) { \ + pluseq(*hptr, jpc_fix_asr(jpc_fix_add(*lptr, lptr[(step)]), 1)); \ + hptr += (step); \ + lptr += (step); \ + } \ + if ((hendind) >= (lendind)) { \ + pluseq(*hptr, *lptr); \ + } \ } -#define NFT_LIFT1(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, pluseq) \ +#define NFT_LIFT1(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, pluseq) \ { \ - register jpc_fix_t *lptr = (lstartptr); \ - register jpc_fix_t *hptr = (hstartptr); \ - register int n = (lendind) - (lstartind); \ - if ((hstartind) >= (lstartind)) { \ - pluseq(*lptr, *hptr); \ - lptr += (step); \ - --n; \ - } \ - if ((lendind) > (hendind)) { \ - --n; \ - } \ - while (n-- > 0) { \ - pluseq(*lptr, jpc_fix_asr(jpc_fix_add(*hptr, hptr[(step)]), 2)); \ - lptr += (step); \ - hptr += (step); \ - } \ - if ((lendind) > (hendind)) { \ - pluseq(*lptr, *hptr); \ - } \ + register jpc_fix_t *lptr = (lstartptr); \ + register jpc_fix_t *hptr = (hstartptr); \ + register int n = (lendind) - (lstartind); \ + if ((hstartind) >= (lstartind)) { \ + pluseq(*lptr, *hptr); \ + lptr += (step); \ + --n; \ + } \ + if ((lendind) > (hendind)) { \ + --n; \ + } \ + while (n-- > 0) { \ + pluseq(*lptr, jpc_fix_asr(jpc_fix_add(*hptr, hptr[(step)]), 2)); \ + lptr += (step); \ + hptr += (step); \ + } \ + if ((lendind) > (hendind)) { \ + pluseq(*lptr, *hptr); \ + } \ } -#define RFT_LIFT0(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, pmeqop) \ +#define RFT_LIFT0(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, pmeqop) \ { \ - register jpc_fix_t *lptr = (lstartptr); \ - register jpc_fix_t *hptr = (hstartptr); \ - register int n = (hendind) - (hstartind); \ - if ((hstartind) < (lstartind)) { \ - *hptr pmeqop *lptr; \ - hptr += (step); \ - --n; \ - } \ - if ((hendind) >= (lendind)) { \ - --n; \ - } \ - while (n-- > 0) { \ - *hptr pmeqop (*lptr + lptr[(step)]) >> 1; \ - hptr += (step); \ - lptr += (step); \ - } \ - if ((hendind) >= (lendind)) { \ - *hptr pmeqop *lptr; \ - } \ + register jpc_fix_t *lptr = (lstartptr); \ + register jpc_fix_t *hptr = (hstartptr); \ + register int n = (hendind) - (hstartind); \ + if ((hstartind) < (lstartind)) { \ + *hptr pmeqop *lptr; \ + hptr += (step); \ + --n; \ + } \ + if ((hendind) >= (lendind)) { \ + --n; \ + } \ + while (n-- > 0) { \ + *hptr pmeqop (*lptr + lptr[(step)]) >> 1; \ + hptr += (step); \ + lptr += (step); \ + } \ + if ((hendind) >= (lendind)) { \ + *hptr pmeqop *lptr; \ + } \ } -#define RFT_LIFT1(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, pmeqop) \ +#define RFT_LIFT1(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, pmeqop) \ { \ - register jpc_fix_t *lptr = (lstartptr); \ - register jpc_fix_t *hptr = (hstartptr); \ - register int n = (lendind) - (lstartind); \ - if ((hstartind) >= (lstartind)) { \ - *lptr pmeqop ((*hptr << 1) + 2) >> 2; \ - lptr += (step); \ - --n; \ - } \ - if ((lendind) > (hendind)) { \ - --n; \ - } \ - while (n-- > 0) { \ - *lptr pmeqop ((*hptr + hptr[(step)]) + 2) >> 2; \ - lptr += (step); \ - hptr += (step); \ - } \ - if ((lendind) > (hendind)) { \ - *lptr pmeqop ((*hptr << 1) + 2) >> 2; \ - } \ + register jpc_fix_t *lptr = (lstartptr); \ + register jpc_fix_t *hptr = (hstartptr); \ + register int n = (lendind) - (lstartind); \ + if ((hstartind) >= (lstartind)) { \ + *lptr pmeqop ((*hptr << 1) + 2) >> 2; \ + lptr += (step); \ + --n; \ + } \ + if ((lendind) > (hendind)) { \ + --n; \ + } \ + while (n-- > 0) { \ + *lptr pmeqop ((*hptr + hptr[(step)]) + 2) >> 2; \ + lptr += (step); \ + hptr += (step); \ + } \ + if ((lendind) > (hendind)) { \ + *lptr pmeqop ((*hptr << 1) + 2) >> 2; \ + } \ } static void jpc_ft_analyze(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x) { - jpc_fix_t *startptr; - int startind; - int endind; - jpc_fix_t * lstartptr; - int lstartind; - int lendind; - jpc_fix_t * hstartptr; - int hstartind; - int hendind; - int interstep; - int intrastep; - int numseq; - - if (flags & JPC_QMFB1D_VERT) { - interstep = 1; - intrastep = jas_seq2d_rowstep(x); - numseq = jas_seq2d_width(x); - startind = jas_seq2d_ystart(x); - endind = jas_seq2d_yend(x); - } else { - interstep = jas_seq2d_rowstep(x); - intrastep = 1; - numseq = jas_seq2d_height(x); - startind = jas_seq2d_xstart(x); - endind = jas_seq2d_xend(x); - } - - assert(startind < endind); - - startptr = jas_seq2d_getref(x, jas_seq2d_xstart(x), jas_seq2d_ystart(x)); - if (flags & JPC_QMFB1D_RITIMODE) { - while (numseq-- > 0) { - jpc_qmfb1d_setup(startptr, startind, endind, intrastep, - &lstartptr, &lstartind, &lendind, &hstartptr, - &hstartind, &hendind); - if (endind - startind > 1) { - jpc_qmfb1d_split(startptr, startind, endind, - intrastep, lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind); - RFT_LIFT0(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, -=); - RFT_LIFT1(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, +=); - } else { - if (lstartind == lendind) { - *startptr <<= 1; - } - } - startptr += interstep; - } - } else { - while (numseq-- > 0) { - jpc_qmfb1d_setup(startptr, startind, endind, intrastep, - &lstartptr, &lstartind, &lendind, &hstartptr, - &hstartind, &hendind); - if (endind - startind > 1) { - jpc_qmfb1d_split(startptr, startind, endind, - intrastep, lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind); - NFT_LIFT0(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, - jpc_fix_minuseq); - NFT_LIFT1(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, - jpc_fix_pluseq); - } else { - if (lstartind == lendind) { - *startptr = jpc_fix_asl(*startptr, 1); - } - } - startptr += interstep; - } - } + jpc_fix_t *startptr; + int startind; + int endind; + jpc_fix_t * lstartptr; + int lstartind; + int lendind; + jpc_fix_t * hstartptr; + int hstartind; + int hendind; + int interstep; + int intrastep; + int numseq; + + if (flags & JPC_QMFB1D_VERT) { + interstep = 1; + intrastep = jas_seq2d_rowstep(x); + numseq = jas_seq2d_width(x); + startind = jas_seq2d_ystart(x); + endind = jas_seq2d_yend(x); + } else { + interstep = jas_seq2d_rowstep(x); + intrastep = 1; + numseq = jas_seq2d_height(x); + startind = jas_seq2d_xstart(x); + endind = jas_seq2d_xend(x); + } + + assert(startind < endind); + + startptr = jas_seq2d_getref(x, jas_seq2d_xstart(x), jas_seq2d_ystart(x)); + if (flags & JPC_QMFB1D_RITIMODE) { + while (numseq-- > 0) { + jpc_qmfb1d_setup(startptr, startind, endind, intrastep, + &lstartptr, &lstartind, &lendind, &hstartptr, + &hstartind, &hendind); + if (endind - startind > 1) { + jpc_qmfb1d_split(startptr, startind, endind, + intrastep, lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind); + RFT_LIFT0(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, -=); + RFT_LIFT1(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, +=); + } else { + if (lstartind == lendind) { + *startptr <<= 1; + } + } + startptr += interstep; + } + } else { + while (numseq-- > 0) { + jpc_qmfb1d_setup(startptr, startind, endind, intrastep, + &lstartptr, &lstartind, &lendind, &hstartptr, + &hstartind, &hendind); + if (endind - startind > 1) { + jpc_qmfb1d_split(startptr, startind, endind, + intrastep, lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind); + NFT_LIFT0(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, + jpc_fix_minuseq); + NFT_LIFT1(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, + jpc_fix_pluseq); + } else { + if (lstartind == lendind) { + *startptr = jpc_fix_asl(*startptr, 1); + } + } + startptr += interstep; + } + } } static void jpc_ft_synthesize(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x) { - jpc_fix_t *startptr; - int startind; - int endind; - jpc_fix_t *lstartptr; - int lstartind; - int lendind; - jpc_fix_t *hstartptr; - int hstartind; - int hendind; - int interstep; - int intrastep; - int numseq; - - if (flags & JPC_QMFB1D_VERT) { - interstep = 1; - intrastep = jas_seq2d_rowstep(x); - numseq = jas_seq2d_width(x); - startind = jas_seq2d_ystart(x); - endind = jas_seq2d_yend(x); - } else { - interstep = jas_seq2d_rowstep(x); - intrastep = 1; - numseq = jas_seq2d_height(x); - startind = jas_seq2d_xstart(x); - endind = jas_seq2d_xend(x); - } - - assert(startind < endind); - - startptr = jas_seq2d_getref(x, jas_seq2d_xstart(x), jas_seq2d_ystart(x)); - if (flags & JPC_QMFB1D_RITIMODE) { - while (numseq-- > 0) { - jpc_qmfb1d_setup(startptr, startind, endind, intrastep, - &lstartptr, &lstartind, &lendind, &hstartptr, - &hstartind, &hendind); - if (endind - startind > 1) { - RFT_LIFT1(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, -=); - RFT_LIFT0(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, +=); - jpc_qmfb1d_join(startptr, startind, endind, - intrastep, lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind); - } else { - if (lstartind == lendind) { - *startptr >>= 1; - } - } - startptr += interstep; - } - } else { - while (numseq-- > 0) { - jpc_qmfb1d_setup(startptr, startind, endind, intrastep, - &lstartptr, &lstartind, &lendind, &hstartptr, - &hstartind, &hendind); - if (endind - startind > 1) { - NFT_LIFT1(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, - jpc_fix_minuseq); - NFT_LIFT0(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, - jpc_fix_pluseq); - jpc_qmfb1d_join(startptr, startind, endind, - intrastep, lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind); - } else { - if (lstartind == lendind) { - *startptr = jpc_fix_asr(*startptr, 1); - } - } - startptr += interstep; - } - } + jpc_fix_t *startptr; + int startind; + int endind; + jpc_fix_t *lstartptr; + int lstartind; + int lendind; + jpc_fix_t *hstartptr; + int hstartind; + int hendind; + int interstep; + int intrastep; + int numseq; + + if (flags & JPC_QMFB1D_VERT) { + interstep = 1; + intrastep = jas_seq2d_rowstep(x); + numseq = jas_seq2d_width(x); + startind = jas_seq2d_ystart(x); + endind = jas_seq2d_yend(x); + } else { + interstep = jas_seq2d_rowstep(x); + intrastep = 1; + numseq = jas_seq2d_height(x); + startind = jas_seq2d_xstart(x); + endind = jas_seq2d_xend(x); + } + + assert(startind < endind); + + startptr = jas_seq2d_getref(x, jas_seq2d_xstart(x), jas_seq2d_ystart(x)); + if (flags & JPC_QMFB1D_RITIMODE) { + while (numseq-- > 0) { + jpc_qmfb1d_setup(startptr, startind, endind, intrastep, + &lstartptr, &lstartind, &lendind, &hstartptr, + &hstartind, &hendind); + if (endind - startind > 1) { + RFT_LIFT1(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, -=); + RFT_LIFT0(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, +=); + jpc_qmfb1d_join(startptr, startind, endind, + intrastep, lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind); + } else { + if (lstartind == lendind) { + *startptr >>= 1; + } + } + startptr += interstep; + } + } else { + while (numseq-- > 0) { + jpc_qmfb1d_setup(startptr, startind, endind, intrastep, + &lstartptr, &lstartind, &lendind, &hstartptr, + &hstartind, &hendind); + if (endind - startind > 1) { + NFT_LIFT1(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, + jpc_fix_minuseq); + NFT_LIFT0(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, + jpc_fix_pluseq); + jpc_qmfb1d_join(startptr, startind, endind, + intrastep, lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind); + } else { + if (lstartind == lendind) { + *startptr = jpc_fix_asr(*startptr, 1); + } + } + startptr += interstep; + } + } } /******************************************************************************\ @@ -707,276 +707,276 @@ static void jpc_ft_synthesize(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x) static int jpc_ns_getnumchans(jpc_qmfb1d_t *qmfb) { - return 2; + return 2; } static int jpc_ns_getanalfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters) { - abort(); - return -1; + abort(); + return -1; } static int jpc_ns_getsynfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters) { - jas_seq_t *lf; - jas_seq_t *hf; - - lf = 0; - hf = 0; - - if (len > 1 || (!len)) { - if (!(lf = jas_seq_create(-3, 4))) { - goto error; - } - jas_seq_set(lf, -3, jpc_dbltofix(-0.09127176311424948)); - jas_seq_set(lf, -2, jpc_dbltofix(-0.05754352622849957)); - jas_seq_set(lf, -1, jpc_dbltofix(0.5912717631142470)); - jas_seq_set(lf, 0, jpc_dbltofix(1.115087052456994)); - jas_seq_set(lf, 1, jpc_dbltofix(0.5912717631142470)); - jas_seq_set(lf, 2, jpc_dbltofix(-0.05754352622849957)); - jas_seq_set(lf, 3, jpc_dbltofix(-0.09127176311424948)); - if (!(hf = jas_seq_create(-3, 6))) { - goto error; - } - jas_seq_set(hf, -3, jpc_dbltofix(-0.02674875741080976 * 2.0)); - jas_seq_set(hf, -2, jpc_dbltofix(-0.01686411844287495 * 2.0)); - jas_seq_set(hf, -1, jpc_dbltofix(0.07822326652898785 * 2.0)); - jas_seq_set(hf, 0, jpc_dbltofix(0.2668641184428723 * 2.0)); - jas_seq_set(hf, 1, jpc_dbltofix(-0.6029490182363579 * 2.0)); - jas_seq_set(hf, 2, jpc_dbltofix(0.2668641184428723 * 2.0)); - jas_seq_set(hf, 3, jpc_dbltofix(0.07822326652898785 * 2.0)); - jas_seq_set(hf, 4, jpc_dbltofix(-0.01686411844287495 * 2.0)); - jas_seq_set(hf, 5, jpc_dbltofix(-0.02674875741080976 * 2.0)); - } else if (len == 1) { - if (!(lf = jas_seq_create(0, 1))) { - goto error; - } - jas_seq_set(lf, 0, jpc_dbltofix(1.0)); - if (!(hf = jas_seq_create(0, 1))) { - goto error; - } - jas_seq_set(hf, 0, jpc_dbltofix(2.0)); - } else { - abort(); - } - - filters[0] = lf; - filters[1] = hf; - - return 0; + jas_seq_t *lf; + jas_seq_t *hf; + + lf = 0; + hf = 0; + + if (len > 1 || (!len)) { + if (!(lf = jas_seq_create(-3, 4))) { + goto error; + } + jas_seq_set(lf, -3, jpc_dbltofix(-0.09127176311424948)); + jas_seq_set(lf, -2, jpc_dbltofix(-0.05754352622849957)); + jas_seq_set(lf, -1, jpc_dbltofix(0.5912717631142470)); + jas_seq_set(lf, 0, jpc_dbltofix(1.115087052456994)); + jas_seq_set(lf, 1, jpc_dbltofix(0.5912717631142470)); + jas_seq_set(lf, 2, jpc_dbltofix(-0.05754352622849957)); + jas_seq_set(lf, 3, jpc_dbltofix(-0.09127176311424948)); + if (!(hf = jas_seq_create(-3, 6))) { + goto error; + } + jas_seq_set(hf, -3, jpc_dbltofix(-0.02674875741080976 * 2.0)); + jas_seq_set(hf, -2, jpc_dbltofix(-0.01686411844287495 * 2.0)); + jas_seq_set(hf, -1, jpc_dbltofix(0.07822326652898785 * 2.0)); + jas_seq_set(hf, 0, jpc_dbltofix(0.2668641184428723 * 2.0)); + jas_seq_set(hf, 1, jpc_dbltofix(-0.6029490182363579 * 2.0)); + jas_seq_set(hf, 2, jpc_dbltofix(0.2668641184428723 * 2.0)); + jas_seq_set(hf, 3, jpc_dbltofix(0.07822326652898785 * 2.0)); + jas_seq_set(hf, 4, jpc_dbltofix(-0.01686411844287495 * 2.0)); + jas_seq_set(hf, 5, jpc_dbltofix(-0.02674875741080976 * 2.0)); + } else if (len == 1) { + if (!(lf = jas_seq_create(0, 1))) { + goto error; + } + jas_seq_set(lf, 0, jpc_dbltofix(1.0)); + if (!(hf = jas_seq_create(0, 1))) { + goto error; + } + jas_seq_set(hf, 0, jpc_dbltofix(2.0)); + } else { + abort(); + } + + filters[0] = lf; + filters[1] = hf; + + return 0; error: - if (lf) { - jas_seq_destroy(lf); - } - if (hf) { - jas_seq_destroy(hf); - } - return -1; + if (lf) { + jas_seq_destroy(lf); + } + if (hf) { + jas_seq_destroy(hf); + } + return -1; } -#define NNS_LIFT0(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, alpha) \ +#define NNS_LIFT0(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, alpha) \ { \ - register jpc_fix_t *lptr = (lstartptr); \ - register jpc_fix_t *hptr = (hstartptr); \ - register int n = (hendind) - (hstartind); \ - jpc_fix_t twoalpha = jpc_fix_mulbyint(alpha, 2); \ - if ((hstartind) < (lstartind)) { \ - jpc_fix_pluseq(*hptr, jpc_fix_mul(*lptr, (twoalpha))); \ - hptr += (step); \ - --n; \ - } \ - if ((hendind) >= (lendind)) { \ - --n; \ - } \ - while (n-- > 0) { \ - jpc_fix_pluseq(*hptr, jpc_fix_mul(jpc_fix_add(*lptr, lptr[(step)]), (alpha))); \ - hptr += (step); \ - lptr += (step); \ - } \ - if ((hendind) >= (lendind)) { \ - jpc_fix_pluseq(*hptr, jpc_fix_mul(*lptr, (twoalpha))); \ - } \ + register jpc_fix_t *lptr = (lstartptr); \ + register jpc_fix_t *hptr = (hstartptr); \ + register int n = (hendind) - (hstartind); \ + jpc_fix_t twoalpha = jpc_fix_mulbyint(alpha, 2); \ + if ((hstartind) < (lstartind)) { \ + jpc_fix_pluseq(*hptr, jpc_fix_mul(*lptr, (twoalpha))); \ + hptr += (step); \ + --n; \ + } \ + if ((hendind) >= (lendind)) { \ + --n; \ + } \ + while (n-- > 0) { \ + jpc_fix_pluseq(*hptr, jpc_fix_mul(jpc_fix_add(*lptr, lptr[(step)]), (alpha))); \ + hptr += (step); \ + lptr += (step); \ + } \ + if ((hendind) >= (lendind)) { \ + jpc_fix_pluseq(*hptr, jpc_fix_mul(*lptr, (twoalpha))); \ + } \ } -#define NNS_LIFT1(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, alpha) \ +#define NNS_LIFT1(lstartptr, lstartind, lendind, hstartptr, hstartind, hendind, step, alpha) \ { \ - register jpc_fix_t *lptr = (lstartptr); \ - register jpc_fix_t *hptr = (hstartptr); \ - register int n = (lendind) - (lstartind); \ - int twoalpha = jpc_fix_mulbyint(alpha, 2); \ - if ((hstartind) >= (lstartind)) { \ - jpc_fix_pluseq(*lptr, jpc_fix_mul(*hptr, (twoalpha))); \ - lptr += (step); \ - --n; \ - } \ - if ((lendind) > (hendind)) { \ - --n; \ - } \ - while (n-- > 0) { \ - jpc_fix_pluseq(*lptr, jpc_fix_mul(jpc_fix_add(*hptr, hptr[(step)]), (alpha))); \ - lptr += (step); \ - hptr += (step); \ - } \ - if ((lendind) > (hendind)) { \ - jpc_fix_pluseq(*lptr, jpc_fix_mul(*hptr, (twoalpha))); \ - } \ + register jpc_fix_t *lptr = (lstartptr); \ + register jpc_fix_t *hptr = (hstartptr); \ + register int n = (lendind) - (lstartind); \ + int twoalpha = jpc_fix_mulbyint(alpha, 2); \ + if ((hstartind) >= (lstartind)) { \ + jpc_fix_pluseq(*lptr, jpc_fix_mul(*hptr, (twoalpha))); \ + lptr += (step); \ + --n; \ + } \ + if ((lendind) > (hendind)) { \ + --n; \ + } \ + while (n-- > 0) { \ + jpc_fix_pluseq(*lptr, jpc_fix_mul(jpc_fix_add(*hptr, hptr[(step)]), (alpha))); \ + lptr += (step); \ + hptr += (step); \ + } \ + if ((lendind) > (hendind)) { \ + jpc_fix_pluseq(*lptr, jpc_fix_mul(*hptr, (twoalpha))); \ + } \ } -#define NNS_SCALE(startptr, startind, endind, step, alpha) \ +#define NNS_SCALE(startptr, startind, endind, step, alpha) \ { \ - register jpc_fix_t *ptr = (startptr); \ - register int n = (endind) - (startind); \ - while (n-- > 0) { \ - jpc_fix_muleq(*ptr, alpha); \ - ptr += (step); \ - } \ + register jpc_fix_t *ptr = (startptr); \ + register int n = (endind) - (startind); \ + while (n-- > 0) { \ + jpc_fix_muleq(*ptr, alpha); \ + ptr += (step); \ + } \ } static void jpc_ns_analyze(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x) { - jpc_fix_t *startptr; - int startind; - int endind; - jpc_fix_t *lstartptr; - int lstartind; - int lendind; - jpc_fix_t *hstartptr; - int hstartind; - int hendind; - int interstep; - int intrastep; - int numseq; - - if (flags & JPC_QMFB1D_VERT) { - interstep = 1; - intrastep = jas_seq2d_rowstep(x); - numseq = jas_seq2d_width(x); - startind = jas_seq2d_ystart(x); - endind = jas_seq2d_yend(x); - } else { - interstep = jas_seq2d_rowstep(x); - intrastep = 1; - numseq = jas_seq2d_height(x); - startind = jas_seq2d_xstart(x); - endind = jas_seq2d_xend(x); - } - - assert(startind < endind); - - startptr = jas_seq2d_getref(x, jas_seq2d_xstart(x), jas_seq2d_ystart(x)); - if (!(flags & JPC_QMFB1D_RITIMODE)) { - while (numseq-- > 0) { - jpc_qmfb1d_setup(startptr, startind, endind, intrastep, - &lstartptr, &lstartind, &lendind, &hstartptr, - &hstartind, &hendind); - if (endind - startind > 1) { - jpc_qmfb1d_split(startptr, startind, endind, - intrastep, lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind); - NNS_LIFT0(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, - jpc_dbltofix(-1.586134342)); - NNS_LIFT1(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, - jpc_dbltofix(-0.052980118)); - NNS_LIFT0(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, - jpc_dbltofix(0.882911075)); - NNS_LIFT1(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, - jpc_dbltofix(0.443506852)); - NNS_SCALE(lstartptr, lstartind, lendind, - intrastep, jpc_dbltofix(1.0/1.23017410558578)); - NNS_SCALE(hstartptr, hstartind, hendind, - intrastep, jpc_dbltofix(1.0/1.62578613134411)); - } else { + jpc_fix_t *startptr; + int startind; + int endind; + jpc_fix_t *lstartptr; + int lstartind; + int lendind; + jpc_fix_t *hstartptr; + int hstartind; + int hendind; + int interstep; + int intrastep; + int numseq; + + if (flags & JPC_QMFB1D_VERT) { + interstep = 1; + intrastep = jas_seq2d_rowstep(x); + numseq = jas_seq2d_width(x); + startind = jas_seq2d_ystart(x); + endind = jas_seq2d_yend(x); + } else { + interstep = jas_seq2d_rowstep(x); + intrastep = 1; + numseq = jas_seq2d_height(x); + startind = jas_seq2d_xstart(x); + endind = jas_seq2d_xend(x); + } + + assert(startind < endind); + + startptr = jas_seq2d_getref(x, jas_seq2d_xstart(x), jas_seq2d_ystart(x)); + if (!(flags & JPC_QMFB1D_RITIMODE)) { + while (numseq-- > 0) { + jpc_qmfb1d_setup(startptr, startind, endind, intrastep, + &lstartptr, &lstartind, &lendind, &hstartptr, + &hstartind, &hendind); + if (endind - startind > 1) { + jpc_qmfb1d_split(startptr, startind, endind, + intrastep, lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind); + NNS_LIFT0(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, + jpc_dbltofix(-1.586134342)); + NNS_LIFT1(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, + jpc_dbltofix(-0.052980118)); + NNS_LIFT0(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, + jpc_dbltofix(0.882911075)); + NNS_LIFT1(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, + jpc_dbltofix(0.443506852)); + NNS_SCALE(lstartptr, lstartind, lendind, + intrastep, jpc_dbltofix(1.0/1.23017410558578)); + NNS_SCALE(hstartptr, hstartind, hendind, + intrastep, jpc_dbltofix(1.0/1.62578613134411)); + } else { #if 0 - if (lstartind == lendind) { - *startptr = jpc_fix_asl(*startptr, 1); - } + if (lstartind == lendind) { + *startptr = jpc_fix_asl(*startptr, 1); + } #endif - } - startptr += interstep; - } - } else { - /* The reversible integer-to-integer mode is not valid for this - transform. */ - abort(); - } + } + startptr += interstep; + } + } else { + /* The reversible integer-to-integer mode is not valid for this + transform. */ + abort(); + } } static void jpc_ns_synthesize(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x) { - jpc_fix_t *startptr; - int startind; - int endind; - jpc_fix_t *lstartptr; - int lstartind; - int lendind; - jpc_fix_t *hstartptr; - int hstartind; - int hendind; - int interstep; - int intrastep; - int numseq; - - if (flags & JPC_QMFB1D_VERT) { - interstep = 1; - intrastep = jas_seq2d_rowstep(x); - numseq = jas_seq2d_width(x); - startind = jas_seq2d_ystart(x); - endind = jas_seq2d_yend(x); - } else { - interstep = jas_seq2d_rowstep(x); - intrastep = 1; - numseq = jas_seq2d_height(x); - startind = jas_seq2d_xstart(x); - endind = jas_seq2d_xend(x); - } - - assert(startind < endind); - - startptr = jas_seq2d_getref(x, jas_seq2d_xstart(x), jas_seq2d_ystart(x)); - if (!(flags & JPC_QMFB1D_RITIMODE)) { - while (numseq-- > 0) { - jpc_qmfb1d_setup(startptr, startind, endind, intrastep, - &lstartptr, &lstartind, &lendind, &hstartptr, - &hstartind, &hendind); - if (endind - startind > 1) { - NNS_SCALE(lstartptr, lstartind, lendind, - intrastep, jpc_dbltofix(1.23017410558578)); - NNS_SCALE(hstartptr, hstartind, hendind, - intrastep, jpc_dbltofix(1.62578613134411)); - NNS_LIFT1(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, - jpc_dbltofix(-0.443506852)); - NNS_LIFT0(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, - jpc_dbltofix(-0.882911075)); - NNS_LIFT1(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, - jpc_dbltofix(0.052980118)); - NNS_LIFT0(lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind, intrastep, - jpc_dbltofix(1.586134342)); - jpc_qmfb1d_join(startptr, startind, endind, - intrastep, lstartptr, lstartind, lendind, - hstartptr, hstartind, hendind); - } else { + jpc_fix_t *startptr; + int startind; + int endind; + jpc_fix_t *lstartptr; + int lstartind; + int lendind; + jpc_fix_t *hstartptr; + int hstartind; + int hendind; + int interstep; + int intrastep; + int numseq; + + if (flags & JPC_QMFB1D_VERT) { + interstep = 1; + intrastep = jas_seq2d_rowstep(x); + numseq = jas_seq2d_width(x); + startind = jas_seq2d_ystart(x); + endind = jas_seq2d_yend(x); + } else { + interstep = jas_seq2d_rowstep(x); + intrastep = 1; + numseq = jas_seq2d_height(x); + startind = jas_seq2d_xstart(x); + endind = jas_seq2d_xend(x); + } + + assert(startind < endind); + + startptr = jas_seq2d_getref(x, jas_seq2d_xstart(x), jas_seq2d_ystart(x)); + if (!(flags & JPC_QMFB1D_RITIMODE)) { + while (numseq-- > 0) { + jpc_qmfb1d_setup(startptr, startind, endind, intrastep, + &lstartptr, &lstartind, &lendind, &hstartptr, + &hstartind, &hendind); + if (endind - startind > 1) { + NNS_SCALE(lstartptr, lstartind, lendind, + intrastep, jpc_dbltofix(1.23017410558578)); + NNS_SCALE(hstartptr, hstartind, hendind, + intrastep, jpc_dbltofix(1.62578613134411)); + NNS_LIFT1(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, + jpc_dbltofix(-0.443506852)); + NNS_LIFT0(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, + jpc_dbltofix(-0.882911075)); + NNS_LIFT1(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, + jpc_dbltofix(0.052980118)); + NNS_LIFT0(lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind, intrastep, + jpc_dbltofix(1.586134342)); + jpc_qmfb1d_join(startptr, startind, endind, + intrastep, lstartptr, lstartind, lendind, + hstartptr, hstartind, hendind); + } else { #if 0 - if (lstartind == lendind) { - *startptr = jpc_fix_asr(*startptr, 1); - } + if (lstartind == lendind) { + *startptr = jpc_fix_asr(*startptr, 1); + } #endif - } - startptr += interstep; - } - } else { - /* The reversible integer-to-integer mode is not valid + } + startptr += interstep; + } + } else { + /* The reversible integer-to-integer mode is not valid for this transform. */ - abort(); - } + abort(); + } } /******************************************************************************\ @@ -985,49 +985,49 @@ static void jpc_ns_synthesize(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x) jpc_qmfb1d_t *jpc_qmfb1d_make(int qmfbid) { - jpc_qmfb1d_t *qmfb; - if (!(qmfb = jpc_qmfb1d_create())) { - return 0; - } - switch (qmfbid) { - case JPC_QMFB1D_FT: - qmfb->ops = &jpc_ft_ops; - break; - case JPC_QMFB1D_NS: - qmfb->ops = &jpc_ns_ops; - break; - default: - jpc_qmfb1d_destroy(qmfb); - return 0; - break; - } - return qmfb; + jpc_qmfb1d_t *qmfb; + if (!(qmfb = jpc_qmfb1d_create())) { + return 0; + } + switch (qmfbid) { + case JPC_QMFB1D_FT: + qmfb->ops = &jpc_ft_ops; + break; + case JPC_QMFB1D_NS: + qmfb->ops = &jpc_ns_ops; + break; + default: + jpc_qmfb1d_destroy(qmfb); + return 0; + break; + } + return qmfb; } static jpc_qmfb1d_t *jpc_qmfb1d_create() { - jpc_qmfb1d_t *qmfb; - if (!(qmfb = jas_malloc(sizeof(jpc_qmfb1d_t)))) { - return 0; - } - qmfb->ops = 0; - return qmfb; + jpc_qmfb1d_t *qmfb; + if (!(qmfb = jas_malloc(sizeof(jpc_qmfb1d_t)))) { + return 0; + } + qmfb->ops = 0; + return qmfb; } jpc_qmfb1d_t *jpc_qmfb1d_copy(jpc_qmfb1d_t *qmfb) { - jpc_qmfb1d_t *newqmfb; + jpc_qmfb1d_t *newqmfb; - if (!(newqmfb = jpc_qmfb1d_create())) { - return 0; - } - newqmfb->ops = qmfb->ops; - return newqmfb; + if (!(newqmfb = jpc_qmfb1d_create())) { + return 0; + } + newqmfb->ops = qmfb->ops; + return newqmfb; } void jpc_qmfb1d_destroy(jpc_qmfb1d_t *qmfb) { - jas_free(qmfb); + jas_free(qmfb); } /******************************************************************************\ @@ -1038,27 +1038,27 @@ void jpc_qmfb1d_getbands(jpc_qmfb1d_t *qmfb, int flags, uint_fast32_t xstart, uint_fast32_t ystart, uint_fast32_t xend, uint_fast32_t yend, int maxbands, int *numbandsptr, jpc_qmfb1dband_t *bands) { - int start; - int end; - if (flags & JPC_QMFB1D_VERT) { - start = ystart; - end = yend; - } else { - start = xstart; - end = xend; - } - assert(jpc_qmfb1d_getnumchans(qmfb) == 2); - assert(start <= end); - bands[0].start = JPC_CEILDIVPOW2(start, 1); - bands[0].end = JPC_CEILDIVPOW2(end, 1); - bands[0].locstart = start; - bands[0].locend = start + bands[0].end - bands[0].start; - bands[1].start = JPC_FLOORDIVPOW2(start, 1); - bands[1].end = JPC_FLOORDIVPOW2(end, 1); - bands[1].locstart = bands[0].locend; - bands[1].locend = bands[1].locstart + bands[1].end - bands[1].start; - assert(bands[1].locend == end); - *numbandsptr = 2; + int start; + int end; + if (flags & JPC_QMFB1D_VERT) { + start = ystart; + end = yend; + } else { + start = xstart; + end = xend; + } + assert(jpc_qmfb1d_getnumchans(qmfb) == 2); + assert(start <= end); + bands[0].start = JPC_CEILDIVPOW2(start, 1); + bands[0].end = JPC_CEILDIVPOW2(end, 1); + bands[0].locstart = start; + bands[0].locend = start + bands[0].end - bands[0].start; + bands[1].start = JPC_FLOORDIVPOW2(start, 1); + bands[1].end = JPC_FLOORDIVPOW2(end, 1); + bands[1].locstart = bands[0].locend; + bands[1].locend = bands[1].locstart + bands[1].end - bands[1].start; + assert(bands[1].locend == end); + *numbandsptr = 2; } /******************************************************************************\ @@ -1067,25 +1067,25 @@ void jpc_qmfb1d_getbands(jpc_qmfb1d_t *qmfb, int flags, uint_fast32_t xstart, int jpc_qmfb1d_getnumchans(jpc_qmfb1d_t *qmfb) { - return (*qmfb->ops->getnumchans)(qmfb); + return (*qmfb->ops->getnumchans)(qmfb); } int jpc_qmfb1d_getanalfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters) { - return (*qmfb->ops->getanalfilters)(qmfb, len, filters); + return (*qmfb->ops->getanalfilters)(qmfb, len, filters); } int jpc_qmfb1d_getsynfilters(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters) { - return (*qmfb->ops->getsynfilters)(qmfb, len, filters); + return (*qmfb->ops->getsynfilters)(qmfb, len, filters); } void jpc_qmfb1d_analyze(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x) { - (*qmfb->ops->analyze)(qmfb, flags, x); + (*qmfb->ops->analyze)(qmfb, flags, x); } void jpc_qmfb1d_synthesize(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x) { - (*qmfb->ops->synthesize)(qmfb, flags, x); + (*qmfb->ops->synthesize)(qmfb, flags, x); } diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_qmfb.h b/converter/other/jpeg2000/libjasper/jpc/jpc_qmfb.h index e10b6c13..fb46965b 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_qmfb.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_qmfb.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -130,17 +130,17 @@ \******************************************************************************/ /* The maximum number of channels for a QMF bank. */ -#define JPC_QMFB1D_MAXCHANS 2 +#define JPC_QMFB1D_MAXCHANS 2 /* Select reversible integer-to-integer mode. */ -#define JPC_QMFB1D_RITIMODE 1 +#define JPC_QMFB1D_RITIMODE 1 /* Vertical filtering. */ -#define JPC_QMFB1D_VERT 0x10000 +#define JPC_QMFB1D_VERT 0x10000 /* QMFB IDs. */ -#define JPC_QMFB1D_FT 1 /* 5/3 */ -#define JPC_QMFB1D_NS 2 /* 9/7 */ +#define JPC_QMFB1D_FT 1 /* 5/3 */ +#define JPC_QMFB1D_NS 2 /* 9/7 */ /******************************************************************************\ * Types. @@ -153,17 +153,17 @@ struct jpc_qmfb1dops_s; typedef struct { - /* The starting index for the band in the downsampled domain. */ - int start; + /* The starting index for the band in the downsampled domain. */ + int start; - /* The ending index for the band in the downsampled domain. */ - int end; + /* The ending index for the band in the downsampled domain. */ + int end; - /* The location of the start of the band. */ - int locstart; + /* The location of the start of the band. */ + int locstart; - /* The location of the end of the band. */ - int locend; + /* The location of the end of the band. */ + int locend; } jpc_qmfb1dband_t; @@ -171,8 +171,8 @@ typedef struct { typedef struct { - /* The operations for this QMFB. */ - struct jpc_qmfb1dops_s *ops; + /* The operations for this QMFB. */ + struct jpc_qmfb1dops_s *ops; } jpc_qmfb1d_t; @@ -180,20 +180,20 @@ typedef struct { typedef struct jpc_qmfb1dops_s { - /* The number of channels in the QMFB. */ - int (*getnumchans)(jpc_qmfb1d_t *qmfb); + /* The number of channels in the QMFB. */ + int (*getnumchans)(jpc_qmfb1d_t *qmfb); - /* Get the analysis filters for this QMFB. */ - int (*getanalfilters)(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters); + /* Get the analysis filters for this QMFB. */ + int (*getanalfilters)(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters); - /* Get the synthesis filters for this QMFB. */ - int (*getsynfilters)(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters); + /* Get the synthesis filters for this QMFB. */ + int (*getsynfilters)(jpc_qmfb1d_t *qmfb, int len, jas_seq2d_t **filters); - /* Do analysis. */ - void (*analyze)(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x); + /* Do analysis. */ + void (*analyze)(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x); - /* Do synthesis. */ - void (*synthesize)(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x); + /* Do synthesis. */ + void (*synthesize)(jpc_qmfb1d_t *qmfb, int flags, jas_seq2d_t *x); } jpc_qmfb1dops_t; diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_t1cod.c b/converter/other/jpeg2000/libjasper/jpc/jpc_t1cod.c index 650cb854..ed188154 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_t1cod.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_t1cod.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -157,46 +157,46 @@ jpc_mqctx_t jpc_mqctxs[JPC_NUMCTXS]; int JPC_PASSTYPE(int passno) { - int passtype; - switch (passno % 3) { - case 0: - passtype = JPC_CLNPASS; - break; - case 1: - passtype = JPC_SIGPASS; - break; - case 2: - passtype = JPC_REFPASS; - break; - default: - passtype = -1; - assert(0); - break; - } - return passtype; + int passtype; + switch (passno % 3) { + case 0: + passtype = JPC_CLNPASS; + break; + case 1: + passtype = JPC_SIGPASS; + break; + case 2: + passtype = JPC_REFPASS; + break; + default: + passtype = -1; + assert(0); + break; + } + return passtype; } int JPC_NOMINALGAIN(int qmfbid, int numlvls, int lvlno, int orient) { if (qmfbid == JPC_COX_INS) { - return 0; + return 0; } - assert(qmfbid == JPC_COX_RFT); - if (lvlno == 0) { - assert(orient == JPC_TSFB_LL); - return 0; - } else { - switch (orient) { - case JPC_TSFB_LH: - case JPC_TSFB_HL: - return 1; - break; - case JPC_TSFB_HH: - return 2; - break; - } - } - abort(); + assert(qmfbid == JPC_COX_RFT); + if (lvlno == 0) { + assert(orient == JPC_TSFB_LL); + return 0; + } else { + switch (orient) { + case JPC_TSFB_LH: + case JPC_TSFB_HL: + return 1; + break; + case JPC_TSFB_HH: + return 2; + break; + } + } + abort(); } /******************************************************************************\ @@ -205,66 +205,66 @@ if (qmfbid == JPC_COX_INS) { int JPC_SEGTYPE(int passno, int firstpassno, int bypass) { - int passtype; - if (bypass) { - passtype = JPC_PASSTYPE(passno); - if (passtype == JPC_CLNPASS) { - return JPC_SEG_MQ; - } - return ((passno < firstpassno + 10) ? JPC_SEG_MQ : JPC_SEG_RAW); - } else { - return JPC_SEG_MQ; - } + int passtype; + if (bypass) { + passtype = JPC_PASSTYPE(passno); + if (passtype == JPC_CLNPASS) { + return JPC_SEG_MQ; + } + return ((passno < firstpassno + 10) ? JPC_SEG_MQ : JPC_SEG_RAW); + } else { + return JPC_SEG_MQ; + } } int JPC_SEGPASSCNT(int passno, int firstpassno, int numpasses, int bypass, int termall) { - int ret; - int passtype; - - if (termall) { - ret = 1; - } else if (bypass) { - if (passno < firstpassno + 10) { - ret = 10 - (passno - firstpassno); - } else { - passtype = JPC_PASSTYPE(passno); - switch (passtype) { - case JPC_SIGPASS: - ret = 2; - break; - case JPC_REFPASS: - ret = 1; - break; - case JPC_CLNPASS: - ret = 1; - break; - default: - ret = -1; - assert(0); - break; - } - } - } else { - ret = JPC_PREC * 3 - 2; - } - ret = JAS_MIN(ret, numpasses - passno); - return ret; + int ret; + int passtype; + + if (termall) { + ret = 1; + } else if (bypass) { + if (passno < firstpassno + 10) { + ret = 10 - (passno - firstpassno); + } else { + passtype = JPC_PASSTYPE(passno); + switch (passtype) { + case JPC_SIGPASS: + ret = 2; + break; + case JPC_REFPASS: + ret = 1; + break; + case JPC_CLNPASS: + ret = 1; + break; + default: + ret = -1; + assert(0); + break; + } + } + } else { + ret = JPC_PREC * 3 - 2; + } + ret = JAS_MIN(ret, numpasses - passno); + return ret; } int JPC_ISTERMINATED(int passno, int firstpassno, int numpasses, int termall, int lazy) { - int ret; - int n; - if (passno - firstpassno == numpasses - 1) { - ret = 1; - } else { - n = JPC_SEGPASSCNT(passno, firstpassno, numpasses, lazy, termall); - ret = (n <= 1) ? 1 : 0; - } - - return ret; + int ret; + int n; + if (passno - firstpassno == numpasses - 1) { + ret = 1; + } else { + n = JPC_SEGPASSCNT(passno, firstpassno, numpasses, lazy, termall); + ret = (n <= 1) ? 1 : 0; + } + + return ret; } /******************************************************************************\ @@ -273,265 +273,265 @@ int JPC_ISTERMINATED(int passno, int firstpassno, int numpasses, int termall, static void jpc_initmqctxs(void) { - jpc_initctxs(jpc_mqctxs); + jpc_initctxs(jpc_mqctxs); } void jpc_initluts() { - int i; - int orient; - int refine; - float u; - float v; - float t; + int i; + int orient; + int refine; + float u; + float v; + float t; /* XXX - hack */ jpc_initmqctxs(); - for (orient = 0; orient < 4; ++orient) { - for (i = 0; i < 256; ++i) { - jpc_zcctxnolut[(orient << 8) | i] = jpc_getzcctxno(i, orient); - } - } - - for (i = 0; i < 256; ++i) { - jpc_spblut[i] = jpc_getspb(i << 4); - } - - for (i = 0; i < 256; ++i) { - jpc_scctxnolut[i] = jpc_getscctxno(i << 4); - } - - for (refine = 0; refine < 2; ++refine) { - for (i = 0; i < 2048; ++i) { - jpc_magctxnolut[(refine << 11) + i] = jpc_getmagctxno((refine ? JPC_REFINE : 0) | i); - } - } - - for (i = 0; i < (1 << JPC_NMSEDEC_BITS); ++i) { - t = i * jpc_pow2i(-JPC_NMSEDEC_FRACBITS); - u = t; - v = t - 1.5; - jpc_signmsedec[i] = jpc_dbltofix(floor((u * u - v * v) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS)); + for (orient = 0; orient < 4; ++orient) { + for (i = 0; i < 256; ++i) { + jpc_zcctxnolut[(orient << 8) | i] = jpc_getzcctxno(i, orient); + } + } + + for (i = 0; i < 256; ++i) { + jpc_spblut[i] = jpc_getspb(i << 4); + } + + for (i = 0; i < 256; ++i) { + jpc_scctxnolut[i] = jpc_getscctxno(i << 4); + } + + for (refine = 0; refine < 2; ++refine) { + for (i = 0; i < 2048; ++i) { + jpc_magctxnolut[(refine << 11) + i] = jpc_getmagctxno((refine ? JPC_REFINE : 0) | i); + } + } + + for (i = 0; i < (1 << JPC_NMSEDEC_BITS); ++i) { + t = i * jpc_pow2i(-JPC_NMSEDEC_FRACBITS); + u = t; + v = t - 1.5; + jpc_signmsedec[i] = jpc_dbltofix(floor((u * u - v * v) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS)); /* XXX - this calc is not correct */ - jpc_signmsedec0[i] = jpc_dbltofix(floor((u * u) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS)); - u = t - 1.0; - if (i & (1 << (JPC_NMSEDEC_BITS - 1))) { - v = t - 1.5; - } else { - v = t - 0.5; - } - jpc_refnmsedec[i] = jpc_dbltofix(floor((u * u - v * v) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS)); + jpc_signmsedec0[i] = jpc_dbltofix(floor((u * u) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS)); + u = t - 1.0; + if (i & (1 << (JPC_NMSEDEC_BITS - 1))) { + v = t - 1.5; + } else { + v = t - 0.5; + } + jpc_refnmsedec[i] = jpc_dbltofix(floor((u * u - v * v) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS)); /* XXX - this calc is not correct */ - jpc_refnmsedec0[i] = jpc_dbltofix(floor((u * u) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS)); - } + jpc_refnmsedec0[i] = jpc_dbltofix(floor((u * u) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS)); + } } jpc_fix_t jpc_getsignmsedec_func(jpc_fix_t x, int bitpos) { - jpc_fix_t y; - assert(!(x & (~JAS_ONES(bitpos + 1)))); - y = jpc_getsignmsedec_macro(x, bitpos); - return y; + jpc_fix_t y; + assert(!(x & (~JAS_ONES(bitpos + 1)))); + y = jpc_getsignmsedec_macro(x, bitpos); + return y; } int jpc_getzcctxno(int f, int orient) { - int h; - int v; - int d; - int n; - int t; - int hv; - - /* Avoid compiler warning. */ - n = 0; - - h = ((f & JPC_WSIG) != 0) + ((f & JPC_ESIG) != 0); - v = ((f & JPC_NSIG) != 0) + ((f & JPC_SSIG) != 0); - d = ((f & JPC_NWSIG) != 0) + ((f & JPC_NESIG) != 0) + ((f & JPC_SESIG) != 0) + ((f & JPC_SWSIG) != 0); - switch (orient) { - case JPC_TSFB_HL: - t = h; - h = v; - v = t; - case JPC_TSFB_LL: - case JPC_TSFB_LH: - if (!h) { - if (!v) { - if (!d) { - n = 0; - } else if (d == 1) { - n = 1; - } else { - n = 2; - } - } else if (v == 1) { - n = 3; - } else { - n = 4; - } - } else if (h == 1) { - if (!v) { - if (!d) { - n = 5; - } else { - n = 6; - } - } else { - n = 7; - } - } else { - n = 8; - } - break; - case JPC_TSFB_HH: - hv = h + v; - if (!d) { - if (!hv) { - n = 0; - } else if (hv == 1) { - n = 1; - } else { - n = 2; - } - } else if (d == 1) { - if (!hv) { - n = 3; - } else if (hv == 1) { - n = 4; - } else { - n = 5; - } - } else if (d == 2) { - if (!hv) { - n = 6; - } else { - n = 7; - } - } else { - n = 8; - } - break; - } - assert(n < JPC_NUMZCCTXS); - return JPC_ZCCTXNO + n; + int h; + int v; + int d; + int n; + int t; + int hv; + + /* Avoid compiler warning. */ + n = 0; + + h = ((f & JPC_WSIG) != 0) + ((f & JPC_ESIG) != 0); + v = ((f & JPC_NSIG) != 0) + ((f & JPC_SSIG) != 0); + d = ((f & JPC_NWSIG) != 0) + ((f & JPC_NESIG) != 0) + ((f & JPC_SESIG) != 0) + ((f & JPC_SWSIG) != 0); + switch (orient) { + case JPC_TSFB_HL: + t = h; + h = v; + v = t; + case JPC_TSFB_LL: + case JPC_TSFB_LH: + if (!h) { + if (!v) { + if (!d) { + n = 0; + } else if (d == 1) { + n = 1; + } else { + n = 2; + } + } else if (v == 1) { + n = 3; + } else { + n = 4; + } + } else if (h == 1) { + if (!v) { + if (!d) { + n = 5; + } else { + n = 6; + } + } else { + n = 7; + } + } else { + n = 8; + } + break; + case JPC_TSFB_HH: + hv = h + v; + if (!d) { + if (!hv) { + n = 0; + } else if (hv == 1) { + n = 1; + } else { + n = 2; + } + } else if (d == 1) { + if (!hv) { + n = 3; + } else if (hv == 1) { + n = 4; + } else { + n = 5; + } + } else if (d == 2) { + if (!hv) { + n = 6; + } else { + n = 7; + } + } else { + n = 8; + } + break; + } + assert(n < JPC_NUMZCCTXS); + return JPC_ZCCTXNO + n; } int jpc_getspb(int f) { - int hc; - int vc; - int n; - - hc = JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == JPC_ESIG) + ((f & (JPC_WSIG | JPC_WSGN)) == JPC_WSIG), 1) - - JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == (JPC_ESIG | JPC_ESGN)) + ((f & (JPC_WSIG | JPC_WSGN)) == (JPC_WSIG | JPC_WSGN)), 1); - vc = JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == JPC_NSIG) + ((f & (JPC_SSIG | JPC_SSGN)) == JPC_SSIG), 1) - - JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == (JPC_NSIG | JPC_NSGN)) + ((f & (JPC_SSIG | JPC_SSGN)) == (JPC_SSIG | JPC_SSGN)), 1); - if (!hc && !vc) { - n = 0; - } else { - n = (!(hc > 0 || (!hc && vc > 0))); - } - return n; + int hc; + int vc; + int n; + + hc = JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == JPC_ESIG) + ((f & (JPC_WSIG | JPC_WSGN)) == JPC_WSIG), 1) - + JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == (JPC_ESIG | JPC_ESGN)) + ((f & (JPC_WSIG | JPC_WSGN)) == (JPC_WSIG | JPC_WSGN)), 1); + vc = JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == JPC_NSIG) + ((f & (JPC_SSIG | JPC_SSGN)) == JPC_SSIG), 1) - + JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == (JPC_NSIG | JPC_NSGN)) + ((f & (JPC_SSIG | JPC_SSGN)) == (JPC_SSIG | JPC_SSGN)), 1); + if (!hc && !vc) { + n = 0; + } else { + n = (!(hc > 0 || (!hc && vc > 0))); + } + return n; } int jpc_getscctxno(int f) { - int hc; - int vc; - int n; - - /* Avoid compiler warning. */ - n = 0; - - hc = JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == JPC_ESIG) + ((f & (JPC_WSIG | JPC_WSGN)) == JPC_WSIG), - 1) - JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == (JPC_ESIG | JPC_ESGN)) + - ((f & (JPC_WSIG | JPC_WSGN)) == (JPC_WSIG | JPC_WSGN)), 1); - vc = JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == JPC_NSIG) + ((f & (JPC_SSIG | JPC_SSGN)) == JPC_SSIG), - 1) - JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == (JPC_NSIG | JPC_NSGN)) + - ((f & (JPC_SSIG | JPC_SSGN)) == (JPC_SSIG | JPC_SSGN)), 1); - assert(hc >= -1 && hc <= 1 && vc >= -1 && vc <= 1); - if (hc < 0) { - hc = -hc; - vc = -vc; - } - if (!hc) { - if (vc == -1) { - n = 1; - } else if (!vc) { - n = 0; - } else { - n = 1; - } - } else if (hc == 1) { - if (vc == -1) { - n = 2; - } else if (!vc) { - n = 3; - } else { - n = 4; - } - } - assert(n < JPC_NUMSCCTXS); - return JPC_SCCTXNO + n; + int hc; + int vc; + int n; + + /* Avoid compiler warning. */ + n = 0; + + hc = JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == JPC_ESIG) + ((f & (JPC_WSIG | JPC_WSGN)) == JPC_WSIG), + 1) - JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == (JPC_ESIG | JPC_ESGN)) + + ((f & (JPC_WSIG | JPC_WSGN)) == (JPC_WSIG | JPC_WSGN)), 1); + vc = JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == JPC_NSIG) + ((f & (JPC_SSIG | JPC_SSGN)) == JPC_SSIG), + 1) - JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == (JPC_NSIG | JPC_NSGN)) + + ((f & (JPC_SSIG | JPC_SSGN)) == (JPC_SSIG | JPC_SSGN)), 1); + assert(hc >= -1 && hc <= 1 && vc >= -1 && vc <= 1); + if (hc < 0) { + hc = -hc; + vc = -vc; + } + if (!hc) { + if (vc == -1) { + n = 1; + } else if (!vc) { + n = 0; + } else { + n = 1; + } + } else if (hc == 1) { + if (vc == -1) { + n = 2; + } else if (!vc) { + n = 3; + } else { + n = 4; + } + } + assert(n < JPC_NUMSCCTXS); + return JPC_SCCTXNO + n; } int jpc_getmagctxno(int f) { - int n; + int n; - if (!(f & JPC_REFINE)) { - n = (f & (JPC_OTHSIGMSK)) ? 1 : 0; - } else { - n = 2; - } + if (!(f & JPC_REFINE)) { + n = (f & (JPC_OTHSIGMSK)) ? 1 : 0; + } else { + n = 2; + } - assert(n < JPC_NUMMAGCTXS); - return JPC_MAGCTXNO + n; + assert(n < JPC_NUMMAGCTXS); + return JPC_MAGCTXNO + n; } void jpc_initctxs(jpc_mqctx_t *ctxs) { - jpc_mqctx_t *ctx; - int i; - - ctx = ctxs; - for (i = 0; i < JPC_NUMCTXS; ++i) { - ctx->mps = 0; - switch (i) { - case JPC_UCTXNO: - ctx->ind = 46; - break; - case JPC_ZCCTXNO: - ctx->ind = 4; - break; - case JPC_AGGCTXNO: - ctx->ind = 3; - break; - default: - ctx->ind = 0; - break; - } - ++ctx; - } + jpc_mqctx_t *ctx; + int i; + + ctx = ctxs; + for (i = 0; i < JPC_NUMCTXS; ++i) { + ctx->mps = 0; + switch (i) { + case JPC_UCTXNO: + ctx->ind = 46; + break; + case JPC_ZCCTXNO: + ctx->ind = 4; + break; + case JPC_AGGCTXNO: + ctx->ind = 3; + break; + default: + ctx->ind = 0; + break; + } + ++ctx; + } } /* Calculate the real quantity exp2(n), where x is an integer. */ double jpc_pow2i(int n) { - double x; - double a; - - x = 1.0; - if (n < 0) { - a = 0.5; - n = -n; - } else { - a = 2.0; - } - while (--n >= 0) { - x *= a; - } - return x; + double x; + double a; + + x = 1.0; + if (n < 0) { + a = 0.5; + n = -n; + } else { + a = 2.0; + } + while (--n >= 0) { + x *= a; + } + return x; } diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_t1cod.h b/converter/other/jpeg2000/libjasper/jpc/jpc_t1cod.h index 3e061d20..771464ec 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_t1cod.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_t1cod.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -132,95 +132,95 @@ \******************************************************************************/ /* The number of bits used to index into various lookup tables. */ -#define JPC_NMSEDEC_BITS 7 -#define JPC_NMSEDEC_FRACBITS (JPC_NMSEDEC_BITS - 1) +#define JPC_NMSEDEC_BITS 7 +#define JPC_NMSEDEC_FRACBITS (JPC_NMSEDEC_BITS - 1) /* * Segment types. */ /* Invalid. */ -#define JPC_SEG_INVALID 0 +#define JPC_SEG_INVALID 0 /* MQ. */ -#define JPC_SEG_MQ 1 +#define JPC_SEG_MQ 1 /* Raw. */ -#define JPC_SEG_RAW 2 +#define JPC_SEG_RAW 2 /* The nominal word size. */ -#define JPC_PREC 32 +#define JPC_PREC 32 /* Tier-1 coding pass types. */ -#define JPC_SIGPASS 0 /* significance */ -#define JPC_REFPASS 1 /* refinement */ -#define JPC_CLNPASS 2 /* cleanup */ +#define JPC_SIGPASS 0 /* significance */ +#define JPC_REFPASS 1 /* refinement */ +#define JPC_CLNPASS 2 /* cleanup */ /* * Per-sample state information for tier-1 coding. */ /* The northeast neighbour has been found to be significant. */ -#define JPC_NESIG 0x0001 +#define JPC_NESIG 0x0001 /* The southeast neighbour has been found to be significant. */ -#define JPC_SESIG 0x0002 +#define JPC_SESIG 0x0002 /* The southwest neighbour has been found to be significant. */ -#define JPC_SWSIG 0x0004 +#define JPC_SWSIG 0x0004 /* The northwest neighbour has been found to be significant. */ -#define JPC_NWSIG 0x0008 +#define JPC_NWSIG 0x0008 /* The north neighbour has been found to be significant. */ -#define JPC_NSIG 0x0010 +#define JPC_NSIG 0x0010 /* The east neighbour has been found to be significant. */ -#define JPC_ESIG 0x0020 +#define JPC_ESIG 0x0020 /* The south neighbour has been found to be significant. */ -#define JPC_SSIG 0x0040 +#define JPC_SSIG 0x0040 /* The west neighbour has been found to be significant. */ -#define JPC_WSIG 0x0080 +#define JPC_WSIG 0x0080 /* The significance mask for 8-connected neighbours. */ -#define JPC_OTHSIGMSK \ - (JPC_NSIG | JPC_NESIG | JPC_ESIG | JPC_SESIG | JPC_SSIG | JPC_SWSIG | JPC_WSIG | JPC_NWSIG) +#define JPC_OTHSIGMSK \ + (JPC_NSIG | JPC_NESIG | JPC_ESIG | JPC_SESIG | JPC_SSIG | JPC_SWSIG | JPC_WSIG | JPC_NWSIG) /* The significance mask for 4-connected neighbours. */ -#define JPC_PRIMSIGMSK (JPC_NSIG | JPC_ESIG | JPC_SSIG | JPC_WSIG) +#define JPC_PRIMSIGMSK (JPC_NSIG | JPC_ESIG | JPC_SSIG | JPC_WSIG) /* The north neighbour is negative in value. */ -#define JPC_NSGN 0x0100 +#define JPC_NSGN 0x0100 /* The east neighbour is negative in value. */ -#define JPC_ESGN 0x0200 +#define JPC_ESGN 0x0200 /* The south neighbour is negative in value. */ -#define JPC_SSGN 0x0400 +#define JPC_SSGN 0x0400 /* The west neighbour is negative in value. */ -#define JPC_WSGN 0x0800 +#define JPC_WSGN 0x0800 /* The sign mask for 4-connected neighbours. */ -#define JPC_SGNMSK (JPC_NSGN | JPC_ESGN | JPC_SSGN | JPC_WSGN) +#define JPC_SGNMSK (JPC_NSGN | JPC_ESGN | JPC_SSGN | JPC_WSGN) /* This sample has been found to be significant. */ -#define JPC_SIG 0x1000 +#define JPC_SIG 0x1000 /* The sample has been refined. */ -#define JPC_REFINE 0x2000 +#define JPC_REFINE 0x2000 /* This sample has been processed during the significance pass. */ -#define JPC_VISIT 0x4000 +#define JPC_VISIT 0x4000 /* The number of aggregation contexts. */ -#define JPC_NUMAGGCTXS 1 +#define JPC_NUMAGGCTXS 1 /* The number of zero coding contexts. */ -#define JPC_NUMZCCTXS 9 +#define JPC_NUMZCCTXS 9 /* The number of magnitude contexts. */ -#define JPC_NUMMAGCTXS 3 +#define JPC_NUMMAGCTXS 3 /* The number of sign coding contexts. */ -#define JPC_NUMSCCTXS 5 +#define JPC_NUMSCCTXS 5 /* The number of uniform contexts. */ -#define JPC_NUMUCTXS 1 +#define JPC_NUMUCTXS 1 /* The context ID for the first aggregation context. */ -#define JPC_AGGCTXNO 0 +#define JPC_AGGCTXNO 0 /* The context ID for the first zero coding context. */ -#define JPC_ZCCTXNO (JPC_AGGCTXNO + JPC_NUMAGGCTXS) +#define JPC_ZCCTXNO (JPC_AGGCTXNO + JPC_NUMAGGCTXS) /* The context ID for the first magnitude context. */ -#define JPC_MAGCTXNO (JPC_ZCCTXNO + JPC_NUMZCCTXS) +#define JPC_MAGCTXNO (JPC_ZCCTXNO + JPC_NUMZCCTXS) /* The context ID for the first sign coding context. */ -#define JPC_SCCTXNO (JPC_MAGCTXNO + JPC_NUMMAGCTXS) +#define JPC_SCCTXNO (JPC_MAGCTXNO + JPC_NUMMAGCTXS) /* The context ID for the first uniform context. */ -#define JPC_UCTXNO (JPC_SCCTXNO + JPC_NUMSCCTXS) +#define JPC_UCTXNO (JPC_SCCTXNO + JPC_NUMSCCTXS) /* The total number of contexts. */ -#define JPC_NUMCTXS (JPC_UCTXNO + JPC_NUMUCTXS) +#define JPC_NUMCTXS (JPC_UCTXNO + JPC_NUMUCTXS) /******************************************************************************\ * External data. @@ -249,76 +249,76 @@ void jpc_initctxs(jpc_mqctx_t *ctxs); /* Get the zero coding context. */ int jpc_getzcctxno(int f, int orient); -#define JPC_GETZCCTXNO(f, orient) \ - (jpc_zcctxnolut[((orient) << 8) | ((f) & JPC_OTHSIGMSK)]) +#define JPC_GETZCCTXNO(f, orient) \ + (jpc_zcctxnolut[((orient) << 8) | ((f) & JPC_OTHSIGMSK)]) /* Get the sign prediction bit. */ int jpc_getspb(int f); -#define JPC_GETSPB(f) \ - (jpc_spblut[((f) & (JPC_PRIMSIGMSK | JPC_SGNMSK)) >> 4]) +#define JPC_GETSPB(f) \ + (jpc_spblut[((f) & (JPC_PRIMSIGMSK | JPC_SGNMSK)) >> 4]) /* Get the sign coding context. */ int jpc_getscctxno(int f); -#define JPC_GETSCCTXNO(f) \ - (jpc_scctxnolut[((f) & (JPC_PRIMSIGMSK | JPC_SGNMSK)) >> 4]) +#define JPC_GETSCCTXNO(f) \ + (jpc_scctxnolut[((f) & (JPC_PRIMSIGMSK | JPC_SGNMSK)) >> 4]) /* Get the magnitude context. */ int jpc_getmagctxno(int f); -#define JPC_GETMAGCTXNO(f) \ - (jpc_magctxnolut[((f) & JPC_OTHSIGMSK) | ((((f) & JPC_REFINE) != 0) << 11)]) +#define JPC_GETMAGCTXNO(f) \ + (jpc_magctxnolut[((f) & JPC_OTHSIGMSK) | ((((f) & JPC_REFINE) != 0) << 11)]) /* Get the normalized MSE reduction for significance passes. */ -#define JPC_GETSIGNMSEDEC(x, bitpos) jpc_getsignmsedec_macro(x, bitpos) +#define JPC_GETSIGNMSEDEC(x, bitpos) jpc_getsignmsedec_macro(x, bitpos) jpc_fix_t jpc_getsignmsedec_func(jpc_fix_t x, int bitpos); -#define jpc_getsignmsedec_macro(x, bitpos) \ - ((bitpos > JPC_NMSEDEC_FRACBITS) ? jpc_signmsedec[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)] : \ - (jpc_signmsedec0[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)])) +#define jpc_getsignmsedec_macro(x, bitpos) \ + ((bitpos > JPC_NMSEDEC_FRACBITS) ? jpc_signmsedec[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)] : \ + (jpc_signmsedec0[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)])) /* Get the normalized MSE reduction for refinement passes. */ -#define JPC_GETREFNMSEDEC(x, bitpos) jpc_getrefnmsedec_macro(x, bitpos) +#define JPC_GETREFNMSEDEC(x, bitpos) jpc_getrefnmsedec_macro(x, bitpos) jpc_fix_t jpc_refsignmsedec_func(jpc_fix_t x, int bitpos); -#define jpc_getrefnmsedec_macro(x, bitpos) \ - ((bitpos > JPC_NMSEDEC_FRACBITS) ? jpc_refnmsedec[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)] : \ - (jpc_refnmsedec0[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)])) +#define jpc_getrefnmsedec_macro(x, bitpos) \ + ((bitpos > JPC_NMSEDEC_FRACBITS) ? jpc_refnmsedec[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)] : \ + (jpc_refnmsedec0[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)])) /* Arithmetic shift right (with ability to shift left also). */ -#define JPC_ASR(x, n) \ - (((n) >= 0) ? ((x) >> (n)) : ((x) << (-(n)))) +#define JPC_ASR(x, n) \ + (((n) >= 0) ? ((x) >> (n)) : ((x) << (-(n)))) /* Update the per-sample state information. */ -#define JPC_UPDATEFLAGS4(fp, rowstep, s, vcausalflag) \ +#define JPC_UPDATEFLAGS4(fp, rowstep, s, vcausalflag) \ { \ - register jpc_fix_t *np = (fp) - (rowstep); \ - register jpc_fix_t *sp = (fp) + (rowstep); \ - if ((vcausalflag)) { \ - sp[-1] |= JPC_NESIG; \ - sp[1] |= JPC_NWSIG; \ - if (s) { \ - *sp |= JPC_NSIG | JPC_NSGN; \ - (fp)[-1] |= JPC_ESIG | JPC_ESGN; \ - (fp)[1] |= JPC_WSIG | JPC_WSGN; \ - } else { \ - *sp |= JPC_NSIG; \ - (fp)[-1] |= JPC_ESIG; \ - (fp)[1] |= JPC_WSIG; \ - } \ - } else { \ - np[-1] |= JPC_SESIG; \ - np[1] |= JPC_SWSIG; \ - sp[-1] |= JPC_NESIG; \ - sp[1] |= JPC_NWSIG; \ - if (s) { \ - *np |= JPC_SSIG | JPC_SSGN; \ - *sp |= JPC_NSIG | JPC_NSGN; \ - (fp)[-1] |= JPC_ESIG | JPC_ESGN; \ - (fp)[1] |= JPC_WSIG | JPC_WSGN; \ - } else { \ - *np |= JPC_SSIG; \ - *sp |= JPC_NSIG; \ - (fp)[-1] |= JPC_ESIG; \ - (fp)[1] |= JPC_WSIG; \ - } \ - } \ + register jpc_fix_t *np = (fp) - (rowstep); \ + register jpc_fix_t *sp = (fp) + (rowstep); \ + if ((vcausalflag)) { \ + sp[-1] |= JPC_NESIG; \ + sp[1] |= JPC_NWSIG; \ + if (s) { \ + *sp |= JPC_NSIG | JPC_NSGN; \ + (fp)[-1] |= JPC_ESIG | JPC_ESGN; \ + (fp)[1] |= JPC_WSIG | JPC_WSGN; \ + } else { \ + *sp |= JPC_NSIG; \ + (fp)[-1] |= JPC_ESIG; \ + (fp)[1] |= JPC_WSIG; \ + } \ + } else { \ + np[-1] |= JPC_SESIG; \ + np[1] |= JPC_SWSIG; \ + sp[-1] |= JPC_NESIG; \ + sp[1] |= JPC_NWSIG; \ + if (s) { \ + *np |= JPC_SSIG | JPC_SSGN; \ + *sp |= JPC_NSIG | JPC_NSGN; \ + (fp)[-1] |= JPC_ESIG | JPC_ESGN; \ + (fp)[1] |= JPC_WSIG | JPC_WSGN; \ + } else { \ + *np |= JPC_SSIG; \ + *sp |= JPC_NSIG; \ + (fp)[-1] |= JPC_ESIG; \ + (fp)[1] |= JPC_WSIG; \ + } \ + } \ } /* Initialize the lookup tables used by the codec. */ diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_t1dec.c b/converter/other/jpeg2000/libjasper/jpc/jpc_t1dec.c index b6c5e14f..437e9dd6 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_t1dec.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_t1dec.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_t1dec.h b/converter/other/jpeg2000/libjasper/jpc/jpc_t1dec.h index f8b3b342..35ff549a 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_t1dec.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_t1dec.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_t1enc.c b/converter/other/jpeg2000/libjasper/jpc/jpc_t1enc.c index 34b9738c..e9ec12d4 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_t1enc.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_t1enc.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -433,7 +433,7 @@ assert(jas_stream_tell(cblk->stream) == jas_stream_getrwcount(cblk->stream)); #if 0 /* XXX - This assertion fails sometimes when various coding modes are used. This seems to be harmless, but why does it happen at all? */ - assert(jas_stream_tell(cblk->stream) == + assert(jas_stream_tell(cblk->stream) == jas_stream_getrwcount(cblk->stream)); #endif diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_t1enc.h b/converter/other/jpeg2000/libjasper/jpc/jpc_t1enc.h index 9ce5ed27..08b4811f 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_t1enc.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_t1enc.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_t2cod.c b/converter/other/jpeg2000/libjasper/jpc/jpc_t2cod.c index a9ca0dc1..9a635285 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_t2cod.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_t2cod.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -132,602 +132,602 @@ static int jpc_pi_nextcprl(jpc_pi_t *pi); int jpc_pi_next(jpc_pi_t *pi) { - jpc_pchg_t *pchg; - int ret; - - - for (;;) { - - pi->valid = false; - - if (!pi->pchg) { - ++pi->pchgno; - pi->compno = 0; - pi->rlvlno = 0; - pi->prcno = 0; - pi->lyrno = 0; - pi->prgvolfirst = true; - if (pi->pchgno < jpc_pchglist_numpchgs(pi->pchglist)) { - pi->pchg = jpc_pchglist_get(pi->pchglist, pi->pchgno); - } else if (pi->pchgno == jpc_pchglist_numpchgs(pi->pchglist)) { - pi->pchg = &pi->defaultpchg; - } else { - return 1; - } - } - - pchg = pi->pchg; - switch (pchg->prgord) { - case JPC_COD_LRCPPRG: - ret = jpc_pi_nextlrcp(pi); - break; - case JPC_COD_RLCPPRG: - ret = jpc_pi_nextrlcp(pi); - break; - case JPC_COD_RPCLPRG: - ret = jpc_pi_nextrpcl(pi); - break; - case JPC_COD_PCRLPRG: - ret = jpc_pi_nextpcrl(pi); - break; - case JPC_COD_CPRLPRG: - ret = jpc_pi_nextcprl(pi); - break; - default: - ret = -1; - break; - } - if (!ret) { - pi->valid = true; - ++pi->pktno; - return 0; - } - pi->pchg = 0; - } + jpc_pchg_t *pchg; + int ret; + + + for (;;) { + + pi->valid = false; + + if (!pi->pchg) { + ++pi->pchgno; + pi->compno = 0; + pi->rlvlno = 0; + pi->prcno = 0; + pi->lyrno = 0; + pi->prgvolfirst = true; + if (pi->pchgno < jpc_pchglist_numpchgs(pi->pchglist)) { + pi->pchg = jpc_pchglist_get(pi->pchglist, pi->pchgno); + } else if (pi->pchgno == jpc_pchglist_numpchgs(pi->pchglist)) { + pi->pchg = &pi->defaultpchg; + } else { + return 1; + } + } + + pchg = pi->pchg; + switch (pchg->prgord) { + case JPC_COD_LRCPPRG: + ret = jpc_pi_nextlrcp(pi); + break; + case JPC_COD_RLCPPRG: + ret = jpc_pi_nextrlcp(pi); + break; + case JPC_COD_RPCLPRG: + ret = jpc_pi_nextrpcl(pi); + break; + case JPC_COD_PCRLPRG: + ret = jpc_pi_nextpcrl(pi); + break; + case JPC_COD_CPRLPRG: + ret = jpc_pi_nextcprl(pi); + break; + default: + ret = -1; + break; + } + if (!ret) { + pi->valid = true; + ++pi->pktno; + return 0; + } + pi->pchg = 0; + } } static int jpc_pi_nextlrcp(register jpc_pi_t *pi) { - jpc_pchg_t *pchg; - int *prclyrno; - - pchg = pi->pchg; - if (!pi->prgvolfirst) { - prclyrno = &pi->pirlvl->prclyrnos[pi->prcno]; - goto skip; - } else { - pi->prgvolfirst = false; - } - - for (pi->lyrno = 0; pi->lyrno < pi->numlyrs && pi->lyrno < - pchg->lyrnoend; ++pi->lyrno) { - for (pi->rlvlno = pchg->rlvlnostart; pi->rlvlno < pi->maxrlvls && - pi->rlvlno < pchg->rlvlnoend; ++pi->rlvlno) { - for (pi->compno = pchg->compnostart, pi->picomp = - &pi->picomps[pi->compno]; pi->compno < pi->numcomps - && pi->compno < pchg->compnoend; ++pi->compno, - ++pi->picomp) { - if (pi->rlvlno >= pi->picomp->numrlvls) { - continue; - } - pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno]; - for (pi->prcno = 0, prclyrno = - pi->pirlvl->prclyrnos; pi->prcno < - pi->pirlvl->numprcs; ++pi->prcno, - ++prclyrno) { - if (pi->lyrno >= *prclyrno) { - *prclyrno = pi->lyrno; - ++(*prclyrno); - return 0; - } + jpc_pchg_t *pchg; + int *prclyrno; + + pchg = pi->pchg; + if (!pi->prgvolfirst) { + prclyrno = &pi->pirlvl->prclyrnos[pi->prcno]; + goto skip; + } else { + pi->prgvolfirst = false; + } + + for (pi->lyrno = 0; pi->lyrno < pi->numlyrs && pi->lyrno < + pchg->lyrnoend; ++pi->lyrno) { + for (pi->rlvlno = pchg->rlvlnostart; pi->rlvlno < pi->maxrlvls && + pi->rlvlno < pchg->rlvlnoend; ++pi->rlvlno) { + for (pi->compno = pchg->compnostart, pi->picomp = + &pi->picomps[pi->compno]; pi->compno < pi->numcomps + && pi->compno < pchg->compnoend; ++pi->compno, + ++pi->picomp) { + if (pi->rlvlno >= pi->picomp->numrlvls) { + continue; + } + pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno]; + for (pi->prcno = 0, prclyrno = + pi->pirlvl->prclyrnos; pi->prcno < + pi->pirlvl->numprcs; ++pi->prcno, + ++prclyrno) { + if (pi->lyrno >= *prclyrno) { + *prclyrno = pi->lyrno; + ++(*prclyrno); + return 0; + } skip: - ; - } - } - } - } - return 1; + ; + } + } + } + } + return 1; } static int jpc_pi_nextrlcp(register jpc_pi_t *pi) { - jpc_pchg_t *pchg; - int *prclyrno; - - pchg = pi->pchg; - if (!pi->prgvolfirst) { - assert(pi->prcno < pi->pirlvl->numprcs); - prclyrno = &pi->pirlvl->prclyrnos[pi->prcno]; - goto skip; - } else { - pi->prgvolfirst = 0; - } - - for (pi->rlvlno = pchg->rlvlnostart; pi->rlvlno < pi->maxrlvls && - pi->rlvlno < pchg->rlvlnoend; ++pi->rlvlno) { - for (pi->lyrno = 0; pi->lyrno < pi->numlyrs && pi->lyrno < - pchg->lyrnoend; ++pi->lyrno) { - for (pi->compno = pchg->compnostart, pi->picomp = - &pi->picomps[pi->compno]; pi->compno < pi->numcomps && - pi->compno < pchg->compnoend; ++pi->compno, ++pi->picomp) { - if (pi->rlvlno >= pi->picomp->numrlvls) { - continue; - } - pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno]; - for (pi->prcno = 0, prclyrno = pi->pirlvl->prclyrnos; - pi->prcno < pi->pirlvl->numprcs; ++pi->prcno, ++prclyrno) { - if (pi->lyrno >= *prclyrno) { - *prclyrno = pi->lyrno; - ++(*prclyrno); - return 0; - } + jpc_pchg_t *pchg; + int *prclyrno; + + pchg = pi->pchg; + if (!pi->prgvolfirst) { + assert(pi->prcno < pi->pirlvl->numprcs); + prclyrno = &pi->pirlvl->prclyrnos[pi->prcno]; + goto skip; + } else { + pi->prgvolfirst = 0; + } + + for (pi->rlvlno = pchg->rlvlnostart; pi->rlvlno < pi->maxrlvls && + pi->rlvlno < pchg->rlvlnoend; ++pi->rlvlno) { + for (pi->lyrno = 0; pi->lyrno < pi->numlyrs && pi->lyrno < + pchg->lyrnoend; ++pi->lyrno) { + for (pi->compno = pchg->compnostart, pi->picomp = + &pi->picomps[pi->compno]; pi->compno < pi->numcomps && + pi->compno < pchg->compnoend; ++pi->compno, ++pi->picomp) { + if (pi->rlvlno >= pi->picomp->numrlvls) { + continue; + } + pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno]; + for (pi->prcno = 0, prclyrno = pi->pirlvl->prclyrnos; + pi->prcno < pi->pirlvl->numprcs; ++pi->prcno, ++prclyrno) { + if (pi->lyrno >= *prclyrno) { + *prclyrno = pi->lyrno; + ++(*prclyrno); + return 0; + } skip: - ; - } - } - } - } - return 1; + ; + } + } + } + } + return 1; } static int jpc_pi_nextrpcl(register jpc_pi_t *pi) { - int rlvlno; - jpc_pirlvl_t *pirlvl; - jpc_pchg_t *pchg; - int prchind; - int prcvind; - int *prclyrno; - int compno; - jpc_picomp_t *picomp; - int xstep; - int ystep; - uint_fast32_t r; - uint_fast32_t rpx; - uint_fast32_t rpy; - uint_fast32_t trx0; - uint_fast32_t try0; - - pchg = pi->pchg; - if (!pi->prgvolfirst) { - goto skip; - } else { - pi->xstep = 0; - pi->ystep = 0; - for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; - ++compno, ++picomp) { - for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno < - picomp->numrlvls; ++rlvlno, ++pirlvl) { - xstep = picomp->hsamp * (1 << (pirlvl->prcwidthexpn + - picomp->numrlvls - rlvlno - 1)); - ystep = picomp->vsamp * (1 << (pirlvl->prcheightexpn + - picomp->numrlvls - rlvlno - 1)); - pi->xstep = (!pi->xstep) ? xstep : JAS_MIN(pi->xstep, xstep); - pi->ystep = (!pi->ystep) ? ystep : JAS_MIN(pi->ystep, ystep); - } - } - pi->prgvolfirst = 0; - } - - for (pi->rlvlno = pchg->rlvlnostart; pi->rlvlno < pchg->rlvlnoend && - pi->rlvlno < pi->maxrlvls; ++pi->rlvlno) { - for (pi->y = pi->ystart; pi->y < pi->yend; pi->y += - pi->ystep - (pi->y % pi->ystep)) { - for (pi->x = pi->xstart; pi->x < pi->xend; pi->x += - pi->xstep - (pi->x % pi->xstep)) { - for (pi->compno = pchg->compnostart, - pi->picomp = &pi->picomps[pi->compno]; - pi->compno < pchg->compnoend && pi->compno < - pi->numcomps; ++pi->compno, ++pi->picomp) { - if (pi->rlvlno >= pi->picomp->numrlvls) { - continue; - } - pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno]; - if (pi->pirlvl->numprcs == 0) { - continue; - } - r = pi->picomp->numrlvls - 1 - pi->rlvlno; - rpx = r + pi->pirlvl->prcwidthexpn; - rpy = r + pi->pirlvl->prcheightexpn; - trx0 = JPC_CEILDIV(pi->xstart, pi->picomp->hsamp << r); - try0 = JPC_CEILDIV(pi->ystart, pi->picomp->vsamp << r); - if (((pi->x == pi->xstart && ((trx0 << r) % (1 << rpx))) - || !(pi->x % (1 << rpx))) && - ((pi->y == pi->ystart && ((try0 << r) % (1 << rpy))) - || !(pi->y % (1 << rpy)))) { - prchind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->x, pi->picomp->hsamp - << r), pi->pirlvl->prcwidthexpn) - JPC_FLOORDIVPOW2(trx0, - pi->pirlvl->prcwidthexpn); - prcvind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->y, pi->picomp->vsamp - << r), pi->pirlvl->prcheightexpn) - JPC_FLOORDIVPOW2(try0, - pi->pirlvl->prcheightexpn); - pi->prcno = prcvind * pi->pirlvl->numhprcs + prchind; - - assert(pi->prcno < pi->pirlvl->numprcs); - for (pi->lyrno = 0; pi->lyrno < - pi->numlyrs && pi->lyrno < pchg->lyrnoend; ++pi->lyrno) { - prclyrno = &pi->pirlvl->prclyrnos[pi->prcno]; - if (pi->lyrno >= *prclyrno) { - ++(*prclyrno); - return 0; - } + int rlvlno; + jpc_pirlvl_t *pirlvl; + jpc_pchg_t *pchg; + int prchind; + int prcvind; + int *prclyrno; + int compno; + jpc_picomp_t *picomp; + int xstep; + int ystep; + uint_fast32_t r; + uint_fast32_t rpx; + uint_fast32_t rpy; + uint_fast32_t trx0; + uint_fast32_t try0; + + pchg = pi->pchg; + if (!pi->prgvolfirst) { + goto skip; + } else { + pi->xstep = 0; + pi->ystep = 0; + for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; + ++compno, ++picomp) { + for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno < + picomp->numrlvls; ++rlvlno, ++pirlvl) { + xstep = picomp->hsamp * (1 << (pirlvl->prcwidthexpn + + picomp->numrlvls - rlvlno - 1)); + ystep = picomp->vsamp * (1 << (pirlvl->prcheightexpn + + picomp->numrlvls - rlvlno - 1)); + pi->xstep = (!pi->xstep) ? xstep : JAS_MIN(pi->xstep, xstep); + pi->ystep = (!pi->ystep) ? ystep : JAS_MIN(pi->ystep, ystep); + } + } + pi->prgvolfirst = 0; + } + + for (pi->rlvlno = pchg->rlvlnostart; pi->rlvlno < pchg->rlvlnoend && + pi->rlvlno < pi->maxrlvls; ++pi->rlvlno) { + for (pi->y = pi->ystart; pi->y < pi->yend; pi->y += + pi->ystep - (pi->y % pi->ystep)) { + for (pi->x = pi->xstart; pi->x < pi->xend; pi->x += + pi->xstep - (pi->x % pi->xstep)) { + for (pi->compno = pchg->compnostart, + pi->picomp = &pi->picomps[pi->compno]; + pi->compno < pchg->compnoend && pi->compno < + pi->numcomps; ++pi->compno, ++pi->picomp) { + if (pi->rlvlno >= pi->picomp->numrlvls) { + continue; + } + pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno]; + if (pi->pirlvl->numprcs == 0) { + continue; + } + r = pi->picomp->numrlvls - 1 - pi->rlvlno; + rpx = r + pi->pirlvl->prcwidthexpn; + rpy = r + pi->pirlvl->prcheightexpn; + trx0 = JPC_CEILDIV(pi->xstart, pi->picomp->hsamp << r); + try0 = JPC_CEILDIV(pi->ystart, pi->picomp->vsamp << r); + if (((pi->x == pi->xstart && ((trx0 << r) % (1 << rpx))) + || !(pi->x % (1 << rpx))) && + ((pi->y == pi->ystart && ((try0 << r) % (1 << rpy))) + || !(pi->y % (1 << rpy)))) { + prchind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->x, pi->picomp->hsamp + << r), pi->pirlvl->prcwidthexpn) - JPC_FLOORDIVPOW2(trx0, + pi->pirlvl->prcwidthexpn); + prcvind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->y, pi->picomp->vsamp + << r), pi->pirlvl->prcheightexpn) - JPC_FLOORDIVPOW2(try0, + pi->pirlvl->prcheightexpn); + pi->prcno = prcvind * pi->pirlvl->numhprcs + prchind; + + assert(pi->prcno < pi->pirlvl->numprcs); + for (pi->lyrno = 0; pi->lyrno < + pi->numlyrs && pi->lyrno < pchg->lyrnoend; ++pi->lyrno) { + prclyrno = &pi->pirlvl->prclyrnos[pi->prcno]; + if (pi->lyrno >= *prclyrno) { + ++(*prclyrno); + return 0; + } skip: - ; - } - } - } - } - } - } - return 1; + ; + } + } + } + } + } + } + return 1; } static int jpc_pi_nextpcrl(register jpc_pi_t *pi) { - int rlvlno; - jpc_pirlvl_t *pirlvl; - jpc_pchg_t *pchg; - int prchind; - int prcvind; - int *prclyrno; - int compno; - jpc_picomp_t *picomp; - int xstep; - int ystep; - uint_fast32_t trx0; - uint_fast32_t try0; - uint_fast32_t r; - uint_fast32_t rpx; - uint_fast32_t rpy; - - pchg = pi->pchg; - if (!pi->prgvolfirst) { - goto skip; - } else { - pi->xstep = 0; - pi->ystep = 0; - for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; - ++compno, ++picomp) { - for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno < - picomp->numrlvls; ++rlvlno, ++pirlvl) { - xstep = picomp->hsamp * (1 << - (pirlvl->prcwidthexpn + picomp->numrlvls - - rlvlno - 1)); - ystep = picomp->vsamp * (1 << - (pirlvl->prcheightexpn + picomp->numrlvls - - rlvlno - 1)); - pi->xstep = (!pi->xstep) ? xstep : - JAS_MIN(pi->xstep, xstep); - pi->ystep = (!pi->ystep) ? ystep : - JAS_MIN(pi->ystep, ystep); - } - } - pi->prgvolfirst = 0; - } - - for (pi->y = pi->ystart; pi->y < pi->yend; pi->y += pi->ystep - - (pi->y % pi->ystep)) { - for (pi->x = pi->xstart; pi->x < pi->xend; pi->x += pi->xstep - - (pi->x % pi->xstep)) { - for (pi->compno = pchg->compnostart, pi->picomp = - &pi->picomps[pi->compno]; pi->compno < pi->numcomps - && pi->compno < pchg->compnoend; ++pi->compno, - ++pi->picomp) { - for (pi->rlvlno = pchg->rlvlnostart, - pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno]; - pi->rlvlno < pi->picomp->numrlvls && - pi->rlvlno < pchg->rlvlnoend; ++pi->rlvlno, - ++pi->pirlvl) { - if (pi->pirlvl->numprcs == 0) { - continue; - } - r = pi->picomp->numrlvls - 1 - pi->rlvlno; - trx0 = JPC_CEILDIV(pi->xstart, pi->picomp->hsamp << r); - try0 = JPC_CEILDIV(pi->ystart, pi->picomp->vsamp << r); - rpx = r + pi->pirlvl->prcwidthexpn; - rpy = r + pi->pirlvl->prcheightexpn; - if (((pi->x == pi->xstart && ((trx0 << r) % (1 << rpx))) || - !(pi->x % (pi->picomp->hsamp << rpx))) && - ((pi->y == pi->ystart && ((try0 << r) % (1 << rpy))) || - !(pi->y % (pi->picomp->vsamp << rpy)))) { - prchind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->x, pi->picomp->hsamp - << r), pi->pirlvl->prcwidthexpn) - JPC_FLOORDIVPOW2(trx0, - pi->pirlvl->prcwidthexpn); - prcvind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->y, pi->picomp->vsamp - << r), pi->pirlvl->prcheightexpn) - JPC_FLOORDIVPOW2(try0, - pi->pirlvl->prcheightexpn); - pi->prcno = prcvind * pi->pirlvl->numhprcs + prchind; - assert(pi->prcno < pi->pirlvl->numprcs); - for (pi->lyrno = 0; pi->lyrno < pi->numlyrs && - pi->lyrno < pchg->lyrnoend; ++pi->lyrno) { - prclyrno = &pi->pirlvl->prclyrnos[pi->prcno]; - if (pi->lyrno >= *prclyrno) { - ++(*prclyrno); - return 0; - } + int rlvlno; + jpc_pirlvl_t *pirlvl; + jpc_pchg_t *pchg; + int prchind; + int prcvind; + int *prclyrno; + int compno; + jpc_picomp_t *picomp; + int xstep; + int ystep; + uint_fast32_t trx0; + uint_fast32_t try0; + uint_fast32_t r; + uint_fast32_t rpx; + uint_fast32_t rpy; + + pchg = pi->pchg; + if (!pi->prgvolfirst) { + goto skip; + } else { + pi->xstep = 0; + pi->ystep = 0; + for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; + ++compno, ++picomp) { + for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno < + picomp->numrlvls; ++rlvlno, ++pirlvl) { + xstep = picomp->hsamp * (1 << + (pirlvl->prcwidthexpn + picomp->numrlvls - + rlvlno - 1)); + ystep = picomp->vsamp * (1 << + (pirlvl->prcheightexpn + picomp->numrlvls - + rlvlno - 1)); + pi->xstep = (!pi->xstep) ? xstep : + JAS_MIN(pi->xstep, xstep); + pi->ystep = (!pi->ystep) ? ystep : + JAS_MIN(pi->ystep, ystep); + } + } + pi->prgvolfirst = 0; + } + + for (pi->y = pi->ystart; pi->y < pi->yend; pi->y += pi->ystep - + (pi->y % pi->ystep)) { + for (pi->x = pi->xstart; pi->x < pi->xend; pi->x += pi->xstep - + (pi->x % pi->xstep)) { + for (pi->compno = pchg->compnostart, pi->picomp = + &pi->picomps[pi->compno]; pi->compno < pi->numcomps + && pi->compno < pchg->compnoend; ++pi->compno, + ++pi->picomp) { + for (pi->rlvlno = pchg->rlvlnostart, + pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno]; + pi->rlvlno < pi->picomp->numrlvls && + pi->rlvlno < pchg->rlvlnoend; ++pi->rlvlno, + ++pi->pirlvl) { + if (pi->pirlvl->numprcs == 0) { + continue; + } + r = pi->picomp->numrlvls - 1 - pi->rlvlno; + trx0 = JPC_CEILDIV(pi->xstart, pi->picomp->hsamp << r); + try0 = JPC_CEILDIV(pi->ystart, pi->picomp->vsamp << r); + rpx = r + pi->pirlvl->prcwidthexpn; + rpy = r + pi->pirlvl->prcheightexpn; + if (((pi->x == pi->xstart && ((trx0 << r) % (1 << rpx))) || + !(pi->x % (pi->picomp->hsamp << rpx))) && + ((pi->y == pi->ystart && ((try0 << r) % (1 << rpy))) || + !(pi->y % (pi->picomp->vsamp << rpy)))) { + prchind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->x, pi->picomp->hsamp + << r), pi->pirlvl->prcwidthexpn) - JPC_FLOORDIVPOW2(trx0, + pi->pirlvl->prcwidthexpn); + prcvind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->y, pi->picomp->vsamp + << r), pi->pirlvl->prcheightexpn) - JPC_FLOORDIVPOW2(try0, + pi->pirlvl->prcheightexpn); + pi->prcno = prcvind * pi->pirlvl->numhprcs + prchind; + assert(pi->prcno < pi->pirlvl->numprcs); + for (pi->lyrno = 0; pi->lyrno < pi->numlyrs && + pi->lyrno < pchg->lyrnoend; ++pi->lyrno) { + prclyrno = &pi->pirlvl->prclyrnos[pi->prcno]; + if (pi->lyrno >= *prclyrno) { + ++(*prclyrno); + return 0; + } skip: - ; - } - } - } - } - } - } - return 1; + ; + } + } + } + } + } + } + return 1; } static int jpc_pi_nextcprl(register jpc_pi_t *pi) { - int rlvlno; - jpc_pirlvl_t *pirlvl; - jpc_pchg_t *pchg; - int prchind; - int prcvind; - int *prclyrno; - uint_fast32_t trx0; - uint_fast32_t try0; - uint_fast32_t r; - uint_fast32_t rpx; - uint_fast32_t rpy; - - pchg = pi->pchg; - if (!pi->prgvolfirst) { - goto skip; - } else { - pi->prgvolfirst = 0; - } - - for (pi->compno = pchg->compnostart, pi->picomp = - &pi->picomps[pi->compno]; pi->compno < pchg->compnoend; ++pi->compno, - ++pi->picomp) { - pirlvl = pi->picomp->pirlvls; - pi->xstep = pi->picomp->hsamp * (1 << (pirlvl->prcwidthexpn + - pi->picomp->numrlvls - 1)); - pi->ystep = pi->picomp->vsamp * (1 << (pirlvl->prcheightexpn + - pi->picomp->numrlvls - 1)); - for (rlvlno = 1, pirlvl = &pi->picomp->pirlvls[1]; - rlvlno < pi->picomp->numrlvls; ++rlvlno, ++pirlvl) { - pi->xstep = JAS_MIN(pi->xstep, pi->picomp->hsamp * (1 << - (pirlvl->prcwidthexpn + pi->picomp->numrlvls - - rlvlno - 1))); - pi->ystep = JAS_MIN(pi->ystep, pi->picomp->vsamp * (1 << - (pirlvl->prcheightexpn + pi->picomp->numrlvls - - rlvlno - 1))); - } - for (pi->y = pi->ystart; pi->y < pi->yend; - pi->y += pi->ystep - (pi->y % pi->ystep)) { - for (pi->x = pi->xstart; pi->x < pi->xend; - pi->x += pi->xstep - (pi->x % pi->xstep)) { - for (pi->rlvlno = pchg->rlvlnostart, - pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno]; - pi->rlvlno < pi->picomp->numrlvls && pi->rlvlno < - pchg->rlvlnoend; ++pi->rlvlno, ++pi->pirlvl) { - if (pi->pirlvl->numprcs == 0) { - continue; - } - r = pi->picomp->numrlvls - 1 - pi->rlvlno; - trx0 = JPC_CEILDIV(pi->xstart, pi->picomp->hsamp << r); - try0 = JPC_CEILDIV(pi->ystart, pi->picomp->vsamp << r); - rpx = r + pi->pirlvl->prcwidthexpn; - rpy = r + pi->pirlvl->prcheightexpn; - if (((pi->x == pi->xstart && ((trx0 << r) % (1 << rpx))) || - !(pi->x % (pi->picomp->hsamp << rpx))) && - ((pi->y == pi->ystart && ((try0 << r) % (1 << rpy))) || - !(pi->y % (pi->picomp->vsamp << rpy)))) { - prchind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->x, pi->picomp->hsamp - << r), pi->pirlvl->prcwidthexpn) - JPC_FLOORDIVPOW2(trx0, - pi->pirlvl->prcwidthexpn); - prcvind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->y, pi->picomp->vsamp - << r), pi->pirlvl->prcheightexpn) - JPC_FLOORDIVPOW2(try0, - pi->pirlvl->prcheightexpn); - pi->prcno = prcvind * - pi->pirlvl->numhprcs + - prchind; - assert(pi->prcno < - pi->pirlvl->numprcs); - for (pi->lyrno = 0; pi->lyrno < - pi->numlyrs && pi->lyrno < pchg->lyrnoend; ++pi->lyrno) { - prclyrno = &pi->pirlvl->prclyrnos[pi->prcno]; - if (pi->lyrno >= *prclyrno) { - ++(*prclyrno); - return 0; - } + int rlvlno; + jpc_pirlvl_t *pirlvl; + jpc_pchg_t *pchg; + int prchind; + int prcvind; + int *prclyrno; + uint_fast32_t trx0; + uint_fast32_t try0; + uint_fast32_t r; + uint_fast32_t rpx; + uint_fast32_t rpy; + + pchg = pi->pchg; + if (!pi->prgvolfirst) { + goto skip; + } else { + pi->prgvolfirst = 0; + } + + for (pi->compno = pchg->compnostart, pi->picomp = + &pi->picomps[pi->compno]; pi->compno < pchg->compnoend; ++pi->compno, + ++pi->picomp) { + pirlvl = pi->picomp->pirlvls; + pi->xstep = pi->picomp->hsamp * (1 << (pirlvl->prcwidthexpn + + pi->picomp->numrlvls - 1)); + pi->ystep = pi->picomp->vsamp * (1 << (pirlvl->prcheightexpn + + pi->picomp->numrlvls - 1)); + for (rlvlno = 1, pirlvl = &pi->picomp->pirlvls[1]; + rlvlno < pi->picomp->numrlvls; ++rlvlno, ++pirlvl) { + pi->xstep = JAS_MIN(pi->xstep, pi->picomp->hsamp * (1 << + (pirlvl->prcwidthexpn + pi->picomp->numrlvls - + rlvlno - 1))); + pi->ystep = JAS_MIN(pi->ystep, pi->picomp->vsamp * (1 << + (pirlvl->prcheightexpn + pi->picomp->numrlvls - + rlvlno - 1))); + } + for (pi->y = pi->ystart; pi->y < pi->yend; + pi->y += pi->ystep - (pi->y % pi->ystep)) { + for (pi->x = pi->xstart; pi->x < pi->xend; + pi->x += pi->xstep - (pi->x % pi->xstep)) { + for (pi->rlvlno = pchg->rlvlnostart, + pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno]; + pi->rlvlno < pi->picomp->numrlvls && pi->rlvlno < + pchg->rlvlnoend; ++pi->rlvlno, ++pi->pirlvl) { + if (pi->pirlvl->numprcs == 0) { + continue; + } + r = pi->picomp->numrlvls - 1 - pi->rlvlno; + trx0 = JPC_CEILDIV(pi->xstart, pi->picomp->hsamp << r); + try0 = JPC_CEILDIV(pi->ystart, pi->picomp->vsamp << r); + rpx = r + pi->pirlvl->prcwidthexpn; + rpy = r + pi->pirlvl->prcheightexpn; + if (((pi->x == pi->xstart && ((trx0 << r) % (1 << rpx))) || + !(pi->x % (pi->picomp->hsamp << rpx))) && + ((pi->y == pi->ystart && ((try0 << r) % (1 << rpy))) || + !(pi->y % (pi->picomp->vsamp << rpy)))) { + prchind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->x, pi->picomp->hsamp + << r), pi->pirlvl->prcwidthexpn) - JPC_FLOORDIVPOW2(trx0, + pi->pirlvl->prcwidthexpn); + prcvind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->y, pi->picomp->vsamp + << r), pi->pirlvl->prcheightexpn) - JPC_FLOORDIVPOW2(try0, + pi->pirlvl->prcheightexpn); + pi->prcno = prcvind * + pi->pirlvl->numhprcs + + prchind; + assert(pi->prcno < + pi->pirlvl->numprcs); + for (pi->lyrno = 0; pi->lyrno < + pi->numlyrs && pi->lyrno < pchg->lyrnoend; ++pi->lyrno) { + prclyrno = &pi->pirlvl->prclyrnos[pi->prcno]; + if (pi->lyrno >= *prclyrno) { + ++(*prclyrno); + return 0; + } skip: - ; - } - } - } - } - } - } - return 1; + ; + } + } + } + } + } + } + return 1; } static void pirlvl_destroy(jpc_pirlvl_t *rlvl) { - if (rlvl->prclyrnos) { - jas_free(rlvl->prclyrnos); - } + if (rlvl->prclyrnos) { + jas_free(rlvl->prclyrnos); + } } static void jpc_picomp_destroy(jpc_picomp_t *picomp) { - int rlvlno; - jpc_pirlvl_t *pirlvl; - if (picomp->pirlvls) { - for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno < - picomp->numrlvls; ++rlvlno, ++pirlvl) { - pirlvl_destroy(pirlvl); - } - jas_free(picomp->pirlvls); - } + int rlvlno; + jpc_pirlvl_t *pirlvl; + if (picomp->pirlvls) { + for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno < + picomp->numrlvls; ++rlvlno, ++pirlvl) { + pirlvl_destroy(pirlvl); + } + jas_free(picomp->pirlvls); + } } void jpc_pi_destroy(jpc_pi_t *pi) { - jpc_picomp_t *picomp; - int compno; - if (pi->picomps) { - for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; - ++compno, ++picomp) { - jpc_picomp_destroy(picomp); - } - jas_free(pi->picomps); - } - if (pi->pchglist) { - jpc_pchglist_destroy(pi->pchglist); - } - jas_free(pi); + jpc_picomp_t *picomp; + int compno; + if (pi->picomps) { + for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; + ++compno, ++picomp) { + jpc_picomp_destroy(picomp); + } + jas_free(pi->picomps); + } + if (pi->pchglist) { + jpc_pchglist_destroy(pi->pchglist); + } + jas_free(pi); } jpc_pi_t *jpc_pi_create0(void) { - jpc_pi_t *pi; - if (!(pi = jas_malloc(sizeof(jpc_pi_t)))) { - return 0; - } - pi->picomps = 0; - pi->pchgno = 0; - if (!(pi->pchglist = jpc_pchglist_create())) { - jas_free(pi); - return 0; - } - return pi; + jpc_pi_t *pi; + if (!(pi = jas_malloc(sizeof(jpc_pi_t)))) { + return 0; + } + pi->picomps = 0; + pi->pchgno = 0; + if (!(pi->pchglist = jpc_pchglist_create())) { + jas_free(pi); + return 0; + } + return pi; } int jpc_pi_addpchg(jpc_pi_t *pi, jpc_pocpchg_t *pchg) { - return jpc_pchglist_insert(pi->pchglist, -1, pchg); + return jpc_pchglist_insert(pi->pchglist, -1, pchg); } jpc_pchglist_t *jpc_pchglist_create(void) { - jpc_pchglist_t *pchglist; - if (!(pchglist = jas_malloc(sizeof(jpc_pchglist_t)))) { - return 0; - } - pchglist->numpchgs = 0; - pchglist->maxpchgs = 0; - pchglist->pchgs = 0; - return pchglist; + jpc_pchglist_t *pchglist; + if (!(pchglist = jas_malloc(sizeof(jpc_pchglist_t)))) { + return 0; + } + pchglist->numpchgs = 0; + pchglist->maxpchgs = 0; + pchglist->pchgs = 0; + return pchglist; } int jpc_pchglist_insert(jpc_pchglist_t *pchglist, int pchgno, jpc_pchg_t *pchg) { - int i; - int newmaxpchgs; - jpc_pchg_t **newpchgs; - if (pchgno < 0) { - pchgno = pchglist->numpchgs; - } - if (pchglist->numpchgs >= pchglist->maxpchgs) { - newmaxpchgs = pchglist->maxpchgs + 128; - if (!(newpchgs = jas_realloc(pchglist->pchgs, newmaxpchgs * sizeof(jpc_pchg_t *)))) { - return -1; - } - pchglist->maxpchgs = newmaxpchgs; - pchglist->pchgs = newpchgs; - } - for (i = pchglist->numpchgs; i > pchgno; --i) { - pchglist->pchgs[i] = pchglist->pchgs[i - 1]; - } - pchglist->pchgs[pchgno] = pchg; - ++pchglist->numpchgs; - return 0; + int i; + int newmaxpchgs; + jpc_pchg_t **newpchgs; + if (pchgno < 0) { + pchgno = pchglist->numpchgs; + } + if (pchglist->numpchgs >= pchglist->maxpchgs) { + newmaxpchgs = pchglist->maxpchgs + 128; + if (!(newpchgs = jas_realloc(pchglist->pchgs, newmaxpchgs * sizeof(jpc_pchg_t *)))) { + return -1; + } + pchglist->maxpchgs = newmaxpchgs; + pchglist->pchgs = newpchgs; + } + for (i = pchglist->numpchgs; i > pchgno; --i) { + pchglist->pchgs[i] = pchglist->pchgs[i - 1]; + } + pchglist->pchgs[pchgno] = pchg; + ++pchglist->numpchgs; + return 0; } jpc_pchg_t *jpc_pchglist_remove(jpc_pchglist_t *pchglist, int pchgno) { - int i; - jpc_pchg_t *pchg; - assert(pchgno < pchglist->numpchgs); - pchg = pchglist->pchgs[pchgno]; - for (i = pchgno + 1; i < pchglist->numpchgs; ++i) { - pchglist->pchgs[i - 1] = pchglist->pchgs[i]; - } - --pchglist->numpchgs; - return pchg; + int i; + jpc_pchg_t *pchg; + assert(pchgno < pchglist->numpchgs); + pchg = pchglist->pchgs[pchgno]; + for (i = pchgno + 1; i < pchglist->numpchgs; ++i) { + pchglist->pchgs[i - 1] = pchglist->pchgs[i]; + } + --pchglist->numpchgs; + return pchg; } jpc_pchg_t *jpc_pchg_copy(jpc_pchg_t *pchg) { - jpc_pchg_t *newpchg; - if (!(newpchg = jas_malloc(sizeof(jpc_pchg_t)))) { - return 0; - } - *newpchg = *pchg; - return newpchg; + jpc_pchg_t *newpchg; + if (!(newpchg = jas_malloc(sizeof(jpc_pchg_t)))) { + return 0; + } + *newpchg = *pchg; + return newpchg; } jpc_pchglist_t *jpc_pchglist_copy(jpc_pchglist_t *pchglist) { - jpc_pchglist_t *newpchglist; - jpc_pchg_t *newpchg; - int pchgno; - if (!(newpchglist = jpc_pchglist_create())) { - return 0; - } - for (pchgno = 0; pchgno < pchglist->numpchgs; ++pchgno) { - if (!(newpchg = jpc_pchg_copy(pchglist->pchgs[pchgno])) || - jpc_pchglist_insert(newpchglist, -1, newpchg)) { - jpc_pchglist_destroy(newpchglist); - return 0; - } - } - return newpchglist; + jpc_pchglist_t *newpchglist; + jpc_pchg_t *newpchg; + int pchgno; + if (!(newpchglist = jpc_pchglist_create())) { + return 0; + } + for (pchgno = 0; pchgno < pchglist->numpchgs; ++pchgno) { + if (!(newpchg = jpc_pchg_copy(pchglist->pchgs[pchgno])) || + jpc_pchglist_insert(newpchglist, -1, newpchg)) { + jpc_pchglist_destroy(newpchglist); + return 0; + } + } + return newpchglist; } void jpc_pchglist_destroy(jpc_pchglist_t *pchglist) { - int pchgno; - if (pchglist->pchgs) { - for (pchgno = 0; pchgno < pchglist->numpchgs; ++pchgno) { - jpc_pchg_destroy(pchglist->pchgs[pchgno]); - } - jas_free(pchglist->pchgs); - } - jas_free(pchglist); + int pchgno; + if (pchglist->pchgs) { + for (pchgno = 0; pchgno < pchglist->numpchgs; ++pchgno) { + jpc_pchg_destroy(pchglist->pchgs[pchgno]); + } + jas_free(pchglist->pchgs); + } + jas_free(pchglist); } void jpc_pchg_destroy(jpc_pchg_t *pchg) { - jas_free(pchg); + jas_free(pchg); } jpc_pchg_t *jpc_pchglist_get(jpc_pchglist_t *pchglist, int pchgno) { - return pchglist->pchgs[pchgno]; + return pchglist->pchgs[pchgno]; } int jpc_pchglist_numpchgs(jpc_pchglist_t *pchglist) { - return pchglist->numpchgs; + return pchglist->numpchgs; } int jpc_pi_init(jpc_pi_t *pi) { - int compno; - int rlvlno; - int prcno; - jpc_picomp_t *picomp; - jpc_pirlvl_t *pirlvl; - int *prclyrno; - - pi->prgvolfirst = 0; - pi->valid = 0; - pi->pktno = -1; - pi->pchgno = -1; - pi->pchg = 0; - - for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; - ++compno, ++picomp) { - for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno < - picomp->numrlvls; ++rlvlno, ++pirlvl) { - for (prcno = 0, prclyrno = pirlvl->prclyrnos; - prcno < pirlvl->numprcs; ++prcno, ++prclyrno) { - *prclyrno = 0; - } - } - } - return 0; + int compno; + int rlvlno; + int prcno; + jpc_picomp_t *picomp; + jpc_pirlvl_t *pirlvl; + int *prclyrno; + + pi->prgvolfirst = 0; + pi->valid = 0; + pi->pktno = -1; + pi->pchgno = -1; + pi->pchg = 0; + + for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; + ++compno, ++picomp) { + for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno < + picomp->numrlvls; ++rlvlno, ++pirlvl) { + for (prcno = 0, prclyrno = pirlvl->prclyrnos; + prcno < pirlvl->numprcs; ++prcno, ++prclyrno) { + *prclyrno = 0; + } + } + } + return 0; } diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_t2cod.h b/converter/other/jpeg2000/libjasper/jpc/jpc_t2cod.h index 82dafcce..8e9b6b15 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_t2cod.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_t2cod.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -117,7 +117,7 @@ */ #ifndef JPC_T2COD_H -#define JPC_T2COD_H +#define JPC_T2COD_H /******************************************************************************\ * Includes. @@ -133,15 +133,15 @@ typedef struct { - /* The number of progression changes. */ - int numpchgs; + /* The number of progression changes. */ + int numpchgs; - /* The maximum number of progression changes that can be accommodated - without growing the progression change array. */ - int maxpchgs; + /* The maximum number of progression changes that can be accommodated + without growing the progression change array. */ + int maxpchgs; - /* The progression changes. */ - jpc_pchg_t **pchgs; + /* The progression changes. */ + jpc_pchg_t **pchgs; } jpc_pchglist_t; @@ -149,21 +149,21 @@ typedef struct { typedef struct { - /* The number of precincts. */ - int numprcs; + /* The number of precincts. */ + int numprcs; - /* The last layer processed for each precinct. */ - int *prclyrnos; + /* The last layer processed for each precinct. */ + int *prclyrnos; - /* The precinct width exponent. */ - int prcwidthexpn; + /* The precinct width exponent. */ + int prcwidthexpn; - /* The precinct height exponent. */ - int prcheightexpn; + /* The precinct height exponent. */ + int prcheightexpn; - /* The number of precincts spanning the resolution level in the horizontal - direction. */ - int numhprcs; + /* The number of precincts spanning the resolution level in the horizontal + direction. */ + int numhprcs; } jpc_pirlvl_t; @@ -171,17 +171,17 @@ typedef struct { typedef struct { - /* The number of resolution levels. */ - int numrlvls; + /* The number of resolution levels. */ + int numrlvls; - /* The per-resolution-level information. */ - jpc_pirlvl_t *pirlvls; + /* The per-resolution-level information. */ + jpc_pirlvl_t *pirlvls; - /* The horizontal sampling period. */ - int hsamp; + /* The horizontal sampling period. */ + int hsamp; - /* The vertical sampling period. */ - int vsamp; + /* The vertical sampling period. */ + int vsamp; } jpc_picomp_t; @@ -189,84 +189,84 @@ typedef struct { typedef struct { - /* The number of layers. */ - int numlyrs; + /* The number of layers. */ + int numlyrs; - /* The number of resolution levels. */ - int maxrlvls; + /* The number of resolution levels. */ + int maxrlvls; - /* The number of components. */ - int numcomps; + /* The number of components. */ + int numcomps; - /* The per-component information. */ - jpc_picomp_t *picomps; + /* The per-component information. */ + jpc_picomp_t *picomps; - /* The current component. */ - jpc_picomp_t *picomp; + /* The current component. */ + jpc_picomp_t *picomp; - /* The current resolution level. */ - jpc_pirlvl_t *pirlvl; + /* The current resolution level. */ + jpc_pirlvl_t *pirlvl; - /* The number of the current component. */ - int compno; + /* The number of the current component. */ + int compno; - /* The number of the current resolution level. */ - int rlvlno; + /* The number of the current resolution level. */ + int rlvlno; - /* The number of the current precinct. */ - int prcno; + /* The number of the current precinct. */ + int prcno; - /* The number of the current layer. */ - int lyrno; + /* The number of the current layer. */ + int lyrno; - /* The x-coordinate of the current position. */ - int x; + /* The x-coordinate of the current position. */ + int x; - /* The y-coordinate of the current position. */ - int y; + /* The y-coordinate of the current position. */ + int y; - /* The horizontal step size. */ - int xstep; + /* The horizontal step size. */ + int xstep; - /* The vertical step size. */ - int ystep; + /* The vertical step size. */ + int ystep; - /* The x-coordinate of the top-left corner of the tile on the reference - grid. */ - int xstart; + /* The x-coordinate of the top-left corner of the tile on the reference + grid. */ + int xstart; - /* The y-coordinate of the top-left corner of the tile on the reference - grid. */ - int ystart; + /* The y-coordinate of the top-left corner of the tile on the reference + grid. */ + int ystart; - /* The x-coordinate of the bottom-right corner of the tile on the - reference grid (plus one). */ - int xend; + /* The x-coordinate of the bottom-right corner of the tile on the + reference grid (plus one). */ + int xend; - /* The y-coordinate of the bottom-right corner of the tile on the - reference grid (plus one). */ - int yend; + /* The y-coordinate of the bottom-right corner of the tile on the + reference grid (plus one). */ + int yend; - /* The current progression change. */ - jpc_pchg_t *pchg; + /* The current progression change. */ + jpc_pchg_t *pchg; - /* The progression change list. */ - jpc_pchglist_t *pchglist; + /* The progression change list. */ + jpc_pchglist_t *pchglist; - /* The progression to use in the absence of explicit specification. */ - jpc_pchg_t defaultpchg; + /* The progression to use in the absence of explicit specification. */ + jpc_pchg_t defaultpchg; - /* The current progression change number. */ - int pchgno; + /* The current progression change number. */ + int pchgno; - /* Is this the first time in the current progression volume? */ - bool prgvolfirst; + /* Is this the first time in the current progression volume? */ + bool prgvolfirst; - /* Is the current iterator value valid? */ - bool valid; + /* Is the current iterator value valid? */ + bool valid; - /* The current packet number. */ - int pktno; + /* The current packet number. */ + int pktno; } jpc_pi_t; @@ -293,22 +293,22 @@ int jpc_pi_begin(jpc_pi_t *pi); int jpc_pi_next(jpc_pi_t *pi); /* Get the index of the current packet. */ -#define jpc_pi_getind(pi) ((pi)->pktno) +#define jpc_pi_getind(pi) ((pi)->pktno) /* Get the component number of the current packet. */ -#define jpc_pi_cmptno(pi) (assert(pi->valid), (pi)->compno) +#define jpc_pi_cmptno(pi) (assert(pi->valid), (pi)->compno) /* Get the resolution level of the current packet. */ -#define jpc_pi_rlvlno(pi) (assert(pi->valid), (pi)->rlvlno) +#define jpc_pi_rlvlno(pi) (assert(pi->valid), (pi)->rlvlno) /* Get the layer number of the current packet. */ -#define jpc_pi_lyrno(pi) (assert(pi->valid), (pi)->lyrno) +#define jpc_pi_lyrno(pi) (assert(pi->valid), (pi)->lyrno) /* Get the precinct number of the current packet. */ -#define jpc_pi_prcno(pi) (assert(pi->valid), (pi)->prcno) +#define jpc_pi_prcno(pi) (assert(pi->valid), (pi)->prcno) /* Get the progression order for the current packet. */ -#define jpc_pi_prg(pi) (assert(pi->valid), (pi)->pchg->prgord) +#define jpc_pi_prg(pi) (assert(pi->valid), (pi)->pchg->prgord) /******************************************************************************\ * Functions/macros for progression change lists. diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_t2dec.c b/converter/other/jpeg2000/libjasper/jpc/jpc_t2dec.c index 9aaaa55c..a05e1c10 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_t2dec.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_t2dec.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -155,305 +155,305 @@ static int jpc_dec_decodepkt(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_str static int jpc_getcommacode(jpc_bitstream_t *in) { - int n; - int v; - - n = 0; - for (;;) { - if ((v = jpc_bitstream_getbit(in)) < 0) { - return -1; - } - if (jpc_bitstream_eof(in)) { - return -1; - } - if (!v) { - break; - } - ++n; - } - - return n; + int n; + int v; + + n = 0; + for (;;) { + if ((v = jpc_bitstream_getbit(in)) < 0) { + return -1; + } + if (jpc_bitstream_eof(in)) { + return -1; + } + if (!v) { + break; + } + ++n; + } + + return n; } static int jpc_getnumnewpasses(jpc_bitstream_t *in) { - int n; - - if ((n = jpc_bitstream_getbit(in)) > 0) { - if ((n = jpc_bitstream_getbit(in)) > 0) { - if ((n = jpc_bitstream_getbits(in, 2)) == 3) { - if ((n = jpc_bitstream_getbits(in, 5)) == 31) { - if ((n = jpc_bitstream_getbits(in, 7)) >= 0) { - n += 36 + 1; - } - } else if (n >= 0) { - n += 5 + 1; - } - } else if (n >= 0) { - n += 2 + 1; - } - } else if (!n) { - n += 2; - } - } else if (!n) { - ++n; - } - - return n; + int n; + + if ((n = jpc_bitstream_getbit(in)) > 0) { + if ((n = jpc_bitstream_getbit(in)) > 0) { + if ((n = jpc_bitstream_getbits(in, 2)) == 3) { + if ((n = jpc_bitstream_getbits(in, 5)) == 31) { + if ((n = jpc_bitstream_getbits(in, 7)) >= 0) { + n += 36 + 1; + } + } else if (n >= 0) { + n += 5 + 1; + } + } else if (n >= 0) { + n += 2 + 1; + } + } else if (!n) { + n += 2; + } + } else if (!n) { + ++n; + } + + return n; } static int jpc_dec_decodepkt(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_stream_t *in, int compno, int rlvlno, int prcno, int lyrno) { - jpc_bitstream_t *inb; - jpc_dec_tcomp_t *tcomp; - jpc_dec_rlvl_t *rlvl; - jpc_dec_band_t *band; - jpc_dec_cblk_t *cblk; - int n; - int m; - int i; - jpc_tagtreenode_t *leaf; - int included; - int ret; - int numnewpasses; - jpc_dec_seg_t *seg; - int len; - int present; - int savenumnewpasses; - int mycounter; - jpc_ms_t *ms; - jpc_dec_tile_t *tile; - jpc_dec_ccp_t *ccp; - jpc_dec_cp_t *cp; - int bandno; - jpc_dec_prc_t *prc; - int usedcblkcnt; - int cblkno; - uint_fast32_t bodylen; - bool discard; - int passno; - int maxpasses; - int hdrlen; - int hdroffstart; - int hdroffend; - - discard = (lyrno >= dec->maxlyrs); - - tile = dec->curtile; - cp = tile->cp; - ccp = &cp->ccps[compno]; - - /* - * Decode the packet header. - */ - - /* Decode the SOP marker segment if present. */ - if (cp->csty & JPC_COD_SOP) { - if (jpc_dec_lookahead(in) == JPC_MS_SOP) { - if (!(ms = jpc_getms(in, dec->cstate))) { - return -1; - } - if (jpc_ms_gettype(ms) != JPC_MS_SOP) { - jpc_ms_destroy(ms); - fprintf(stderr, "missing SOP marker segment\n"); - return -1; - } - jpc_ms_destroy(ms); - } - } + jpc_bitstream_t *inb; + jpc_dec_tcomp_t *tcomp; + jpc_dec_rlvl_t *rlvl; + jpc_dec_band_t *band; + jpc_dec_cblk_t *cblk; + int n; + int m; + int i; + jpc_tagtreenode_t *leaf; + int included; + int ret; + int numnewpasses; + jpc_dec_seg_t *seg; + int len; + int present; + int savenumnewpasses; + int mycounter; + jpc_ms_t *ms; + jpc_dec_tile_t *tile; + jpc_dec_ccp_t *ccp; + jpc_dec_cp_t *cp; + int bandno; + jpc_dec_prc_t *prc; + int usedcblkcnt; + int cblkno; + uint_fast32_t bodylen; + bool discard; + int passno; + int maxpasses; + int hdrlen; + int hdroffstart; + int hdroffend; + + discard = (lyrno >= dec->maxlyrs); + + tile = dec->curtile; + cp = tile->cp; + ccp = &cp->ccps[compno]; + + /* + * Decode the packet header. + */ + + /* Decode the SOP marker segment if present. */ + if (cp->csty & JPC_COD_SOP) { + if (jpc_dec_lookahead(in) == JPC_MS_SOP) { + if (!(ms = jpc_getms(in, dec->cstate))) { + return -1; + } + if (jpc_ms_gettype(ms) != JPC_MS_SOP) { + jpc_ms_destroy(ms); + fprintf(stderr, "missing SOP marker segment\n"); + return -1; + } + jpc_ms_destroy(ms); + } + } hdroffstart = jas_stream_getrwcount(pkthdrstream); - if (!(inb = jpc_bitstream_sopen(pkthdrstream, "r"))) { - return -1; - } - - if ((present = jpc_bitstream_getbit(inb)) < 0) { - return 1; - } - JAS_DBGLOG(10, ("\n", present)); - JAS_DBGLOG(10, ("present=%d ", present)); - - /* Is the packet non-empty? */ - if (present) { - /* The packet is non-empty. */ - tcomp = &tile->tcomps[compno]; - rlvl = &tcomp->rlvls[rlvlno]; - bodylen = 0; - for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands; - ++bandno, ++band) { - if (!band->data) { - continue; - } - prc = &band->prcs[prcno]; - if (!prc->cblks) { - continue; - } - usedcblkcnt = 0; - for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks; - ++cblkno, ++cblk) { - ++usedcblkcnt; - if (!cblk->numpasses) { - leaf = jpc_tagtree_getleaf(prc->incltagtree, usedcblkcnt - 1); - if ((included = jpc_tagtree_decode(prc->incltagtree, leaf, lyrno + 1, inb)) < 0) { - return -1; - } - } else { - if ((included = jpc_bitstream_getbit(inb)) < 0) { - return -1; - } - } - JAS_DBGLOG(10, ("\n")); - JAS_DBGLOG(10, ("included=%d ", included)); - if (!included) { - continue; - } - if (!cblk->numpasses) { - i = 1; - leaf = jpc_tagtree_getleaf(prc->numimsbstagtree, usedcblkcnt - 1); - for (;;) { - if ((ret = jpc_tagtree_decode(prc->numimsbstagtree, leaf, i, inb)) < 0) { - return -1; - } - if (ret) { - break; - } - ++i; - } - cblk->numimsbs = i - 1; - cblk->firstpassno = cblk->numimsbs * 3; - } - if ((numnewpasses = jpc_getnumnewpasses(inb)) < 0) { - return -1; - } - JAS_DBGLOG(10, ("numnewpasses=%d ", numnewpasses)); - seg = cblk->curseg; - savenumnewpasses = numnewpasses; - mycounter = 0; - if (numnewpasses > 0) { - if ((m = jpc_getcommacode(inb)) < 0) { - return -1; - } - cblk->numlenbits += m; - JAS_DBGLOG(10, ("increment=%d ", m)); - while (numnewpasses > 0) { - passno = cblk->firstpassno + cblk->numpasses + mycounter; - /* XXX - the maxpasses is not set precisely but this doesn't matter... */ - maxpasses = JPC_SEGPASSCNT(passno, cblk->firstpassno, 10000, (ccp->cblkctx & JPC_COX_LAZY) != 0, (ccp->cblkctx & JPC_COX_TERMALL) != 0); - if (!discard && !seg) { - if (!(seg = jpc_seg_alloc())) { - return -1; - } - jpc_seglist_insert(&cblk->segs, cblk->segs.tail, seg); - if (!cblk->curseg) { - cblk->curseg = seg; - } - seg->passno = passno; - seg->type = JPC_SEGTYPE(seg->passno, cblk->firstpassno, (ccp->cblkctx & JPC_COX_LAZY) != 0); - seg->maxpasses = maxpasses; - } - n = JAS_MIN(numnewpasses, maxpasses); - mycounter += n; - numnewpasses -= n; - if ((len = jpc_bitstream_getbits(inb, cblk->numlenbits + jpc_floorlog2(n))) < 0) { - return -1; - } - JAS_DBGLOG(10, ("len=%d ", len)); - if (!discard) { - seg->lyrno = lyrno; - seg->numpasses += n; - seg->cnt = len; - seg = seg->next; - } - bodylen += len; - } - } - cblk->numpasses += savenumnewpasses; - } - } - - jpc_bitstream_inalign(inb, 0, 0); - - } else { - if (jpc_bitstream_inalign(inb, 0x7f, 0)) { - fprintf(stderr, "alignment failed\n"); - return -1; - } - } - jpc_bitstream_close(inb); - - hdroffend = jas_stream_getrwcount(pkthdrstream); - hdrlen = hdroffend - hdroffstart; - if (jas_getdbglevel() >= 5) { - fprintf(stderr, "hdrlen=%lu bodylen=%lu \n", (unsigned long) hdrlen, - (unsigned long) bodylen); - } - - if (cp->csty & JPC_COD_EPH) { - if (jpc_dec_lookahead(pkthdrstream) == JPC_MS_EPH) { - if (!(ms = jpc_getms(pkthdrstream, dec->cstate))) { - fprintf(stderr, "cannot get (EPH) marker segment\n"); - return -1; - } - if (jpc_ms_gettype(ms) != JPC_MS_EPH) { - jpc_ms_destroy(ms); - fprintf(stderr, "missing EPH marker segment\n"); - return -1; - } - jpc_ms_destroy(ms); - } - } - - /* decode the packet body. */ - - if (jas_getdbglevel() >= 1) { - fprintf(stderr, "packet body offset=%06ld\n", (long) jas_stream_getrwcount(in)); - } - - if (!discard) { - tcomp = &tile->tcomps[compno]; - rlvl = &tcomp->rlvls[rlvlno]; - for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands; - ++bandno, ++band) { - if (!band->data) { - continue; - } - prc = &band->prcs[prcno]; - if (!prc->cblks) { - continue; - } - for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks; - ++cblkno, ++cblk) { - seg = cblk->curseg; - while (seg) { - if (!seg->stream) { - if (!(seg->stream = jas_stream_memopen(0, 0))) { - return -1; - } - } + if (!(inb = jpc_bitstream_sopen(pkthdrstream, "r"))) { + return -1; + } + + if ((present = jpc_bitstream_getbit(inb)) < 0) { + return 1; + } + JAS_DBGLOG(10, ("\n", present)); + JAS_DBGLOG(10, ("present=%d ", present)); + + /* Is the packet non-empty? */ + if (present) { + /* The packet is non-empty. */ + tcomp = &tile->tcomps[compno]; + rlvl = &tcomp->rlvls[rlvlno]; + bodylen = 0; + for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands; + ++bandno, ++band) { + if (!band->data) { + continue; + } + prc = &band->prcs[prcno]; + if (!prc->cblks) { + continue; + } + usedcblkcnt = 0; + for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks; + ++cblkno, ++cblk) { + ++usedcblkcnt; + if (!cblk->numpasses) { + leaf = jpc_tagtree_getleaf(prc->incltagtree, usedcblkcnt - 1); + if ((included = jpc_tagtree_decode(prc->incltagtree, leaf, lyrno + 1, inb)) < 0) { + return -1; + } + } else { + if ((included = jpc_bitstream_getbit(inb)) < 0) { + return -1; + } + } + JAS_DBGLOG(10, ("\n")); + JAS_DBGLOG(10, ("included=%d ", included)); + if (!included) { + continue; + } + if (!cblk->numpasses) { + i = 1; + leaf = jpc_tagtree_getleaf(prc->numimsbstagtree, usedcblkcnt - 1); + for (;;) { + if ((ret = jpc_tagtree_decode(prc->numimsbstagtree, leaf, i, inb)) < 0) { + return -1; + } + if (ret) { + break; + } + ++i; + } + cblk->numimsbs = i - 1; + cblk->firstpassno = cblk->numimsbs * 3; + } + if ((numnewpasses = jpc_getnumnewpasses(inb)) < 0) { + return -1; + } + JAS_DBGLOG(10, ("numnewpasses=%d ", numnewpasses)); + seg = cblk->curseg; + savenumnewpasses = numnewpasses; + mycounter = 0; + if (numnewpasses > 0) { + if ((m = jpc_getcommacode(inb)) < 0) { + return -1; + } + cblk->numlenbits += m; + JAS_DBGLOG(10, ("increment=%d ", m)); + while (numnewpasses > 0) { + passno = cblk->firstpassno + cblk->numpasses + mycounter; + /* XXX - the maxpasses is not set precisely but this doesn't matter... */ + maxpasses = JPC_SEGPASSCNT(passno, cblk->firstpassno, 10000, (ccp->cblkctx & JPC_COX_LAZY) != 0, (ccp->cblkctx & JPC_COX_TERMALL) != 0); + if (!discard && !seg) { + if (!(seg = jpc_seg_alloc())) { + return -1; + } + jpc_seglist_insert(&cblk->segs, cblk->segs.tail, seg); + if (!cblk->curseg) { + cblk->curseg = seg; + } + seg->passno = passno; + seg->type = JPC_SEGTYPE(seg->passno, cblk->firstpassno, (ccp->cblkctx & JPC_COX_LAZY) != 0); + seg->maxpasses = maxpasses; + } + n = JAS_MIN(numnewpasses, maxpasses); + mycounter += n; + numnewpasses -= n; + if ((len = jpc_bitstream_getbits(inb, cblk->numlenbits + jpc_floorlog2(n))) < 0) { + return -1; + } + JAS_DBGLOG(10, ("len=%d ", len)); + if (!discard) { + seg->lyrno = lyrno; + seg->numpasses += n; + seg->cnt = len; + seg = seg->next; + } + bodylen += len; + } + } + cblk->numpasses += savenumnewpasses; + } + } + + jpc_bitstream_inalign(inb, 0, 0); + + } else { + if (jpc_bitstream_inalign(inb, 0x7f, 0)) { + fprintf(stderr, "alignment failed\n"); + return -1; + } + } + jpc_bitstream_close(inb); + + hdroffend = jas_stream_getrwcount(pkthdrstream); + hdrlen = hdroffend - hdroffstart; + if (jas_getdbglevel() >= 5) { + fprintf(stderr, "hdrlen=%lu bodylen=%lu \n", (unsigned long) hdrlen, + (unsigned long) bodylen); + } + + if (cp->csty & JPC_COD_EPH) { + if (jpc_dec_lookahead(pkthdrstream) == JPC_MS_EPH) { + if (!(ms = jpc_getms(pkthdrstream, dec->cstate))) { + fprintf(stderr, "cannot get (EPH) marker segment\n"); + return -1; + } + if (jpc_ms_gettype(ms) != JPC_MS_EPH) { + jpc_ms_destroy(ms); + fprintf(stderr, "missing EPH marker segment\n"); + return -1; + } + jpc_ms_destroy(ms); + } + } + + /* decode the packet body. */ + + if (jas_getdbglevel() >= 1) { + fprintf(stderr, "packet body offset=%06ld\n", (long) jas_stream_getrwcount(in)); + } + + if (!discard) { + tcomp = &tile->tcomps[compno]; + rlvl = &tcomp->rlvls[rlvlno]; + for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands; + ++bandno, ++band) { + if (!band->data) { + continue; + } + prc = &band->prcs[prcno]; + if (!prc->cblks) { + continue; + } + for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks; + ++cblkno, ++cblk) { + seg = cblk->curseg; + while (seg) { + if (!seg->stream) { + if (!(seg->stream = jas_stream_memopen(0, 0))) { + return -1; + } + } #if 0 fprintf(stderr, "lyrno=%02d, compno=%02d, lvlno=%02d, prcno=%02d, bandno=%02d, cblkno=%02d, passno=%02d numpasses=%02d cnt=%d numbps=%d, numimsbs=%d\n", lyrno, compno, rlvlno, prcno, band - rlvl->bands, cblk - prc->cblks, seg->passno, seg->numpasses, seg->cnt, band->numbps, cblk->numimsbs); #endif - if (seg->cnt > 0) { - if (jpc_getdata(in, seg->stream, seg->cnt) < 0) { - return -1; - } - seg->cnt = 0; - } - if (seg->numpasses >= seg->maxpasses) { - cblk->curseg = seg->next; - } - seg = seg->next; - } - } - } - } else { - if (jas_stream_gobble(in, bodylen) != bodylen) { - return -1; - } - } - return 0; + if (seg->cnt > 0) { + if (jpc_getdata(in, seg->stream, seg->cnt) < 0) { + return -1; + } + seg->cnt = 0; + } + if (seg->numpasses >= seg->maxpasses) { + cblk->curseg = seg->next; + } + seg = seg->next; + } + } + } + } else { + if (jas_stream_gobble(in, bodylen) != bodylen) { + return -1; + } + } + return 0; } /********************************************************************************************/ @@ -461,166 +461,166 @@ fprintf(stderr, "lyrno=%02d, compno=%02d, lvlno=%02d, prcno=%02d, bandno=%02d, c int jpc_dec_decodepkts(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_stream_t *in) { - jpc_dec_tile_t *tile; - jpc_pi_t *pi; - int ret; + jpc_dec_tile_t *tile; + jpc_pi_t *pi; + int ret; - tile = dec->curtile; - pi = tile->pi; - for (;;) { + tile = dec->curtile; + pi = tile->pi; + for (;;) { if (!tile->pkthdrstream || jas_stream_peekc(tile->pkthdrstream) == EOF) { - switch (jpc_dec_lookahead(in)) { - case JPC_MS_EOC: - case JPC_MS_SOT: - return 0; - break; - case JPC_MS_SOP: - case JPC_MS_EPH: - case 0: - break; - default: - return -1; - break; - } + switch (jpc_dec_lookahead(in)) { + case JPC_MS_EOC: + case JPC_MS_SOT: + return 0; + break; + case JPC_MS_SOP: + case JPC_MS_EPH: + case 0: + break; + default: + return -1; + break; + } } - if ((ret = jpc_pi_next(pi))) { - return ret; - } + if ((ret = jpc_pi_next(pi))) { + return ret; + } if (dec->maxpkts >= 0 && dec->numpkts >= dec->maxpkts) { - fprintf(stderr, "warning: stopping decode prematurely as requested\n"); - return 0; + fprintf(stderr, "warning: stopping decode prematurely as requested\n"); + return 0; } - if (jas_getdbglevel() >= 1) { - fprintf(stderr, "packet offset=%08ld prg=%d cmptno=%02d " - "rlvlno=%02d prcno=%03d lyrno=%02d\n", (long) - jas_stream_getrwcount(in), jpc_pi_prg(pi), jpc_pi_cmptno(pi), - jpc_pi_rlvlno(pi), jpc_pi_prcno(pi), jpc_pi_lyrno(pi)); - } - if (jpc_dec_decodepkt(dec, pkthdrstream, in, jpc_pi_cmptno(pi), jpc_pi_rlvlno(pi), - jpc_pi_prcno(pi), jpc_pi_lyrno(pi))) { - return -1; - } + if (jas_getdbglevel() >= 1) { + fprintf(stderr, "packet offset=%08ld prg=%d cmptno=%02d " + "rlvlno=%02d prcno=%03d lyrno=%02d\n", (long) + jas_stream_getrwcount(in), jpc_pi_prg(pi), jpc_pi_cmptno(pi), + jpc_pi_rlvlno(pi), jpc_pi_prcno(pi), jpc_pi_lyrno(pi)); + } + if (jpc_dec_decodepkt(dec, pkthdrstream, in, jpc_pi_cmptno(pi), jpc_pi_rlvlno(pi), + jpc_pi_prcno(pi), jpc_pi_lyrno(pi))) { + return -1; + } ++dec->numpkts; - } + } - return 0; + return 0; } jpc_pi_t *jpc_dec_pi_create(jpc_dec_t *dec, jpc_dec_tile_t *tile) { - jpc_pi_t *pi; - int compno; - jpc_picomp_t *picomp; - jpc_pirlvl_t *pirlvl; - jpc_dec_tcomp_t *tcomp; - int rlvlno; - jpc_dec_rlvl_t *rlvl; - int prcno; - int *prclyrno; - jpc_dec_cmpt_t *cmpt; - - if (!(pi = jpc_pi_create0())) { - return 0; - } - pi->numcomps = dec->numcomps; - if (!(pi->picomps = jas_malloc(pi->numcomps * sizeof(jpc_picomp_t)))) { - jpc_pi_destroy(pi); - return 0; - } - for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; ++compno, - ++picomp) { - picomp->pirlvls = 0; - } - - for (compno = 0, tcomp = tile->tcomps, picomp = pi->picomps; - compno < pi->numcomps; ++compno, ++tcomp, ++picomp) { - picomp->numrlvls = tcomp->numrlvls; - if (!(picomp->pirlvls = jas_malloc(picomp->numrlvls * - sizeof(jpc_pirlvl_t)))) { - jpc_pi_destroy(pi); - return 0; - } - for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno < - picomp->numrlvls; ++rlvlno, ++pirlvl) { - pirlvl->prclyrnos = 0; - } - for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls; - rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) { + jpc_pi_t *pi; + int compno; + jpc_picomp_t *picomp; + jpc_pirlvl_t *pirlvl; + jpc_dec_tcomp_t *tcomp; + int rlvlno; + jpc_dec_rlvl_t *rlvl; + int prcno; + int *prclyrno; + jpc_dec_cmpt_t *cmpt; + + if (!(pi = jpc_pi_create0())) { + return 0; + } + pi->numcomps = dec->numcomps; + if (!(pi->picomps = jas_malloc(pi->numcomps * sizeof(jpc_picomp_t)))) { + jpc_pi_destroy(pi); + return 0; + } + for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; ++compno, + ++picomp) { + picomp->pirlvls = 0; + } + + for (compno = 0, tcomp = tile->tcomps, picomp = pi->picomps; + compno < pi->numcomps; ++compno, ++tcomp, ++picomp) { + picomp->numrlvls = tcomp->numrlvls; + if (!(picomp->pirlvls = jas_malloc(picomp->numrlvls * + sizeof(jpc_pirlvl_t)))) { + jpc_pi_destroy(pi); + return 0; + } + for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno < + picomp->numrlvls; ++rlvlno, ++pirlvl) { + pirlvl->prclyrnos = 0; + } + for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls; + rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) { /* XXX sizeof(long) should be sizeof different type */ - pirlvl->numprcs = rlvl->numprcs; - if (!(pirlvl->prclyrnos = jas_malloc(pirlvl->numprcs * - sizeof(long)))) { - jpc_pi_destroy(pi); - return 0; - } - } - } - - pi->maxrlvls = 0; - for (compno = 0, tcomp = tile->tcomps, picomp = pi->picomps, cmpt = - dec->cmpts; compno < pi->numcomps; ++compno, ++tcomp, ++picomp, - ++cmpt) { - picomp->hsamp = cmpt->hstep; - picomp->vsamp = cmpt->vstep; - for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls; - rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) { - pirlvl->prcwidthexpn = rlvl->prcwidthexpn; - pirlvl->prcheightexpn = rlvl->prcheightexpn; - for (prcno = 0, prclyrno = pirlvl->prclyrnos; - prcno < pirlvl->numprcs; ++prcno, ++prclyrno) { - *prclyrno = 0; - } - pirlvl->numhprcs = rlvl->numhprcs; - } - if (pi->maxrlvls < tcomp->numrlvls) { - pi->maxrlvls = tcomp->numrlvls; - } - } - - pi->numlyrs = tile->cp->numlyrs; - pi->xstart = tile->xstart; - pi->ystart = tile->ystart; - pi->xend = tile->xend; - pi->yend = tile->yend; - - pi->picomp = 0; - pi->pirlvl = 0; - pi->x = 0; - pi->y = 0; - pi->compno = 0; - pi->rlvlno = 0; - pi->prcno = 0; - pi->lyrno = 0; - pi->xstep = 0; - pi->ystep = 0; - - pi->pchgno = -1; - - pi->defaultpchg.prgord = tile->cp->prgord; - pi->defaultpchg.compnostart = 0; - pi->defaultpchg.compnoend = pi->numcomps; - pi->defaultpchg.rlvlnostart = 0; - pi->defaultpchg.rlvlnoend = pi->maxrlvls; - pi->defaultpchg.lyrnoend = pi->numlyrs; - pi->pchg = 0; - - pi->valid = 0; - - return pi; + pirlvl->numprcs = rlvl->numprcs; + if (!(pirlvl->prclyrnos = jas_malloc(pirlvl->numprcs * + sizeof(long)))) { + jpc_pi_destroy(pi); + return 0; + } + } + } + + pi->maxrlvls = 0; + for (compno = 0, tcomp = tile->tcomps, picomp = pi->picomps, cmpt = + dec->cmpts; compno < pi->numcomps; ++compno, ++tcomp, ++picomp, + ++cmpt) { + picomp->hsamp = cmpt->hstep; + picomp->vsamp = cmpt->vstep; + for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls; + rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) { + pirlvl->prcwidthexpn = rlvl->prcwidthexpn; + pirlvl->prcheightexpn = rlvl->prcheightexpn; + for (prcno = 0, prclyrno = pirlvl->prclyrnos; + prcno < pirlvl->numprcs; ++prcno, ++prclyrno) { + *prclyrno = 0; + } + pirlvl->numhprcs = rlvl->numhprcs; + } + if (pi->maxrlvls < tcomp->numrlvls) { + pi->maxrlvls = tcomp->numrlvls; + } + } + + pi->numlyrs = tile->cp->numlyrs; + pi->xstart = tile->xstart; + pi->ystart = tile->ystart; + pi->xend = tile->xend; + pi->yend = tile->yend; + + pi->picomp = 0; + pi->pirlvl = 0; + pi->x = 0; + pi->y = 0; + pi->compno = 0; + pi->rlvlno = 0; + pi->prcno = 0; + pi->lyrno = 0; + pi->xstep = 0; + pi->ystep = 0; + + pi->pchgno = -1; + + pi->defaultpchg.prgord = tile->cp->prgord; + pi->defaultpchg.compnostart = 0; + pi->defaultpchg.compnoend = pi->numcomps; + pi->defaultpchg.rlvlnostart = 0; + pi->defaultpchg.rlvlnoend = pi->maxrlvls; + pi->defaultpchg.lyrnoend = pi->numlyrs; + pi->pchg = 0; + + pi->valid = 0; + + return pi; } long jpc_dec_lookahead(jas_stream_t *in) { - uint_fast16_t x; - if (jpc_getuint16(in, &x)) { - return -1; - } - if (jas_stream_ungetc(in, x & 0xff) == EOF || - jas_stream_ungetc(in, x >> 8) == EOF) { - return -1; - } - if (x >= JPC_MS_INMIN && x <= JPC_MS_INMAX) { - return x; - } - return 0; + uint_fast16_t x; + if (jpc_getuint16(in, &x)) { + return -1; + } + if (jas_stream_ungetc(in, x & 0xff) == EOF || + jas_stream_ungetc(in, x >> 8) == EOF) { + return -1; + } + if (x >= JPC_MS_INMIN && x <= JPC_MS_INMAX) { + return x; + } + return 0; } diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_t2dec.h b/converter/other/jpeg2000/libjasper/jpc/jpc_t2dec.h index 923d7c1a..8e94232a 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_t2dec.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_t2dec.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_t2enc.c b/converter/other/jpeg2000/libjasper/jpc/jpc_t2enc.c index 1444dc7b..2d03cb29 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_t2enc.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_t2enc.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -142,563 +142,563 @@ static int jpc_putcommacode(jpc_bitstream_t *out, int n) { - assert(n >= 0); - - while (--n >= 0) { - if (jpc_bitstream_putbit(out, 1) == EOF) { - return -1; - } - } - if (jpc_bitstream_putbit(out, 0) == EOF) { - return -1; - } - return 0; + assert(n >= 0); + + while (--n >= 0) { + if (jpc_bitstream_putbit(out, 1) == EOF) { + return -1; + } + } + if (jpc_bitstream_putbit(out, 0) == EOF) { + return -1; + } + return 0; } static int jpc_putnumnewpasses(jpc_bitstream_t *out, int n) { - int ret; - - if (n <= 0) { - return -1; - } else if (n == 1) { - ret = jpc_bitstream_putbit(out, 0); - } else if (n == 2) { - ret = jpc_bitstream_putbits(out, 2, 2); - } else if (n <= 5) { - ret = jpc_bitstream_putbits(out, 4, 0xc | (n - 3)); - } else if (n <= 36) { - ret = jpc_bitstream_putbits(out, 9, 0x1e0 | (n - 6)); - } else if (n <= 164) { - ret = jpc_bitstream_putbits(out, 16, 0xff80 | (n - 37)); - } else { - /* The standard has no provision for encoding a larger value. - In practice, however, it is highly unlikely that this - limitation will ever be encountered. */ - return -1; - } - - return (ret != EOF) ? 0 : (-1); + int ret; + + if (n <= 0) { + return -1; + } else if (n == 1) { + ret = jpc_bitstream_putbit(out, 0); + } else if (n == 2) { + ret = jpc_bitstream_putbits(out, 2, 2); + } else if (n <= 5) { + ret = jpc_bitstream_putbits(out, 4, 0xc | (n - 3)); + } else if (n <= 36) { + ret = jpc_bitstream_putbits(out, 9, 0x1e0 | (n - 6)); + } else if (n <= 164) { + ret = jpc_bitstream_putbits(out, 16, 0xff80 | (n - 37)); + } else { + /* The standard has no provision for encoding a larger value. + In practice, however, it is highly unlikely that this + limitation will ever be encountered. */ + return -1; + } + + return (ret != EOF) ? 0 : (-1); } int jpc_enc_encpkts(jpc_enc_t *enc, jas_stream_t *out) { - jpc_enc_tile_t *tile; - jpc_pi_t *pi; - - tile = enc->curtile; - - jpc_init_t2state(enc, 0); - pi = tile->pi; - jpc_pi_init(pi); - - if (!jpc_pi_next(pi)) { - for (;;) { - if (jpc_enc_encpkt(enc, out, jpc_pi_cmptno(pi), jpc_pi_rlvlno(pi), - jpc_pi_prcno(pi), jpc_pi_lyrno(pi))) { - return -1; - } - if (jpc_pi_next(pi)) { - break; - } - } - } - - return 0; + jpc_enc_tile_t *tile; + jpc_pi_t *pi; + + tile = enc->curtile; + + jpc_init_t2state(enc, 0); + pi = tile->pi; + jpc_pi_init(pi); + + if (!jpc_pi_next(pi)) { + for (;;) { + if (jpc_enc_encpkt(enc, out, jpc_pi_cmptno(pi), jpc_pi_rlvlno(pi), + jpc_pi_prcno(pi), jpc_pi_lyrno(pi))) { + return -1; + } + if (jpc_pi_next(pi)) { + break; + } + } + } + + return 0; } int jpc_enc_encpkt(jpc_enc_t *enc, jas_stream_t *out, int compno, int lvlno, int prcno, int lyrno) { - jpc_enc_tcmpt_t *comp; - jpc_enc_rlvl_t *lvl; - jpc_enc_band_t *band; - jpc_enc_band_t *endbands; - jpc_enc_cblk_t *cblk; - jpc_enc_cblk_t *endcblks; - jpc_bitstream_t *outb; - jpc_enc_pass_t *pass; - jpc_enc_pass_t *startpass; - jpc_enc_pass_t *lastpass; - jpc_enc_pass_t *endpass; - jpc_enc_pass_t *endpasses; - int i; - int included; - int ret; - jpc_tagtreenode_t *leaf; - int n; - int t1; - int t2; - int adjust; - int maxadjust; - int datalen; - int numnewpasses; - int passcount; - jpc_enc_tile_t *tile; - jpc_enc_prc_t *prc; - jpc_enc_cp_t *cp; - jpc_ms_t *ms; - - tile = enc->curtile; - cp = enc->cp; - - if (cp->tcp.csty & JPC_COD_SOP) { - if (!(ms = jpc_ms_create(JPC_MS_SOP))) { - return -1; - } - ms->parms.sop.seqno = jpc_pi_getind(tile->pi); - if (jpc_putms(out, enc->cstate, ms)) { - return -1; - } - jpc_ms_destroy(ms); - } - - outb = jpc_bitstream_sopen(out, "w+"); - assert(outb); - - if (jpc_bitstream_putbit(outb, 1) == EOF) { - return -1; - } - JAS_DBGLOG(10, ("\n")); - JAS_DBGLOG(10, ("present. ")); - - comp = &tile->tcmpts[compno]; - lvl = &comp->rlvls[lvlno]; - endbands = &lvl->bands[lvl->numbands]; - for (band = lvl->bands; band != endbands; ++band) { - if (!band->data) { - continue; - } - prc = &band->prcs[prcno]; - if (!prc->cblks) { - continue; - } - - endcblks = &prc->cblks[prc->numcblks]; - for (cblk = prc->cblks; cblk != endcblks; ++cblk) { - if (!lyrno) { - leaf = jpc_tagtree_getleaf(prc->nlibtree, cblk - prc->cblks); - jpc_tagtree_setvalue(prc->nlibtree, leaf, cblk->numimsbs); - } - pass = cblk->curpass; - included = (pass && pass->lyrno == lyrno); - if (included && (!cblk->numencpasses)) { - assert(pass->lyrno == lyrno); - leaf = jpc_tagtree_getleaf(prc->incltree, - cblk - prc->cblks); - jpc_tagtree_setvalue(prc->incltree, leaf, pass->lyrno); - } - } - - endcblks = &prc->cblks[prc->numcblks]; - for (cblk = prc->cblks; cblk != endcblks; ++cblk) { - pass = cblk->curpass; - included = (pass && pass->lyrno == lyrno); - if (!cblk->numencpasses) { - leaf = jpc_tagtree_getleaf(prc->incltree, - cblk - prc->cblks); - if (jpc_tagtree_encode(prc->incltree, leaf, lyrno - + 1, outb) < 0) { - return -1; - } - } else { - if (jpc_bitstream_putbit(outb, included) == EOF) { - return -1; - } - } - JAS_DBGLOG(10, ("included=%d ", included)); - if (!included) { - continue; - } - if (!cblk->numencpasses) { - i = 1; - leaf = jpc_tagtree_getleaf(prc->nlibtree, cblk - prc->cblks); - for (;;) { - if ((ret = jpc_tagtree_encode(prc->nlibtree, leaf, i, outb)) < 0) { - return -1; - } - if (ret) { - break; - } - ++i; - } - assert(leaf->known_ && i == leaf->value_ + 1); - } - - endpasses = &cblk->passes[cblk->numpasses]; - startpass = pass; - endpass = startpass; - while (endpass != endpasses && endpass->lyrno == lyrno){ - ++endpass; - } - numnewpasses = endpass - startpass; - if (jpc_putnumnewpasses(outb, numnewpasses)) { - return -1; - } - JAS_DBGLOG(10, ("numnewpasses=%d ", numnewpasses)); - - lastpass = endpass - 1; - n = startpass->start; - passcount = 1; - maxadjust = 0; - for (pass = startpass; pass != endpass; ++pass) { - if (pass->term || pass == lastpass) { - datalen = pass->end - n; - t1 = jpc_firstone(datalen) + 1; - t2 = cblk->numlenbits + jpc_floorlog2(passcount); - adjust = JAS_MAX(t1 - t2, 0); - maxadjust = JAS_MAX(adjust, maxadjust); - n += datalen; - passcount = 1; - } else { - ++passcount; - } - } - if (jpc_putcommacode(outb, maxadjust)) { - return -1; - } - cblk->numlenbits += maxadjust; - - lastpass = endpass - 1; - n = startpass->start; - passcount = 1; - for (pass = startpass; pass != endpass; ++pass) { - if (pass->term || pass == lastpass) { - datalen = pass->end - n; + jpc_enc_tcmpt_t *comp; + jpc_enc_rlvl_t *lvl; + jpc_enc_band_t *band; + jpc_enc_band_t *endbands; + jpc_enc_cblk_t *cblk; + jpc_enc_cblk_t *endcblks; + jpc_bitstream_t *outb; + jpc_enc_pass_t *pass; + jpc_enc_pass_t *startpass; + jpc_enc_pass_t *lastpass; + jpc_enc_pass_t *endpass; + jpc_enc_pass_t *endpasses; + int i; + int included; + int ret; + jpc_tagtreenode_t *leaf; + int n; + int t1; + int t2; + int adjust; + int maxadjust; + int datalen; + int numnewpasses; + int passcount; + jpc_enc_tile_t *tile; + jpc_enc_prc_t *prc; + jpc_enc_cp_t *cp; + jpc_ms_t *ms; + + tile = enc->curtile; + cp = enc->cp; + + if (cp->tcp.csty & JPC_COD_SOP) { + if (!(ms = jpc_ms_create(JPC_MS_SOP))) { + return -1; + } + ms->parms.sop.seqno = jpc_pi_getind(tile->pi); + if (jpc_putms(out, enc->cstate, ms)) { + return -1; + } + jpc_ms_destroy(ms); + } + + outb = jpc_bitstream_sopen(out, "w+"); + assert(outb); + + if (jpc_bitstream_putbit(outb, 1) == EOF) { + return -1; + } + JAS_DBGLOG(10, ("\n")); + JAS_DBGLOG(10, ("present. ")); + + comp = &tile->tcmpts[compno]; + lvl = &comp->rlvls[lvlno]; + endbands = &lvl->bands[lvl->numbands]; + for (band = lvl->bands; band != endbands; ++band) { + if (!band->data) { + continue; + } + prc = &band->prcs[prcno]; + if (!prc->cblks) { + continue; + } + + endcblks = &prc->cblks[prc->numcblks]; + for (cblk = prc->cblks; cblk != endcblks; ++cblk) { + if (!lyrno) { + leaf = jpc_tagtree_getleaf(prc->nlibtree, cblk - prc->cblks); + jpc_tagtree_setvalue(prc->nlibtree, leaf, cblk->numimsbs); + } + pass = cblk->curpass; + included = (pass && pass->lyrno == lyrno); + if (included && (!cblk->numencpasses)) { + assert(pass->lyrno == lyrno); + leaf = jpc_tagtree_getleaf(prc->incltree, + cblk - prc->cblks); + jpc_tagtree_setvalue(prc->incltree, leaf, pass->lyrno); + } + } + + endcblks = &prc->cblks[prc->numcblks]; + for (cblk = prc->cblks; cblk != endcblks; ++cblk) { + pass = cblk->curpass; + included = (pass && pass->lyrno == lyrno); + if (!cblk->numencpasses) { + leaf = jpc_tagtree_getleaf(prc->incltree, + cblk - prc->cblks); + if (jpc_tagtree_encode(prc->incltree, leaf, lyrno + + 1, outb) < 0) { + return -1; + } + } else { + if (jpc_bitstream_putbit(outb, included) == EOF) { + return -1; + } + } + JAS_DBGLOG(10, ("included=%d ", included)); + if (!included) { + continue; + } + if (!cblk->numencpasses) { + i = 1; + leaf = jpc_tagtree_getleaf(prc->nlibtree, cblk - prc->cblks); + for (;;) { + if ((ret = jpc_tagtree_encode(prc->nlibtree, leaf, i, outb)) < 0) { + return -1; + } + if (ret) { + break; + } + ++i; + } + assert(leaf->known_ && i == leaf->value_ + 1); + } + + endpasses = &cblk->passes[cblk->numpasses]; + startpass = pass; + endpass = startpass; + while (endpass != endpasses && endpass->lyrno == lyrno){ + ++endpass; + } + numnewpasses = endpass - startpass; + if (jpc_putnumnewpasses(outb, numnewpasses)) { + return -1; + } + JAS_DBGLOG(10, ("numnewpasses=%d ", numnewpasses)); + + lastpass = endpass - 1; + n = startpass->start; + passcount = 1; + maxadjust = 0; + for (pass = startpass; pass != endpass; ++pass) { + if (pass->term || pass == lastpass) { + datalen = pass->end - n; + t1 = jpc_firstone(datalen) + 1; + t2 = cblk->numlenbits + jpc_floorlog2(passcount); + adjust = JAS_MAX(t1 - t2, 0); + maxadjust = JAS_MAX(adjust, maxadjust); + n += datalen; + passcount = 1; + } else { + ++passcount; + } + } + if (jpc_putcommacode(outb, maxadjust)) { + return -1; + } + cblk->numlenbits += maxadjust; + + lastpass = endpass - 1; + n = startpass->start; + passcount = 1; + for (pass = startpass; pass != endpass; ++pass) { + if (pass->term || pass == lastpass) { + datalen = pass->end - n; assert(jpc_firstone(datalen) < cblk->numlenbits + jpc_floorlog2(passcount)); - if (jpc_bitstream_putbits(outb, cblk->numlenbits + jpc_floorlog2(passcount), datalen) == EOF) { - return -1; - } - n += datalen; - passcount = 1; - } else { - ++passcount; - } - } - } - } - - jpc_bitstream_outalign(outb, 0); - jpc_bitstream_close(outb); - - if (cp->tcp.csty & JPC_COD_EPH) { - if (!(ms = jpc_ms_create(JPC_MS_EPH))) { - return -1; - } - jpc_putms(out, enc->cstate, ms); - jpc_ms_destroy(ms); - } - - comp = &tile->tcmpts[compno]; - lvl = &comp->rlvls[lvlno]; - endbands = &lvl->bands[lvl->numbands]; - for (band = lvl->bands; band != endbands; ++band) { - if (!band->data) { - continue; - } - prc = &band->prcs[prcno]; - if (!prc->cblks) { - continue; - } - endcblks = &prc->cblks[prc->numcblks]; - for (cblk = prc->cblks; cblk != endcblks; ++cblk) { - pass = cblk->curpass; - - if (!pass) { - continue; - } - if (pass->lyrno != lyrno) { - assert(pass->lyrno < 0 || pass->lyrno > lyrno); - continue; - } - - endpasses = &cblk->passes[cblk->numpasses]; - startpass = pass; - endpass = startpass; - while (endpass != endpasses && endpass->lyrno == lyrno){ - ++endpass; - } - lastpass = endpass - 1; - numnewpasses = endpass - startpass; - - jas_stream_seek(cblk->stream, startpass->start, SEEK_SET); - assert(jas_stream_tell(cblk->stream) == startpass->start); - if (jas_stream_copy(out, cblk->stream, lastpass->end - startpass->start)) { - return -1; - } - cblk->curpass = (endpass != endpasses) ? endpass : 0; - cblk->numencpasses += numnewpasses; - - } - } - - return 0; + if (jpc_bitstream_putbits(outb, cblk->numlenbits + jpc_floorlog2(passcount), datalen) == EOF) { + return -1; + } + n += datalen; + passcount = 1; + } else { + ++passcount; + } + } + } + } + + jpc_bitstream_outalign(outb, 0); + jpc_bitstream_close(outb); + + if (cp->tcp.csty & JPC_COD_EPH) { + if (!(ms = jpc_ms_create(JPC_MS_EPH))) { + return -1; + } + jpc_putms(out, enc->cstate, ms); + jpc_ms_destroy(ms); + } + + comp = &tile->tcmpts[compno]; + lvl = &comp->rlvls[lvlno]; + endbands = &lvl->bands[lvl->numbands]; + for (band = lvl->bands; band != endbands; ++band) { + if (!band->data) { + continue; + } + prc = &band->prcs[prcno]; + if (!prc->cblks) { + continue; + } + endcblks = &prc->cblks[prc->numcblks]; + for (cblk = prc->cblks; cblk != endcblks; ++cblk) { + pass = cblk->curpass; + + if (!pass) { + continue; + } + if (pass->lyrno != lyrno) { + assert(pass->lyrno < 0 || pass->lyrno > lyrno); + continue; + } + + endpasses = &cblk->passes[cblk->numpasses]; + startpass = pass; + endpass = startpass; + while (endpass != endpasses && endpass->lyrno == lyrno){ + ++endpass; + } + lastpass = endpass - 1; + numnewpasses = endpass - startpass; + + jas_stream_seek(cblk->stream, startpass->start, SEEK_SET); + assert(jas_stream_tell(cblk->stream) == startpass->start); + if (jas_stream_copy(out, cblk->stream, lastpass->end - startpass->start)) { + return -1; + } + cblk->curpass = (endpass != endpasses) ? endpass : 0; + cblk->numencpasses += numnewpasses; + + } + } + + return 0; } void jpc_save_t2state(jpc_enc_t *enc) { /* stream pos in embedded T1 stream may be wrong since not saved/restored! */ - jpc_enc_tcmpt_t *comp; - jpc_enc_tcmpt_t *endcomps; - jpc_enc_rlvl_t *lvl; - jpc_enc_rlvl_t *endlvls; - jpc_enc_band_t *band; - jpc_enc_band_t *endbands; - jpc_enc_cblk_t *cblk; - jpc_enc_cblk_t *endcblks; - jpc_enc_tile_t *tile; - uint_fast32_t prcno; - jpc_enc_prc_t *prc; - - tile = enc->curtile; - - endcomps = &tile->tcmpts[tile->numtcmpts]; - for (comp = tile->tcmpts; comp != endcomps; ++comp) { - endlvls = &comp->rlvls[comp->numrlvls]; - for (lvl = comp->rlvls; lvl != endlvls; ++lvl) { - if (!lvl->bands) { - continue; - } - endbands = &lvl->bands[lvl->numbands]; - for (band = lvl->bands; band != endbands; ++band) { - if (!band->data) { - continue; - } - for (prcno = 0, prc = band->prcs; prcno < lvl->numprcs; ++prcno, ++prc) { - if (!prc->cblks) { - continue; - } - jpc_tagtree_copy(prc->savincltree, prc->incltree); - jpc_tagtree_copy(prc->savnlibtree, prc->nlibtree); - endcblks = &prc->cblks[prc->numcblks]; - for (cblk = prc->cblks; cblk != endcblks; ++cblk) { - cblk->savedcurpass = cblk->curpass; - cblk->savednumencpasses = cblk->numencpasses; - cblk->savednumlenbits = cblk->numlenbits; - } - } - } - } - } + jpc_enc_tcmpt_t *comp; + jpc_enc_tcmpt_t *endcomps; + jpc_enc_rlvl_t *lvl; + jpc_enc_rlvl_t *endlvls; + jpc_enc_band_t *band; + jpc_enc_band_t *endbands; + jpc_enc_cblk_t *cblk; + jpc_enc_cblk_t *endcblks; + jpc_enc_tile_t *tile; + uint_fast32_t prcno; + jpc_enc_prc_t *prc; + + tile = enc->curtile; + + endcomps = &tile->tcmpts[tile->numtcmpts]; + for (comp = tile->tcmpts; comp != endcomps; ++comp) { + endlvls = &comp->rlvls[comp->numrlvls]; + for (lvl = comp->rlvls; lvl != endlvls; ++lvl) { + if (!lvl->bands) { + continue; + } + endbands = &lvl->bands[lvl->numbands]; + for (band = lvl->bands; band != endbands; ++band) { + if (!band->data) { + continue; + } + for (prcno = 0, prc = band->prcs; prcno < lvl->numprcs; ++prcno, ++prc) { + if (!prc->cblks) { + continue; + } + jpc_tagtree_copy(prc->savincltree, prc->incltree); + jpc_tagtree_copy(prc->savnlibtree, prc->nlibtree); + endcblks = &prc->cblks[prc->numcblks]; + for (cblk = prc->cblks; cblk != endcblks; ++cblk) { + cblk->savedcurpass = cblk->curpass; + cblk->savednumencpasses = cblk->numencpasses; + cblk->savednumlenbits = cblk->numlenbits; + } + } + } + } + } } void jpc_restore_t2state(jpc_enc_t *enc) { - jpc_enc_tcmpt_t *comp; - jpc_enc_tcmpt_t *endcomps; - jpc_enc_rlvl_t *lvl; - jpc_enc_rlvl_t *endlvls; - jpc_enc_band_t *band; - jpc_enc_band_t *endbands; - jpc_enc_cblk_t *cblk; - jpc_enc_cblk_t *endcblks; - jpc_enc_tile_t *tile; - uint_fast32_t prcno; - jpc_enc_prc_t *prc; - - tile = enc->curtile; - - endcomps = &tile->tcmpts[tile->numtcmpts]; - for (comp = tile->tcmpts; comp != endcomps; ++comp) { - endlvls = &comp->rlvls[comp->numrlvls]; - for (lvl = comp->rlvls; lvl != endlvls; ++lvl) { - if (!lvl->bands) { - continue; - } - endbands = &lvl->bands[lvl->numbands]; - for (band = lvl->bands; band != endbands; ++band) { - if (!band->data) { - continue; - } - for (prcno = 0, prc = band->prcs; prcno < lvl->numprcs; ++prcno, ++prc) { - if (!prc->cblks) { - continue; - } - jpc_tagtree_copy(prc->incltree, prc->savincltree); - jpc_tagtree_copy(prc->nlibtree, prc->savnlibtree); - endcblks = &prc->cblks[prc->numcblks]; - for (cblk = prc->cblks; cblk != endcblks; ++cblk) { - cblk->curpass = cblk->savedcurpass; - cblk->numencpasses = cblk->savednumencpasses; - cblk->numlenbits = cblk->savednumlenbits; - } - } - } - } - } + jpc_enc_tcmpt_t *comp; + jpc_enc_tcmpt_t *endcomps; + jpc_enc_rlvl_t *lvl; + jpc_enc_rlvl_t *endlvls; + jpc_enc_band_t *band; + jpc_enc_band_t *endbands; + jpc_enc_cblk_t *cblk; + jpc_enc_cblk_t *endcblks; + jpc_enc_tile_t *tile; + uint_fast32_t prcno; + jpc_enc_prc_t *prc; + + tile = enc->curtile; + + endcomps = &tile->tcmpts[tile->numtcmpts]; + for (comp = tile->tcmpts; comp != endcomps; ++comp) { + endlvls = &comp->rlvls[comp->numrlvls]; + for (lvl = comp->rlvls; lvl != endlvls; ++lvl) { + if (!lvl->bands) { + continue; + } + endbands = &lvl->bands[lvl->numbands]; + for (band = lvl->bands; band != endbands; ++band) { + if (!band->data) { + continue; + } + for (prcno = 0, prc = band->prcs; prcno < lvl->numprcs; ++prcno, ++prc) { + if (!prc->cblks) { + continue; + } + jpc_tagtree_copy(prc->incltree, prc->savincltree); + jpc_tagtree_copy(prc->nlibtree, prc->savnlibtree); + endcblks = &prc->cblks[prc->numcblks]; + for (cblk = prc->cblks; cblk != endcblks; ++cblk) { + cblk->curpass = cblk->savedcurpass; + cblk->numencpasses = cblk->savednumencpasses; + cblk->numlenbits = cblk->savednumlenbits; + } + } + } + } + } } void jpc_init_t2state(jpc_enc_t *enc, int raflag) { /* It is assumed that band->numbps and cblk->numbps precomputed */ - jpc_enc_tcmpt_t *comp; - jpc_enc_tcmpt_t *endcomps; - jpc_enc_rlvl_t *lvl; - jpc_enc_rlvl_t *endlvls; - jpc_enc_band_t *band; - jpc_enc_band_t *endbands; - jpc_enc_cblk_t *cblk; - jpc_enc_cblk_t *endcblks; - jpc_enc_pass_t *pass; - jpc_enc_pass_t *endpasses; - jpc_tagtreenode_t *leaf; - jpc_enc_tile_t *tile; - uint_fast32_t prcno; - jpc_enc_prc_t *prc; - - tile = enc->curtile; - - endcomps = &tile->tcmpts[tile->numtcmpts]; - for (comp = tile->tcmpts; comp != endcomps; ++comp) { - endlvls = &comp->rlvls[comp->numrlvls]; - for (lvl = comp->rlvls; lvl != endlvls; ++lvl) { - if (!lvl->bands) { - continue; - } - endbands = &lvl->bands[lvl->numbands]; - for (band = lvl->bands; band != endbands; ++band) { - if (!band->data) { - continue; - } - for (prcno = 0, prc = band->prcs; prcno < lvl->numprcs; ++prcno, ++prc) { - if (!prc->cblks) { - continue; - } - jpc_tagtree_reset(prc->incltree); - jpc_tagtree_reset(prc->nlibtree); - endcblks = &prc->cblks[prc->numcblks]; - for (cblk = prc->cblks; cblk != endcblks; ++cblk) { - if (jas_stream_rewind(cblk->stream)) { - assert(0); - } - cblk->curpass = (cblk->numpasses > 0) ? cblk->passes : 0; - cblk->numencpasses = 0; - cblk->numlenbits = 3; - cblk->numimsbs = band->numbps - cblk->numbps; - assert(cblk->numimsbs >= 0); - leaf = jpc_tagtree_getleaf(prc->nlibtree, cblk - prc->cblks); - jpc_tagtree_setvalue(prc->nlibtree, leaf, cblk->numimsbs); - - if (raflag) { - endpasses = &cblk->passes[cblk->numpasses]; - for (pass = cblk->passes; pass != endpasses; ++pass) { - pass->lyrno = -1; - pass->lyrno = 0; - } - } - } - } - } - } - } + jpc_enc_tcmpt_t *comp; + jpc_enc_tcmpt_t *endcomps; + jpc_enc_rlvl_t *lvl; + jpc_enc_rlvl_t *endlvls; + jpc_enc_band_t *band; + jpc_enc_band_t *endbands; + jpc_enc_cblk_t *cblk; + jpc_enc_cblk_t *endcblks; + jpc_enc_pass_t *pass; + jpc_enc_pass_t *endpasses; + jpc_tagtreenode_t *leaf; + jpc_enc_tile_t *tile; + uint_fast32_t prcno; + jpc_enc_prc_t *prc; + + tile = enc->curtile; + + endcomps = &tile->tcmpts[tile->numtcmpts]; + for (comp = tile->tcmpts; comp != endcomps; ++comp) { + endlvls = &comp->rlvls[comp->numrlvls]; + for (lvl = comp->rlvls; lvl != endlvls; ++lvl) { + if (!lvl->bands) { + continue; + } + endbands = &lvl->bands[lvl->numbands]; + for (band = lvl->bands; band != endbands; ++band) { + if (!band->data) { + continue; + } + for (prcno = 0, prc = band->prcs; prcno < lvl->numprcs; ++prcno, ++prc) { + if (!prc->cblks) { + continue; + } + jpc_tagtree_reset(prc->incltree); + jpc_tagtree_reset(prc->nlibtree); + endcblks = &prc->cblks[prc->numcblks]; + for (cblk = prc->cblks; cblk != endcblks; ++cblk) { + if (jas_stream_rewind(cblk->stream)) { + assert(0); + } + cblk->curpass = (cblk->numpasses > 0) ? cblk->passes : 0; + cblk->numencpasses = 0; + cblk->numlenbits = 3; + cblk->numimsbs = band->numbps - cblk->numbps; + assert(cblk->numimsbs >= 0); + leaf = jpc_tagtree_getleaf(prc->nlibtree, cblk - prc->cblks); + jpc_tagtree_setvalue(prc->nlibtree, leaf, cblk->numimsbs); + + if (raflag) { + endpasses = &cblk->passes[cblk->numpasses]; + for (pass = cblk->passes; pass != endpasses; ++pass) { + pass->lyrno = -1; + pass->lyrno = 0; + } + } + } + } + } + } + } } jpc_pi_t *jpc_enc_pi_create(jpc_enc_cp_t *cp, jpc_enc_tile_t *tile) { - jpc_pi_t *pi; - int compno; - jpc_picomp_t *picomp; - jpc_pirlvl_t *pirlvl; - jpc_enc_tcmpt_t *tcomp; - int rlvlno; - jpc_enc_rlvl_t *rlvl; - int prcno; - int *prclyrno; - - if (!(pi = jpc_pi_create0())) { - return 0; - } - pi->pktno = -1; - pi->numcomps = cp->numcmpts; - if (!(pi->picomps = jas_malloc(pi->numcomps * sizeof(jpc_picomp_t)))) { - jpc_pi_destroy(pi); - return 0; - } - for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; ++compno, - ++picomp) { - picomp->pirlvls = 0; - } - - for (compno = 0, tcomp = tile->tcmpts, picomp = pi->picomps; - compno < pi->numcomps; ++compno, ++tcomp, ++picomp) { - picomp->numrlvls = tcomp->numrlvls; - if (!(picomp->pirlvls = jas_malloc(picomp->numrlvls * - sizeof(jpc_pirlvl_t)))) { - jpc_pi_destroy(pi); - return 0; - } - for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno < - picomp->numrlvls; ++rlvlno, ++pirlvl) { - pirlvl->prclyrnos = 0; - } - for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls; - rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) { + jpc_pi_t *pi; + int compno; + jpc_picomp_t *picomp; + jpc_pirlvl_t *pirlvl; + jpc_enc_tcmpt_t *tcomp; + int rlvlno; + jpc_enc_rlvl_t *rlvl; + int prcno; + int *prclyrno; + + if (!(pi = jpc_pi_create0())) { + return 0; + } + pi->pktno = -1; + pi->numcomps = cp->numcmpts; + if (!(pi->picomps = jas_malloc(pi->numcomps * sizeof(jpc_picomp_t)))) { + jpc_pi_destroy(pi); + return 0; + } + for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; ++compno, + ++picomp) { + picomp->pirlvls = 0; + } + + for (compno = 0, tcomp = tile->tcmpts, picomp = pi->picomps; + compno < pi->numcomps; ++compno, ++tcomp, ++picomp) { + picomp->numrlvls = tcomp->numrlvls; + if (!(picomp->pirlvls = jas_malloc(picomp->numrlvls * + sizeof(jpc_pirlvl_t)))) { + jpc_pi_destroy(pi); + return 0; + } + for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno < + picomp->numrlvls; ++rlvlno, ++pirlvl) { + pirlvl->prclyrnos = 0; + } + for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls; + rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) { /* XXX sizeof(long) should be sizeof different type */ - pirlvl->numprcs = rlvl->numprcs; - if (rlvl->numprcs) { - if (!(pirlvl->prclyrnos = jas_malloc(pirlvl->numprcs * - sizeof(long)))) { - jpc_pi_destroy(pi); - return 0; - } - } else { - pirlvl->prclyrnos = 0; - } - } - } - - pi->maxrlvls = 0; - for (compno = 0, tcomp = tile->tcmpts, picomp = pi->picomps; - compno < pi->numcomps; ++compno, ++tcomp, ++picomp) { - picomp->hsamp = cp->ccps[compno].sampgrdstepx; - picomp->vsamp = cp->ccps[compno].sampgrdstepy; - for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls; - rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) { - pirlvl->prcwidthexpn = rlvl->prcwidthexpn; - pirlvl->prcheightexpn = rlvl->prcheightexpn; - for (prcno = 0, prclyrno = pirlvl->prclyrnos; - prcno < pirlvl->numprcs; ++prcno, ++prclyrno) { - *prclyrno = 0; - } - pirlvl->numhprcs = rlvl->numhprcs; - } - if (pi->maxrlvls < tcomp->numrlvls) { - pi->maxrlvls = tcomp->numrlvls; - } - } - - pi->numlyrs = tile->numlyrs; - pi->xstart = tile->tlx; - pi->ystart = tile->tly; - pi->xend = tile->brx; - pi->yend = tile->bry; - - pi->picomp = 0; - pi->pirlvl = 0; - pi->x = 0; - pi->y = 0; - pi->compno = 0; - pi->rlvlno = 0; - pi->prcno = 0; - pi->lyrno = 0; - pi->xstep = 0; - pi->ystep = 0; - - pi->pchgno = -1; - - pi->defaultpchg.prgord = tile->prg; - pi->defaultpchg.compnostart = 0; - pi->defaultpchg.compnoend = pi->numcomps; - pi->defaultpchg.rlvlnostart = 0; - pi->defaultpchg.rlvlnoend = pi->maxrlvls; - pi->defaultpchg.lyrnoend = pi->numlyrs; - pi->pchg = 0; - - pi->valid = 0; - - return pi; + pirlvl->numprcs = rlvl->numprcs; + if (rlvl->numprcs) { + if (!(pirlvl->prclyrnos = jas_malloc(pirlvl->numprcs * + sizeof(long)))) { + jpc_pi_destroy(pi); + return 0; + } + } else { + pirlvl->prclyrnos = 0; + } + } + } + + pi->maxrlvls = 0; + for (compno = 0, tcomp = tile->tcmpts, picomp = pi->picomps; + compno < pi->numcomps; ++compno, ++tcomp, ++picomp) { + picomp->hsamp = cp->ccps[compno].sampgrdstepx; + picomp->vsamp = cp->ccps[compno].sampgrdstepy; + for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls; + rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) { + pirlvl->prcwidthexpn = rlvl->prcwidthexpn; + pirlvl->prcheightexpn = rlvl->prcheightexpn; + for (prcno = 0, prclyrno = pirlvl->prclyrnos; + prcno < pirlvl->numprcs; ++prcno, ++prclyrno) { + *prclyrno = 0; + } + pirlvl->numhprcs = rlvl->numhprcs; + } + if (pi->maxrlvls < tcomp->numrlvls) { + pi->maxrlvls = tcomp->numrlvls; + } + } + + pi->numlyrs = tile->numlyrs; + pi->xstart = tile->tlx; + pi->ystart = tile->tly; + pi->xend = tile->brx; + pi->yend = tile->bry; + + pi->picomp = 0; + pi->pirlvl = 0; + pi->x = 0; + pi->y = 0; + pi->compno = 0; + pi->rlvlno = 0; + pi->prcno = 0; + pi->lyrno = 0; + pi->xstep = 0; + pi->ystep = 0; + + pi->pchgno = -1; + + pi->defaultpchg.prgord = tile->prg; + pi->defaultpchg.compnostart = 0; + pi->defaultpchg.compnoend = pi->numcomps; + pi->defaultpchg.rlvlnostart = 0; + pi->defaultpchg.rlvlnoend = pi->maxrlvls; + pi->defaultpchg.lyrnoend = pi->numlyrs; + pi->pchg = 0; + + pi->valid = 0; + + return pi; } diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_t2enc.h b/converter/other/jpeg2000/libjasper/jpc/jpc_t2enc.h index e97f8c06..8b5979de 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_t2enc.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_t2enc.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_tagtree.c b/converter/other/jpeg2000/libjasper/jpc/jpc_tagtree.c index 2b13fcf1..1d026b85 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_tagtree.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_tagtree.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -135,101 +135,101 @@ static jpc_tagtree_t *jpc_tagtree_alloc(void) { - jpc_tagtree_t *tree; + jpc_tagtree_t *tree; - if (!(tree = jas_malloc(sizeof(jpc_tagtree_t)))) { - return 0; - } - tree->numleafsh_ = 0; - tree->numleafsv_ = 0; - tree->numnodes_ = 0; - tree->nodes_ = 0; + if (!(tree = jas_malloc(sizeof(jpc_tagtree_t)))) { + return 0; + } + tree->numleafsh_ = 0; + tree->numleafsv_ = 0; + tree->numnodes_ = 0; + tree->nodes_ = 0; - return tree; + return tree; } /* Create a tag tree. */ jpc_tagtree_t *jpc_tagtree_create(int numleafsh, int numleafsv) { - int nplh[JPC_TAGTREE_MAXDEPTH]; - int nplv[JPC_TAGTREE_MAXDEPTH]; - jpc_tagtreenode_t *node; - jpc_tagtreenode_t *parentnode; - jpc_tagtreenode_t *parentnode0; - jpc_tagtree_t *tree; - int i; - int j; - int k; - int numlvls; - int n; - - assert(numleafsh > 0 && numleafsv > 0); - - if (!(tree = jpc_tagtree_alloc())) { - return 0; - } - tree->numleafsh_ = numleafsh; - tree->numleafsv_ = numleafsv; - - numlvls = 0; - nplh[0] = numleafsh; - nplv[0] = numleafsv; - do { - n = nplh[numlvls] * nplv[numlvls]; - nplh[numlvls + 1] = (nplh[numlvls] + 1) / 2; - nplv[numlvls + 1] = (nplv[numlvls] + 1) / 2; - tree->numnodes_ += n; - ++numlvls; - } while (n > 1); - - if (!(tree->nodes_ = jas_malloc(tree->numnodes_ * sizeof(jpc_tagtreenode_t)))) { - return 0; - } - - /* Initialize the parent links for all nodes in the tree. */ - - node = tree->nodes_; - parentnode = &tree->nodes_[tree->numleafsh_ * tree->numleafsv_]; - parentnode0 = parentnode; - - for (i = 0; i < numlvls - 1; ++i) { - for (j = 0; j < nplv[i]; ++j) { - k = nplh[i]; - while (--k >= 0) { - node->parent_ = parentnode; - ++node; - if (--k >= 0) { - node->parent_ = parentnode; - ++node; - } - ++parentnode; - } - if ((j & 1) || j == nplv[i] - 1) { - parentnode0 = parentnode; - } else { - parentnode = parentnode0; - parentnode0 += nplh[i]; - } - } - } - node->parent_ = 0; - - /* Initialize the data values to something sane. */ - - jpc_tagtree_reset(tree); - - return tree; + int nplh[JPC_TAGTREE_MAXDEPTH]; + int nplv[JPC_TAGTREE_MAXDEPTH]; + jpc_tagtreenode_t *node; + jpc_tagtreenode_t *parentnode; + jpc_tagtreenode_t *parentnode0; + jpc_tagtree_t *tree; + int i; + int j; + int k; + int numlvls; + int n; + + assert(numleafsh > 0 && numleafsv > 0); + + if (!(tree = jpc_tagtree_alloc())) { + return 0; + } + tree->numleafsh_ = numleafsh; + tree->numleafsv_ = numleafsv; + + numlvls = 0; + nplh[0] = numleafsh; + nplv[0] = numleafsv; + do { + n = nplh[numlvls] * nplv[numlvls]; + nplh[numlvls + 1] = (nplh[numlvls] + 1) / 2; + nplv[numlvls + 1] = (nplv[numlvls] + 1) / 2; + tree->numnodes_ += n; + ++numlvls; + } while (n > 1); + + if (!(tree->nodes_ = jas_malloc(tree->numnodes_ * sizeof(jpc_tagtreenode_t)))) { + return 0; + } + + /* Initialize the parent links for all nodes in the tree. */ + + node = tree->nodes_; + parentnode = &tree->nodes_[tree->numleafsh_ * tree->numleafsv_]; + parentnode0 = parentnode; + + for (i = 0; i < numlvls - 1; ++i) { + for (j = 0; j < nplv[i]; ++j) { + k = nplh[i]; + while (--k >= 0) { + node->parent_ = parentnode; + ++node; + if (--k >= 0) { + node->parent_ = parentnode; + ++node; + } + ++parentnode; + } + if ((j & 1) || j == nplv[i] - 1) { + parentnode0 = parentnode; + } else { + parentnode = parentnode0; + parentnode0 += nplh[i]; + } + } + } + node->parent_ = 0; + + /* Initialize the data values to something sane. */ + + jpc_tagtree_reset(tree); + + return tree; } /* Destroy a tag tree. */ void jpc_tagtree_destroy(jpc_tagtree_t *tree) { - if (tree->nodes_) { - jas_free(tree->nodes_); - } - jas_free(tree); + if (tree->nodes_) { + jas_free(tree->nodes_); + } + jas_free(tree); } /******************************************************************************\ @@ -240,42 +240,42 @@ void jpc_tagtree_destroy(jpc_tagtree_t *tree) void jpc_tagtree_copy(jpc_tagtree_t *dsttree, jpc_tagtree_t *srctree) { - int n; - jpc_tagtreenode_t *srcnode; - jpc_tagtreenode_t *dstnode; - - /* The two tag trees must have similar sizes. */ - assert(srctree->numleafsh_ == dsttree->numleafsh_ && - srctree->numleafsv_ == dsttree->numleafsv_); - - n = srctree->numnodes_; - srcnode = srctree->nodes_; - dstnode = dsttree->nodes_; - while (--n >= 0) { - dstnode->value_ = srcnode->value_; - dstnode->low_ = srcnode->low_; - dstnode->known_ = srcnode->known_; - ++dstnode; - ++srcnode; - } + int n; + jpc_tagtreenode_t *srcnode; + jpc_tagtreenode_t *dstnode; + + /* The two tag trees must have similar sizes. */ + assert(srctree->numleafsh_ == dsttree->numleafsh_ && + srctree->numleafsv_ == dsttree->numleafsv_); + + n = srctree->numnodes_; + srcnode = srctree->nodes_; + dstnode = dsttree->nodes_; + while (--n >= 0) { + dstnode->value_ = srcnode->value_; + dstnode->low_ = srcnode->low_; + dstnode->known_ = srcnode->known_; + ++dstnode; + ++srcnode; + } } /* Reset all of the state information associated with a tag tree. */ void jpc_tagtree_reset(jpc_tagtree_t *tree) { - int n; - jpc_tagtreenode_t *node; - - n = tree->numnodes_; - node = tree->nodes_; - - while (--n >= 0) { - node->value_ = INT_MAX; - node->low_ = 0; - node->known_ = 0; - ++node; - } + int n; + jpc_tagtreenode_t *node; + + n = tree->numnodes_; + node = tree->nodes_; + + while (--n >= 0) { + node->value_ = INT_MAX; + node->low_ = 0; + node->known_ = 0; + ++node; + } } /* Set the value associated with the specified leaf node, updating @@ -283,22 +283,22 @@ the other nodes as necessary. */ void jpc_tagtree_setvalue(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf, int value) { - jpc_tagtreenode_t *node; + jpc_tagtreenode_t *node; - assert(value >= 0); + assert(value >= 0); - node = leaf; - while (node && node->value_ > value) { - node->value_ = value; - node = node->parent_; - } + node = leaf; + while (node && node->value_ > value) { + node->value_ = value; + node = node->parent_; + } } /* Get a particular leaf node. */ jpc_tagtreenode_t *jpc_tagtree_getleaf(jpc_tagtree_t *tree, int n) { - return &tree->nodes_[n]; + return &tree->nodes_[n]; } /* Invoke the tag tree encoding procedure. */ @@ -306,55 +306,55 @@ jpc_tagtreenode_t *jpc_tagtree_getleaf(jpc_tagtree_t *tree, int n) int jpc_tagtree_encode(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf, int threshold, jpc_bitstream_t *out) { - jpc_tagtreenode_t *stk[JPC_TAGTREE_MAXDEPTH - 1]; - jpc_tagtreenode_t **stkptr; - jpc_tagtreenode_t *node; - int low; - - assert(leaf); - assert(threshold >= 0); - - /* Traverse to the root of the tree, recording the path taken. */ - stkptr = stk; - node = leaf; - while (node->parent_) { - *stkptr++ = node; - node = node->parent_; - } - - low = 0; - for (;;) { - if (low > node->low_) { - /* Deferred propagation of the lower bound downward in - the tree. */ - node->low_ = low; - } else { - low = node->low_; - } - - while (low < threshold) { - if (low >= node->value_) { - if (!node->known_) { - if (jpc_bitstream_putbit(out, 1) == EOF) { - return -1; - } - node->known_ = 1; - } - break; - } - if (jpc_bitstream_putbit(out, 0) == EOF) { - return -1; - } - ++low; - } - node->low_ = low; - if (stkptr == stk) { - break; - } - node = *--stkptr; - - } - return (leaf->low_ < threshold) ? 1 : 0; + jpc_tagtreenode_t *stk[JPC_TAGTREE_MAXDEPTH - 1]; + jpc_tagtreenode_t **stkptr; + jpc_tagtreenode_t *node; + int low; + + assert(leaf); + assert(threshold >= 0); + + /* Traverse to the root of the tree, recording the path taken. */ + stkptr = stk; + node = leaf; + while (node->parent_) { + *stkptr++ = node; + node = node->parent_; + } + + low = 0; + for (;;) { + if (low > node->low_) { + /* Deferred propagation of the lower bound downward in + the tree. */ + node->low_ = low; + } else { + low = node->low_; + } + + while (low < threshold) { + if (low >= node->value_) { + if (!node->known_) { + if (jpc_bitstream_putbit(out, 1) == EOF) { + return -1; + } + node->known_ = 1; + } + break; + } + if (jpc_bitstream_putbit(out, 0) == EOF) { + return -1; + } + ++low; + } + node->low_ = low; + if (stkptr == stk) { + break; + } + node = *--stkptr; + + } + return (leaf->low_ < threshold) ? 1 : 0; } @@ -363,47 +363,47 @@ int jpc_tagtree_encode(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf, int thresho int jpc_tagtree_decode(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf, int threshold, jpc_bitstream_t *in) { - jpc_tagtreenode_t *stk[JPC_TAGTREE_MAXDEPTH - 1]; - jpc_tagtreenode_t **stkptr; - jpc_tagtreenode_t *node; - int low; - int ret; - - assert(threshold >= 0); - - /* Traverse to the root of the tree, recording the path taken. */ - stkptr = stk; - node = leaf; - while (node->parent_) { - *stkptr++ = node; - node = node->parent_; - } - - low = 0; - for (;;) { - if (low > node->low_) { - node->low_ = low; - } else { - low = node->low_; - } - while (low < threshold && low < node->value_) { - if ((ret = jpc_bitstream_getbit(in)) < 0) { - return -1; - } - if (ret) { - node->value_ = low; - } else { - ++low; - } - } - node->low_ = low; - if (stkptr == stk) { - break; - } - node = *--stkptr; - } - - return (node->value_ < threshold) ? 1 : 0; + jpc_tagtreenode_t *stk[JPC_TAGTREE_MAXDEPTH - 1]; + jpc_tagtreenode_t **stkptr; + jpc_tagtreenode_t *node; + int low; + int ret; + + assert(threshold >= 0); + + /* Traverse to the root of the tree, recording the path taken. */ + stkptr = stk; + node = leaf; + while (node->parent_) { + *stkptr++ = node; + node = node->parent_; + } + + low = 0; + for (;;) { + if (low > node->low_) { + node->low_ = low; + } else { + low = node->low_; + } + while (low < threshold && low < node->value_) { + if ((ret = jpc_bitstream_getbit(in)) < 0) { + return -1; + } + if (ret) { + node->value_ = low; + } else { + ++low; + } + } + node->low_ = low; + if (stkptr == stk) { + break; + } + node = *--stkptr; + } + + return (node->value_ < threshold) ? 1 : 0; } /******************************************************************************\ @@ -412,15 +412,15 @@ int jpc_tagtree_decode(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf, int thresho void jpc_tagtree_dump(jpc_tagtree_t *tree, FILE *out) { - jpc_tagtreenode_t *node; - int n; - - node = tree->nodes_; - n = tree->numnodes_; - while (--n >= 0) { - fprintf(out, "node %p, parent %p, value %d, lower %d, known %d\n", - (void *) node, (void *) node->parent_, node->value_, node->low_, - node->known_); - ++node; - } + jpc_tagtreenode_t *node; + int n; + + node = tree->nodes_; + n = tree->numnodes_; + while (--n >= 0) { + fprintf(out, "node %p, parent %p, value %d, lower %d, known %d\n", + (void *) node, (void *) node->parent_, node->value_, node->low_, + node->known_); + ++node; + } } diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_tagtree.h b/converter/other/jpeg2000/libjasper/jpc/jpc_tagtree.h index 1892b13f..cf1dc652 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_tagtree.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_tagtree.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -133,7 +133,7 @@ \******************************************************************************/ /* The maximum allowable depth for a tag tree. */ -#define JPC_TAGTREE_MAXDEPTH 32 +#define JPC_TAGTREE_MAXDEPTH 32 /******************************************************************************\ * Types @@ -145,17 +145,17 @@ typedef struct jpc_tagtreenode_ { - /* The parent of this node. */ - struct jpc_tagtreenode_ *parent_; + /* The parent of this node. */ + struct jpc_tagtreenode_ *parent_; - /* The value associated with this node. */ - int value_; + /* The value associated with this node. */ + int value_; - /* The lower bound on the value associated with this node. */ - int low_; + /* The lower bound on the value associated with this node. */ + int low_; - /* A flag indicating if the value is known exactly. */ - int known_; + /* A flag indicating if the value is known exactly. */ + int known_; } jpc_tagtreenode_t; @@ -165,17 +165,17 @@ typedef struct jpc_tagtreenode_ { typedef struct { - /* The number of leaves in the horizontal direction. */ - int numleafsh_; + /* The number of leaves in the horizontal direction. */ + int numleafsh_; - /* The number of leaves in the vertical direction. */ - int numleafsv_; + /* The number of leaves in the vertical direction. */ + int numleafsv_; - /* The total number of nodes in the tree. */ - int numnodes_; + /* The total number of nodes in the tree. */ + int numnodes_; - /* The nodes. */ - jpc_tagtreenode_t *nodes_; + /* The nodes. */ + jpc_tagtreenode_t *nodes_; } jpc_tagtree_t; diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_tsfb.c b/converter/other/jpeg2000/libjasper/jpc/jpc_tsfb.c index f7d66b57..a5772c53 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_tsfb.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_tsfb.c @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -134,8 +134,8 @@ * \******************************************************************************/ -#define bandnotovind(tsfbnode, x) ((x) / (tsfbnode)->numhchans) -#define bandnotohind(tsfbnode, x) ((x) % (tsfbnode)->numhchans) +#define bandnotovind(tsfbnode, x) ((x) / (tsfbnode)->numhchans) +#define bandnotohind(tsfbnode, x) ((x) % (tsfbnode)->numhchans) static jpc_tsfb_t *jpc_tsfb_create(void); static jpc_tsfbnode_t *jpc_tsfbnode_create(void); @@ -158,74 +158,74 @@ static int jpc_tsfbnode_getequivfilters(jpc_tsfbnode_t *tsfbnode, int cldind, jpc_tsfb_t *jpc_tsfb_wavelet(jpc_qmfb1d_t *hqmfb, jpc_qmfb1d_t *vqmfb, int numdlvls) { - jpc_tsfb_t *tsfb; - int dlvlno; - jpc_tsfbnode_t *curnode; - jpc_tsfbnode_t *prevnode; - int childno; - if (!(tsfb = jpc_tsfb_create())) { - return 0; - } - prevnode = 0; - for (dlvlno = 0; dlvlno < numdlvls; ++dlvlno) { - if (!(curnode = jpc_tsfbnode_create())) { - jpc_tsfb_destroy(tsfb); - return 0; - } - if (prevnode) { - prevnode->children[0] = curnode; - ++prevnode->numchildren; - curnode->parent = prevnode; - } else { - tsfb->root = curnode; - curnode->parent = 0; - } - if (hqmfb) { - curnode->numhchans = jpc_qmfb1d_getnumchans(hqmfb); - if (!(curnode->hqmfb = jpc_qmfb1d_copy(hqmfb))) { - jpc_tsfb_destroy(tsfb); - return 0; - } - } else { - curnode->hqmfb = 0; - curnode->numhchans = 1; - } - if (vqmfb) { - curnode->numvchans = jpc_qmfb1d_getnumchans(vqmfb); - if (!(curnode->vqmfb = jpc_qmfb1d_copy(vqmfb))) { - jpc_tsfb_destroy(tsfb); - return 0; - } - } else { - curnode->vqmfb = 0; - curnode->numvchans = 1; - } - curnode->maxchildren = curnode->numhchans * curnode->numvchans; - for (childno = 0; childno < curnode->maxchildren; - ++childno) { - curnode->children[childno] = 0; - } - prevnode = curnode; - } - return tsfb; + jpc_tsfb_t *tsfb; + int dlvlno; + jpc_tsfbnode_t *curnode; + jpc_tsfbnode_t *prevnode; + int childno; + if (!(tsfb = jpc_tsfb_create())) { + return 0; + } + prevnode = 0; + for (dlvlno = 0; dlvlno < numdlvls; ++dlvlno) { + if (!(curnode = jpc_tsfbnode_create())) { + jpc_tsfb_destroy(tsfb); + return 0; + } + if (prevnode) { + prevnode->children[0] = curnode; + ++prevnode->numchildren; + curnode->parent = prevnode; + } else { + tsfb->root = curnode; + curnode->parent = 0; + } + if (hqmfb) { + curnode->numhchans = jpc_qmfb1d_getnumchans(hqmfb); + if (!(curnode->hqmfb = jpc_qmfb1d_copy(hqmfb))) { + jpc_tsfb_destroy(tsfb); + return 0; + } + } else { + curnode->hqmfb = 0; + curnode->numhchans = 1; + } + if (vqmfb) { + curnode->numvchans = jpc_qmfb1d_getnumchans(vqmfb); + if (!(curnode->vqmfb = jpc_qmfb1d_copy(vqmfb))) { + jpc_tsfb_destroy(tsfb); + return 0; + } + } else { + curnode->vqmfb = 0; + curnode->numvchans = 1; + } + curnode->maxchildren = curnode->numhchans * curnode->numvchans; + for (childno = 0; childno < curnode->maxchildren; + ++childno) { + curnode->children[childno] = 0; + } + prevnode = curnode; + } + return tsfb; } static jpc_tsfb_t *jpc_tsfb_create() { - jpc_tsfb_t *tsfb; - if (!(tsfb = jas_malloc(sizeof(jpc_tsfb_t)))) { - return 0; - } - tsfb->root = 0; - return tsfb; + jpc_tsfb_t *tsfb; + if (!(tsfb = jas_malloc(sizeof(jpc_tsfb_t)))) { + return 0; + } + tsfb->root = 0; + return tsfb; } void jpc_tsfb_destroy(jpc_tsfb_t *tsfb) { - if (tsfb->root) { - jpc_tsfbnode_destroy(tsfb->root); - } - jas_free(tsfb); + if (tsfb->root) { + jpc_tsfbnode_destroy(tsfb->root); + } + jas_free(tsfb); } /******************************************************************************\ @@ -234,83 +234,83 @@ void jpc_tsfb_destroy(jpc_tsfb_t *tsfb) void jpc_tsfb_analyze(jpc_tsfb_t *tsfb, int flags, jas_seq2d_t *x) { - if (tsfb->root) { - jpc_tsfbnode_analyze(tsfb->root, flags, x); - } + if (tsfb->root) { + jpc_tsfbnode_analyze(tsfb->root, flags, x); + } } static void jpc_tsfbnode_analyze(jpc_tsfbnode_t *node, int flags, jas_seq2d_t *x) { - jpc_tsfbnodeband_t nodebands[JPC_TSFB_MAXBANDSPERNODE]; - int numbands; - jas_seq2d_t *y; - int bandno; - jpc_tsfbnodeband_t *band; - - if (node->vqmfb) { - jpc_qmfb1d_analyze(node->vqmfb, flags | JPC_QMFB1D_VERT, x); - } - if (node->hqmfb) { - jpc_qmfb1d_analyze(node->hqmfb, flags, x); - } - if (node->numchildren > 0) { - qmfb2d_getbands(node->hqmfb, node->vqmfb, jas_seq2d_xstart(x), - jas_seq2d_ystart(x), jas_seq2d_xend(x), jas_seq2d_yend(x), - JPC_TSFB_MAXBANDSPERNODE, &numbands, nodebands); - y = jas_seq2d_create(0, 0, 0, 0); - assert(y); - for (bandno = 0, band = nodebands; bandno < numbands; ++bandno, ++band) { - if (node->children[bandno]) { - if (band->xstart != band->xend && band->ystart != band->yend) { - jas_seq2d_bindsub(y, x, band->locxstart, band->locystart, - band->locxend, band->locyend); - jas_seq2d_setshift(y, band->xstart, band->ystart); - jpc_tsfbnode_analyze(node->children[bandno], flags, y); - } - } - } - jas_matrix_destroy(y); - } + jpc_tsfbnodeband_t nodebands[JPC_TSFB_MAXBANDSPERNODE]; + int numbands; + jas_seq2d_t *y; + int bandno; + jpc_tsfbnodeband_t *band; + + if (node->vqmfb) { + jpc_qmfb1d_analyze(node->vqmfb, flags | JPC_QMFB1D_VERT, x); + } + if (node->hqmfb) { + jpc_qmfb1d_analyze(node->hqmfb, flags, x); + } + if (node->numchildren > 0) { + qmfb2d_getbands(node->hqmfb, node->vqmfb, jas_seq2d_xstart(x), + jas_seq2d_ystart(x), jas_seq2d_xend(x), jas_seq2d_yend(x), + JPC_TSFB_MAXBANDSPERNODE, &numbands, nodebands); + y = jas_seq2d_create(0, 0, 0, 0); + assert(y); + for (bandno = 0, band = nodebands; bandno < numbands; ++bandno, ++band) { + if (node->children[bandno]) { + if (band->xstart != band->xend && band->ystart != band->yend) { + jas_seq2d_bindsub(y, x, band->locxstart, band->locystart, + band->locxend, band->locyend); + jas_seq2d_setshift(y, band->xstart, band->ystart); + jpc_tsfbnode_analyze(node->children[bandno], flags, y); + } + } + } + jas_matrix_destroy(y); + } } void jpc_tsfb_synthesize(jpc_tsfb_t *tsfb, int flags, jas_seq2d_t *x) { - if (tsfb->root) { - jpc_tsfbnode_synthesize(tsfb->root, flags, x); - } + if (tsfb->root) { + jpc_tsfbnode_synthesize(tsfb->root, flags, x); + } } static void jpc_tsfbnode_synthesize(jpc_tsfbnode_t *node, int flags, jas_seq2d_t *x) { - jpc_tsfbnodeband_t nodebands[JPC_TSFB_MAXBANDSPERNODE]; - int numbands; - jas_seq2d_t *y; - int bandno; - jpc_tsfbnodeband_t *band; - - if (node->numchildren > 0) { - qmfb2d_getbands(node->hqmfb, node->vqmfb, jas_seq2d_xstart(x), - jas_seq2d_ystart(x), jas_seq2d_xend(x), jas_seq2d_yend(x), - JPC_TSFB_MAXBANDSPERNODE, &numbands, nodebands); - y = jas_seq2d_create(0, 0, 0, 0); - for (bandno = 0, band = nodebands; bandno < numbands; ++bandno, ++band) { - if (node->children[bandno]) { - if (band->xstart != band->xend && band->ystart != band->yend) { - jas_seq2d_bindsub(y, x, band->locxstart, band->locystart, - band->locxend, band->locyend); - jas_seq2d_setshift(y, band->xstart, band->ystart); - jpc_tsfbnode_synthesize(node->children[bandno], flags, y); - } - } - } - jas_seq2d_destroy(y); - } - if (node->hqmfb) { - jpc_qmfb1d_synthesize(node->hqmfb, flags, x); - } - if (node->vqmfb) { - jpc_qmfb1d_synthesize(node->vqmfb, flags | JPC_QMFB1D_VERT, x); - } + jpc_tsfbnodeband_t nodebands[JPC_TSFB_MAXBANDSPERNODE]; + int numbands; + jas_seq2d_t *y; + int bandno; + jpc_tsfbnodeband_t *band; + + if (node->numchildren > 0) { + qmfb2d_getbands(node->hqmfb, node->vqmfb, jas_seq2d_xstart(x), + jas_seq2d_ystart(x), jas_seq2d_xend(x), jas_seq2d_yend(x), + JPC_TSFB_MAXBANDSPERNODE, &numbands, nodebands); + y = jas_seq2d_create(0, 0, 0, 0); + for (bandno = 0, band = nodebands; bandno < numbands; ++bandno, ++band) { + if (node->children[bandno]) { + if (band->xstart != band->xend && band->ystart != band->yend) { + jas_seq2d_bindsub(y, x, band->locxstart, band->locystart, + band->locxend, band->locyend); + jas_seq2d_setshift(y, band->xstart, band->ystart); + jpc_tsfbnode_synthesize(node->children[bandno], flags, y); + } + } + } + jas_seq2d_destroy(y); + } + if (node->hqmfb) { + jpc_qmfb1d_synthesize(node->hqmfb, flags, x); + } + if (node->vqmfb) { + jpc_qmfb1d_synthesize(node->vqmfb, flags | JPC_QMFB1D_VERT, x); + } } /******************************************************************************\ @@ -321,114 +321,114 @@ static void jpc_tsfbnode_synthesize(jpc_tsfbnode_t *node, int flags, jas_seq2d_t int jpc_tsfb_getbands(jpc_tsfb_t *tsfb, uint_fast32_t xstart, uint_fast32_t ystart, uint_fast32_t xend, uint_fast32_t yend, jpc_tsfb_band_t *bands) { - jpc_tsfb_band_t *savbands; - savbands = bands; - if (!tsfb->root) { - bands[0].xstart = xstart; - bands[0].ystart = ystart; - bands[0].xend = xend; - bands[0].yend = yend; - bands[0].locxstart = xstart; - bands[0].locystart = ystart; - bands[0].locxend = xend; - bands[0].locyend = yend; - bands[0].orient = JPC_TSFB_LL; - bands[0].synenergywt = JPC_FIX_ONE; - ++bands; - } else { - jpc_tsfbnode_getbandstree(tsfb->root, xstart, ystart, - xstart, ystart, xend, yend, &bands); - } - return bands - savbands; + jpc_tsfb_band_t *savbands; + savbands = bands; + if (!tsfb->root) { + bands[0].xstart = xstart; + bands[0].ystart = ystart; + bands[0].xend = xend; + bands[0].yend = yend; + bands[0].locxstart = xstart; + bands[0].locystart = ystart; + bands[0].locxend = xend; + bands[0].locyend = yend; + bands[0].orient = JPC_TSFB_LL; + bands[0].synenergywt = JPC_FIX_ONE; + ++bands; + } else { + jpc_tsfbnode_getbandstree(tsfb->root, xstart, ystart, + xstart, ystart, xend, yend, &bands); + } + return bands - savbands; } static void jpc_tsfbnode_getbandstree(jpc_tsfbnode_t *node, uint_fast32_t posxstart, uint_fast32_t posystart, uint_fast32_t xstart, uint_fast32_t ystart, uint_fast32_t xend, uint_fast32_t yend, jpc_tsfb_band_t **bands) { - jpc_tsfbnodeband_t nodebands[JPC_TSFB_MAXBANDSPERNODE]; - jpc_tsfbnodeband_t *nodeband; - int nodebandno; - int numnodebands; - jpc_tsfb_band_t *band; - jas_seq_t *hfilter; - jas_seq_t *vfilter; - - qmfb2d_getbands(node->hqmfb, node->vqmfb, xstart, ystart, xend, yend, - JPC_TSFB_MAXBANDSPERNODE, &numnodebands, nodebands); - if (node->numchildren > 0) { - for (nodebandno = 0, nodeband = nodebands; - nodebandno < numnodebands; ++nodebandno, ++nodeband) { - if (node->children[nodebandno]) { - jpc_tsfbnode_getbandstree(node->children[ - nodebandno], posxstart + - nodeband->locxstart - xstart, posystart + - nodeband->locystart - ystart, nodeband->xstart, - nodeband->ystart, nodeband->xend, - nodeband->yend, bands); - - } - } - } + jpc_tsfbnodeband_t nodebands[JPC_TSFB_MAXBANDSPERNODE]; + jpc_tsfbnodeband_t *nodeband; + int nodebandno; + int numnodebands; + jpc_tsfb_band_t *band; + jas_seq_t *hfilter; + jas_seq_t *vfilter; + + qmfb2d_getbands(node->hqmfb, node->vqmfb, xstart, ystart, xend, yend, + JPC_TSFB_MAXBANDSPERNODE, &numnodebands, nodebands); + if (node->numchildren > 0) { + for (nodebandno = 0, nodeband = nodebands; + nodebandno < numnodebands; ++nodebandno, ++nodeband) { + if (node->children[nodebandno]) { + jpc_tsfbnode_getbandstree(node->children[ + nodebandno], posxstart + + nodeband->locxstart - xstart, posystart + + nodeband->locystart - ystart, nodeband->xstart, + nodeband->ystart, nodeband->xend, + nodeband->yend, bands); + + } + } + } assert(numnodebands == 4 || numnodebands == 3); - for (nodebandno = 0, nodeband = nodebands; nodebandno < numnodebands; - ++nodebandno, ++nodeband) { - if (!node->children[nodebandno]) { - band = *bands; - band->xstart = nodeband->xstart; - band->ystart = nodeband->ystart; - band->xend = nodeband->xend; - band->yend = nodeband->yend; - band->locxstart = posxstart + nodeband->locxstart - - xstart; - band->locystart = posystart + nodeband->locystart - - ystart; - band->locxend = band->locxstart + band->xend - - band->xstart; - band->locyend = band->locystart + band->yend - - band->ystart; - if (numnodebands == 4) { - switch (nodebandno) { - case 0: - band->orient = JPC_TSFB_LL; - break; - case 1: - band->orient = JPC_TSFB_HL; - break; - case 2: - band->orient = JPC_TSFB_LH; - break; - case 3: - band->orient = JPC_TSFB_HH; - break; - default: - abort(); - break; - } - } else { - switch (nodebandno) { - case 0: - band->orient = JPC_TSFB_HL; - break; - case 1: - band->orient = JPC_TSFB_LH; - break; - case 2: - band->orient = JPC_TSFB_HH; - break; - default: - abort(); - break; - } - } - jpc_tsfbnode_getequivfilters(node, nodebandno, band->xend - band->xstart, band->yend - band->ystart, &hfilter, &vfilter); - band->synenergywt = jpc_fix_mul(jpc_seq_norm(hfilter), - jpc_seq_norm(vfilter)); - jas_seq_destroy(hfilter); - jas_seq_destroy(vfilter); - ++(*bands); - } - } + for (nodebandno = 0, nodeband = nodebands; nodebandno < numnodebands; + ++nodebandno, ++nodeband) { + if (!node->children[nodebandno]) { + band = *bands; + band->xstart = nodeband->xstart; + band->ystart = nodeband->ystart; + band->xend = nodeband->xend; + band->yend = nodeband->yend; + band->locxstart = posxstart + nodeband->locxstart - + xstart; + band->locystart = posystart + nodeband->locystart - + ystart; + band->locxend = band->locxstart + band->xend - + band->xstart; + band->locyend = band->locystart + band->yend - + band->ystart; + if (numnodebands == 4) { + switch (nodebandno) { + case 0: + band->orient = JPC_TSFB_LL; + break; + case 1: + band->orient = JPC_TSFB_HL; + break; + case 2: + band->orient = JPC_TSFB_LH; + break; + case 3: + band->orient = JPC_TSFB_HH; + break; + default: + abort(); + break; + } + } else { + switch (nodebandno) { + case 0: + band->orient = JPC_TSFB_HL; + break; + case 1: + band->orient = JPC_TSFB_LH; + break; + case 2: + band->orient = JPC_TSFB_HH; + break; + default: + abort(); + break; + } + } + jpc_tsfbnode_getequivfilters(node, nodebandno, band->xend - band->xstart, band->yend - band->ystart, &hfilter, &vfilter); + band->synenergywt = jpc_fix_mul(jpc_seq_norm(hfilter), + jpc_seq_norm(vfilter)); + jas_seq_destroy(hfilter); + jas_seq_destroy(vfilter); + ++(*bands); + } + } } /******************************************************************************\ @@ -437,37 +437,37 @@ assert(numnodebands == 4 || numnodebands == 3); static jpc_tsfbnode_t *jpc_tsfbnode_create() { - jpc_tsfbnode_t *node; - if (!(node = jas_malloc(sizeof(jpc_tsfbnode_t)))) { - return 0; - } - node->numhchans = 0; - node->numvchans = 0; - node->numchildren = 0; - node->maxchildren = 0; - node->hqmfb = 0; - node->vqmfb = 0; - node->parent = 0; - return node; + jpc_tsfbnode_t *node; + if (!(node = jas_malloc(sizeof(jpc_tsfbnode_t)))) { + return 0; + } + node->numhchans = 0; + node->numvchans = 0; + node->numchildren = 0; + node->maxchildren = 0; + node->hqmfb = 0; + node->vqmfb = 0; + node->parent = 0; + return node; } static void jpc_tsfbnode_destroy(jpc_tsfbnode_t *node) { - jpc_tsfbnode_t **child; - int childno; - for (childno = 0, child = node->children; childno < node->maxchildren; - ++childno, ++child) { - if (*child) { - jpc_tsfbnode_destroy(*child); - } - } - if (node->hqmfb) { - jpc_qmfb1d_destroy(node->hqmfb); - } - if (node->vqmfb) { - jpc_qmfb1d_destroy(node->vqmfb); - } - jas_free(node); + jpc_tsfbnode_t **child; + int childno; + for (childno = 0, child = node->children; childno < node->maxchildren; + ++childno, ++child) { + if (*child) { + jpc_tsfbnode_destroy(*child); + } + } + if (node->hqmfb) { + jpc_qmfb1d_destroy(node->hqmfb); + } + if (node->vqmfb) { + jpc_qmfb1d_destroy(node->vqmfb); + } + jas_free(node); } @@ -481,182 +481,182 @@ static void qmfb2d_getbands(jpc_qmfb1d_t *hqmfb, jpc_qmfb1d_t *vqmfb, uint_fast32_t xstart, uint_fast32_t ystart, uint_fast32_t xend, uint_fast32_t yend, int maxbands, int *numbandsptr, jpc_tsfbnodeband_t *bands) { - jpc_qmfb1dband_t hbands[JPC_QMFB1D_MAXCHANS]; - jpc_qmfb1dband_t vbands[JPC_QMFB1D_MAXCHANS]; - int numhbands; - int numvbands; - int numbands; - int bandno; - int hbandno; - int vbandno; - jpc_tsfbnodeband_t *band; - - if (hqmfb) { - jpc_qmfb1d_getbands(hqmfb, 0, xstart, ystart, xend, yend, - JPC_QMFB1D_MAXCHANS, &numhbands, hbands); - } else { - numhbands = 1; - hbands[0].start = xstart; - hbands[0].end = xend; - hbands[0].locstart = xstart; - hbands[0].locend = xend; - } - if (vqmfb) { - jpc_qmfb1d_getbands(vqmfb, JPC_QMFB1D_VERT, xstart, ystart, xend, - yend, JPC_QMFB1D_MAXCHANS, &numvbands, vbands); - } else { - numvbands = 1; - vbands[0].start = ystart; - vbands[0].end = yend; - vbands[0].locstart = ystart; - vbands[0].locend = yend; - } - numbands = numhbands * numvbands; - *numbandsptr = numbands; - for (bandno = 0, band = bands; bandno < numbands; ++bandno, ++band) { - hbandno = bandno % numhbands; - vbandno = bandno / numhbands; - band->xstart = hbands[hbandno].start; - band->ystart = vbands[vbandno].start; - band->xend = hbands[hbandno].end; - band->yend = vbands[vbandno].end; - band->locxstart = hbands[hbandno].locstart; - band->locystart = vbands[vbandno].locstart; - band->locxend = hbands[hbandno].locend; - band->locyend = vbands[vbandno].locend; - assert(band->xstart <= band->xend && - band->ystart <= band->yend); - if (band->xstart == band->xend) { - band->yend = band->ystart; - band->locyend = band->locystart; - } else if (band->ystart == band->yend) { - band->xend = band->xstart; - band->locxend = band->locxstart; - } - } + jpc_qmfb1dband_t hbands[JPC_QMFB1D_MAXCHANS]; + jpc_qmfb1dband_t vbands[JPC_QMFB1D_MAXCHANS]; + int numhbands; + int numvbands; + int numbands; + int bandno; + int hbandno; + int vbandno; + jpc_tsfbnodeband_t *band; + + if (hqmfb) { + jpc_qmfb1d_getbands(hqmfb, 0, xstart, ystart, xend, yend, + JPC_QMFB1D_MAXCHANS, &numhbands, hbands); + } else { + numhbands = 1; + hbands[0].start = xstart; + hbands[0].end = xend; + hbands[0].locstart = xstart; + hbands[0].locend = xend; + } + if (vqmfb) { + jpc_qmfb1d_getbands(vqmfb, JPC_QMFB1D_VERT, xstart, ystart, xend, + yend, JPC_QMFB1D_MAXCHANS, &numvbands, vbands); + } else { + numvbands = 1; + vbands[0].start = ystart; + vbands[0].end = yend; + vbands[0].locstart = ystart; + vbands[0].locend = yend; + } + numbands = numhbands * numvbands; + *numbandsptr = numbands; + for (bandno = 0, band = bands; bandno < numbands; ++bandno, ++band) { + hbandno = bandno % numhbands; + vbandno = bandno / numhbands; + band->xstart = hbands[hbandno].start; + band->ystart = vbands[vbandno].start; + band->xend = hbands[hbandno].end; + band->yend = vbands[vbandno].end; + band->locxstart = hbands[hbandno].locstart; + band->locystart = vbands[vbandno].locstart; + band->locxend = hbands[hbandno].locend; + band->locyend = vbands[vbandno].locend; + assert(band->xstart <= band->xend && + band->ystart <= band->yend); + if (band->xstart == band->xend) { + band->yend = band->ystart; + band->locyend = band->locystart; + } else if (band->ystart == band->yend) { + band->xend = band->xstart; + band->locxend = band->locxstart; + } + } } static int jpc_tsfbnode_getequivfilters(jpc_tsfbnode_t *tsfbnode, int cldind, int width, int height, jas_seq_t **hfilter, jas_seq_t **vfilter) { - jas_seq_t *hseq; - jas_seq_t *vseq; - jpc_tsfbnode_t *node; - jas_seq2d_t *hfilters[JPC_QMFB1D_MAXCHANS]; - jas_seq2d_t *vfilters[JPC_QMFB1D_MAXCHANS]; - int numhchans; - int numvchans; - jas_seq_t *tmpseq; - - hseq = 0; - vseq = 0; - - if (!(hseq = jas_seq_create(0, 1))) { - goto error; - } - jas_seq_set(hseq, 0, jpc_inttofix(1)); - if (!(vseq = jas_seq_create(0, 1))) { - goto error; - } - jas_seq_set(vseq, 0, jpc_inttofix(1)); - - node = tsfbnode; - while (node) { - if (node->hqmfb) { - numhchans = jpc_qmfb1d_getnumchans(node->hqmfb); - if (jpc_qmfb1d_getsynfilters(node->hqmfb, width, hfilters)) { - goto error; - } - if (!(tmpseq = jpc_seq_upsample(hseq, numhchans))) { - goto error; - } - jas_seq_destroy(hseq); - hseq = tmpseq; - if (!(tmpseq = jpc_seq_conv(hseq, hfilters[bandnotohind(node, cldind)]))) { - goto error; - } - jas_seq_destroy(hfilters[0]); - jas_seq_destroy(hfilters[1]); - jas_seq_destroy(hseq); - hseq = tmpseq; - } - if (node->vqmfb) { - numvchans = jpc_qmfb1d_getnumchans(node->vqmfb); - if (jpc_qmfb1d_getsynfilters(node->vqmfb, height, vfilters)) { - abort(); - } - if (!(tmpseq = jpc_seq_upsample(vseq, numvchans))) { - goto error; - } - jas_seq_destroy(vseq); - vseq = tmpseq; - if (!(tmpseq = jpc_seq_conv(vseq, vfilters[bandnotovind(node, cldind)]))) { - goto error; - } - jas_seq_destroy(vfilters[0]); - jas_seq_destroy(vfilters[1]); - jas_seq_destroy(vseq); - vseq = tmpseq; - } - if (node->parent) { - cldind = jpc_tsfbnode_findchild(node->parent, node); - } - node = node->parent; - } - - *hfilter = hseq; - *vfilter = vseq; - - return 0; + jas_seq_t *hseq; + jas_seq_t *vseq; + jpc_tsfbnode_t *node; + jas_seq2d_t *hfilters[JPC_QMFB1D_MAXCHANS]; + jas_seq2d_t *vfilters[JPC_QMFB1D_MAXCHANS]; + int numhchans; + int numvchans; + jas_seq_t *tmpseq; + + hseq = 0; + vseq = 0; + + if (!(hseq = jas_seq_create(0, 1))) { + goto error; + } + jas_seq_set(hseq, 0, jpc_inttofix(1)); + if (!(vseq = jas_seq_create(0, 1))) { + goto error; + } + jas_seq_set(vseq, 0, jpc_inttofix(1)); + + node = tsfbnode; + while (node) { + if (node->hqmfb) { + numhchans = jpc_qmfb1d_getnumchans(node->hqmfb); + if (jpc_qmfb1d_getsynfilters(node->hqmfb, width, hfilters)) { + goto error; + } + if (!(tmpseq = jpc_seq_upsample(hseq, numhchans))) { + goto error; + } + jas_seq_destroy(hseq); + hseq = tmpseq; + if (!(tmpseq = jpc_seq_conv(hseq, hfilters[bandnotohind(node, cldind)]))) { + goto error; + } + jas_seq_destroy(hfilters[0]); + jas_seq_destroy(hfilters[1]); + jas_seq_destroy(hseq); + hseq = tmpseq; + } + if (node->vqmfb) { + numvchans = jpc_qmfb1d_getnumchans(node->vqmfb); + if (jpc_qmfb1d_getsynfilters(node->vqmfb, height, vfilters)) { + abort(); + } + if (!(tmpseq = jpc_seq_upsample(vseq, numvchans))) { + goto error; + } + jas_seq_destroy(vseq); + vseq = tmpseq; + if (!(tmpseq = jpc_seq_conv(vseq, vfilters[bandnotovind(node, cldind)]))) { + goto error; + } + jas_seq_destroy(vfilters[0]); + jas_seq_destroy(vfilters[1]); + jas_seq_destroy(vseq); + vseq = tmpseq; + } + if (node->parent) { + cldind = jpc_tsfbnode_findchild(node->parent, node); + } + node = node->parent; + } + + *hfilter = hseq; + *vfilter = vseq; + + return 0; error: - if (hseq) { - jas_seq_destroy(hseq); - } - if (vseq) { - jas_seq_destroy(vseq); - } - return -1; + if (hseq) { + jas_seq_destroy(hseq); + } + if (vseq) { + jas_seq_destroy(vseq); + } + return -1; } static int jpc_tsfbnode_findchild(jpc_tsfbnode_t *parnode, jpc_tsfbnode_t *cldnode) { - int i; - - for (i = 0; i < parnode->maxchildren; i++) { - if (parnode->children[i] == cldnode) - return i; - } - assert(0); - return -1; + int i; + + for (i = 0; i < parnode->maxchildren; i++) { + if (parnode->children[i] == cldnode) + return i; + } + assert(0); + return -1; } jpc_tsfb_t *jpc_cod_gettsfb(int qmfbid, int numlevels) { - jpc_tsfb_t *tsfb; - - switch (qmfbid) { - case JPC_COX_RFT: - qmfbid = JPC_QMFB1D_FT; - break; - case JPC_COX_INS: - qmfbid = JPC_QMFB1D_NS; - break; - default: - assert(0); - qmfbid = 10; - break; - } + jpc_tsfb_t *tsfb; + + switch (qmfbid) { + case JPC_COX_RFT: + qmfbid = JPC_QMFB1D_FT; + break; + case JPC_COX_INS: + qmfbid = JPC_QMFB1D_NS; + break; + default: + assert(0); + qmfbid = 10; + break; + } { - jpc_qmfb1d_t *hqmfb; - hqmfb = jpc_qmfb1d_make(qmfbid); - assert(hqmfb); - tsfb = jpc_tsfb_wavelet(hqmfb, hqmfb, numlevels); - assert(tsfb); - jpc_qmfb1d_destroy(hqmfb); + jpc_qmfb1d_t *hqmfb; + hqmfb = jpc_qmfb1d_make(qmfbid); + assert(hqmfb); + tsfb = jpc_tsfb_wavelet(hqmfb, hqmfb, numlevels); + assert(tsfb); + jpc_qmfb1d_destroy(hqmfb); } - return tsfb; + return tsfb; } diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_tsfb.h b/converter/other/jpeg2000/libjasper/jpc/jpc_tsfb.h index 8670c22e..3558cadb 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_tsfb.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_tsfb.h @@ -6,14 +6,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -21,22 +21,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -56,17 +56,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -106,7 +106,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ @@ -132,19 +132,19 @@ * Constants. \******************************************************************************/ -#define JPC_TSFB_MAXBANDS (JPC_TSFB_MAXDEPTH * 3 + 1) -#define JPC_TSFB_MAXDEPTH 32 -#define JPC_TSFB_RITIMODE JPC_QMFB1D_RITIMODE +#define JPC_TSFB_MAXBANDS (JPC_TSFB_MAXDEPTH * 3 + 1) +#define JPC_TSFB_MAXDEPTH 32 +#define JPC_TSFB_RITIMODE JPC_QMFB1D_RITIMODE -#define JPC_TSFB_MAXBANDSPERNODE (JPC_QMFB1D_MAXCHANS * JPC_QMFB1D_MAXCHANS) +#define JPC_TSFB_MAXBANDSPERNODE (JPC_QMFB1D_MAXCHANS * JPC_QMFB1D_MAXCHANS) -#define JPC_TSFB_PRUNEVERT 0x01 -#define JPC_TSFB_PRUNEHORZ 0x02 +#define JPC_TSFB_PRUNEVERT 0x01 +#define JPC_TSFB_PRUNEHORZ 0x02 -#define JPC_TSFB_LL 0 -#define JPC_TSFB_LH 1 -#define JPC_TSFB_HL 2 -#define JPC_TSFB_HH 3 +#define JPC_TSFB_LL 0 +#define JPC_TSFB_LH 1 +#define JPC_TSFB_HL 2 +#define JPC_TSFB_HH 3 /******************************************************************************\ * Types. @@ -152,45 +152,45 @@ typedef struct { - int xstart; - int ystart; - int xend; - int yend; - int locxstart; - int locystart; - int locxend; - int locyend; + int xstart; + int ystart; + int xend; + int yend; + int locxstart; + int locystart; + int locxend; + int locyend; } jpc_tsfbnodeband_t; typedef struct jpc_tsfbnode_s { - int numhchans; - int numvchans; - jpc_qmfb1d_t *hqmfb; - jpc_qmfb1d_t *vqmfb; - int maxchildren; - int numchildren; - struct jpc_tsfbnode_s *children[JPC_TSFB_MAXBANDSPERNODE]; - struct jpc_tsfbnode_s *parent; + int numhchans; + int numvchans; + jpc_qmfb1d_t *hqmfb; + jpc_qmfb1d_t *vqmfb; + int maxchildren; + int numchildren; + struct jpc_tsfbnode_s *children[JPC_TSFB_MAXBANDSPERNODE]; + struct jpc_tsfbnode_s *parent; } jpc_tsfbnode_t; typedef struct { - jpc_tsfbnode_t *root; + jpc_tsfbnode_t *root; } jpc_tsfb_t; typedef struct { - int xstart; - int ystart; - int xend; - int yend; - int orient; - int locxstart; - int locystart; - int locxend; - int locyend; - jpc_fix_t synenergywt; + int xstart; + int ystart; + int xend; + int yend; + int orient; + int locxstart; + int locystart; + int locxend; + int locyend; + jpc_fix_t synenergywt; } jpc_tsfb_band_t; /******************************************************************************\ diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_util.c b/converter/other/jpeg2000/libjasper/jpc/jpc_util.c index e6e3942a..12a41c3f 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_util.c +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_util.c @@ -139,32 +139,32 @@ static unsigned int countOfTokens(const char * const s, - const char * const delim) { + const char * const delim) { - unsigned int n; - char buf[4096]; - const char * cp; + unsigned int n; + char buf[4096]; + const char * cp; - strncpy(buf, s, sizeof(buf)); - buf[sizeof(buf) - 1] = '\0'; - n = 0; /* initial value */ - if ((cp = strtok(buf, delim))) { - ++n; - while ((cp = strtok(0, delim))) { - if (cp[0] != '\0') { - ++n; - } - } - } - return n; + strncpy(buf, s, sizeof(buf)); + buf[sizeof(buf) - 1] = '\0'; + n = 0; /* initial value */ + if ((cp = strtok(buf, delim))) { + ++n; + while ((cp = strtok(0, delim))) { + if (cp[0] != '\0') { + ++n; + } + } + } + return n; } int jpc_atoaf(const char * const s, - int * const numvaluesP, - double ** const valuesP) { + int * const numvaluesP, + double ** const valuesP) { /*---------------------------------------------------------------------------- Parse a string like "3.2,9,-5". Return as *numvaluesP the number of values in the string and as *valuesP a malloced array of the values. @@ -173,96 +173,96 @@ jpc_atoaf(const char * const s, Delimiters can be comma as in the example or space, tab, or newline. -----------------------------------------------------------------------------*/ - char const delim[] = ", \t\n"; + char const delim[] = ", \t\n"; - unsigned int const valueCt = countOfTokens(s, delim); + unsigned int const valueCt = countOfTokens(s, delim); - if (valueCt > 0) { - unsigned int i; - double * vs; - const char * cp; - char buf[4096]; + if (valueCt > 0) { + unsigned int i; + double * vs; + const char * cp; + char buf[4096]; - if (!(vs = jas_malloc(valueCt * sizeof(double)))) { - return -1; - } + if (!(vs = jas_malloc(valueCt * sizeof(double)))) { + return -1; + } - strncpy(buf, s, sizeof(buf)); - buf[sizeof(buf) - 1] = '\0'; - i = 0; - if ((cp = strtok(buf, delim))) { - vs[i] = atof(cp); - ++i; - while ((cp = strtok(0, delim))) { - if (cp[0] != '\0') { - vs[i] = atof(cp); - ++i; - } - } - } - assert(i == valueCt); - *numvaluesP = valueCt; - *valuesP = vs; - } else { - *valuesP = NULL; - *numvaluesP = 0; - } - return 0; + strncpy(buf, s, sizeof(buf)); + buf[sizeof(buf) - 1] = '\0'; + i = 0; + if ((cp = strtok(buf, delim))) { + vs[i] = atof(cp); + ++i; + while ((cp = strtok(0, delim))) { + if (cp[0] != '\0') { + vs[i] = atof(cp); + ++i; + } + } + } + assert(i == valueCt); + *numvaluesP = valueCt; + *valuesP = vs; + } else { + *valuesP = NULL; + *numvaluesP = 0; + } + return 0; } jas_seq_t *jpc_seq_upsample(jas_seq_t *x, int m) { - jas_seq_t *z; - int i; + jas_seq_t *z; + int i; - if (!(z = jas_seq_create(jas_seq_start(x) * m, (jas_seq_end(x) - 1) * m + 1))) - return 0; - for (i = jas_seq_start(z); i < jas_seq_end(z); i++) { - *jas_seq_getref(z, i) = (!JAS_MOD(i, m)) ? jas_seq_get(x, i / m) : - jpc_inttofix(0); - } + if (!(z = jas_seq_create(jas_seq_start(x) * m, (jas_seq_end(x) - 1) * m + 1))) + return 0; + for (i = jas_seq_start(z); i < jas_seq_end(z); i++) { + *jas_seq_getref(z, i) = (!JAS_MOD(i, m)) ? jas_seq_get(x, i / m) : + jpc_inttofix(0); + } - return z; + return z; } jpc_fix_t jpc_seq_norm(jas_seq_t *x) { - jpc_fix_t s; - int i; + jpc_fix_t s; + int i; - s = jpc_inttofix(0); - for (i = jas_seq_start(x); i < jas_seq_end(x); i++) { - s = jpc_fix_add(s, jpc_fix_mul(jas_seq_get(x, i), jas_seq_get(x, i))); - } + s = jpc_inttofix(0); + for (i = jas_seq_start(x); i < jas_seq_end(x); i++) { + s = jpc_fix_add(s, jpc_fix_mul(jas_seq_get(x, i), jas_seq_get(x, i))); + } - return jpc_dbltofix(sqrt(jpc_fixtodbl(s))); + return jpc_dbltofix(sqrt(jpc_fixtodbl(s))); } jas_seq_t *jpc_seq_conv(jas_seq_t *x, jas_seq_t *y) { - int i; - int j; - int k; - jas_seq_t *z; - jpc_fix_t s; - jpc_fix_t v; + int i; + int j; + int k; + jas_seq_t *z; + jpc_fix_t s; + jpc_fix_t v; - z = jas_seq_create(jas_seq_start(x) + jas_seq_start(y), - jas_seq_end(x) + jas_seq_end(y) - 1); - assert(z); - for (i = jas_seq_start(z); i < jas_seq_end(z); i++) { - s = jpc_inttofix(0); - for (j = jas_seq_start(y); j < jas_seq_end(y); j++) { - k = i - j; - if (k < jas_seq_start(x) || k >= jas_seq_end(x)) { - v = JPC_FIX_ZERO; - } else { - v = jas_seq_get(x, k); - } - s = jpc_fix_add(s, jpc_fix_mul(jas_seq_get(y, j), v)); - } - *jas_seq_getref(z, i) = s; - } + z = jas_seq_create(jas_seq_start(x) + jas_seq_start(y), + jas_seq_end(x) + jas_seq_end(y) - 1); + assert(z); + for (i = jas_seq_start(z); i < jas_seq_end(z); i++) { + s = jpc_inttofix(0); + for (j = jas_seq_start(y); j < jas_seq_end(y); j++) { + k = i - j; + if (k < jas_seq_start(x) || k >= jas_seq_end(x)) { + v = JPC_FIX_ZERO; + } else { + v = jas_seq_get(x, k); + } + s = jpc_fix_add(s, jpc_fix_mul(jas_seq_get(y, j), v)); + } + *jas_seq_getref(z, i) = s; + } - return z; + return z; } diff --git a/converter/other/jpeg2000/libjasper/jpc/jpc_util.h b/converter/other/jpeg2000/libjasper/jpc/jpc_util.h index c23fc33b..f1d90385 100644 --- a/converter/other/jpeg2000/libjasper/jpc/jpc_util.h +++ b/converter/other/jpeg2000/libjasper/jpc/jpc_util.h @@ -4,14 +4,14 @@ */ /* __START_OF_JASPER_LICENSE__ - * + * * JasPer Software License - * + * * IMAGE POWER JPEG-2000 PUBLIC LICENSE * ************************************ - * + * * GRANT: - * + * * Permission is hereby granted, free of charge, to any person (the "User") * obtaining a copy of this software and associated documentation, to deal * in the JasPer Software without restriction, including without limitation @@ -19,22 +19,22 @@ * and/or sell copies of the JasPer Software (in source and binary forms), * and to permit persons to whom the JasPer Software is furnished to do so, * provided further that the License Conditions below are met. - * + * * License Conditions * ****************** - * + * * A. Redistributions of source code must retain the above copyright notice, * and this list of conditions, and the following disclaimer. - * + * * B. Redistributions in binary form must reproduce the above copyright * notice, and this list of conditions, and the following disclaimer in * the documentation and/or other materials provided with the distribution. - * + * * C. Neither the name of Image Power, Inc. nor any other contributor * (including, but not limited to, the University of British Columbia and * Michael David Adams) may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * D. User agrees that it shall not commence any action against Image Power, * Inc., the University of British Columbia, Michael David Adams, or any * other contributors (collectively "Licensors") for infringement of any @@ -54,17 +54,17 @@ * trade dress, or service mark rights); and (v) divisions, continuations, * renewals, reissues and extensions of the foregoing (as and to the extent * applicable) now existing, hereafter filed, issued or acquired. - * + * * E. If User commences an infringement action against any Licensor(s) then * such Licensor(s) shall have the right to terminate User's license and * all sublicenses that have been granted hereunder by User to other parties. - * + * * F. This software is for use only in hardware or software products that * are compliant with ISO/IEC 15444-1 (i.e., JPEG-2000 Part 1). No license * or right to this Software is granted for products that do not comply * with ISO/IEC 15444-1. The JPEG-2000 Part 1 standard can be purchased * from the ISO. - * + * * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. * NO USE OF THE JASPER SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER * THIS DISCLAIMER. THE JASPER SOFTWARE IS PROVIDED BY THE LICENSORS AND @@ -104,7 +104,7 @@ * TECHNOLOGY OR PRODUCTS FOR HIGH RISK ACTIVITIES AND WILL ENSURE THAT ITS * CUSTOMERS AND END-USERS OF ITS PRODUCTS ARE PROVIDED WITH A COPY OF THE * NOTICE SPECIFIED IN THIS SECTION. - * + * * __END_OF_JASPER_LICENSE__ */ diff --git a/converter/other/jpeg2000/pamtojpeg2k.c b/converter/other/jpeg2000/pamtojpeg2k.c index 8f7409c0..ea9ad492 100644 --- a/converter/other/jpeg2000/pamtojpeg2k.c +++ b/converter/other/jpeg2000/pamtojpeg2k.c @@ -314,7 +314,7 @@ static void createJasperImage(struct pam * const inpamP, jas_image_t ** const jasperPP) { - jas_image_cmptparm_t * cmptparms; + jas_image_cmptparm_t * cmptparms; unsigned int plane; MALLOCARRAY_NOFAIL(cmptparms, inpamP->depth); @@ -489,7 +489,7 @@ writeJpc(jas_image_t * const jasperP, pm_error("jas_image_encode() failed to encode the JPEG 2000 " "image. Rc=%d", rc); } - jas_stream_flush(outStreamP); + jas_stream_flush(outStreamP); { int rc; @@ -501,7 +501,7 @@ writeJpc(jas_image_t * const jasperP, "jas_stream_close() rc = %d", rc); } - jas_image_clearfmts(); + jas_image_clearfmts(); pm_strfree(options); } @@ -539,7 +539,7 @@ main(int argc, char **argv) writeJpc(jasperP, cmdline, fileno(stdout)); - jas_image_destroy(jasperP); + jas_image_destroy(jasperP); pm_close(ifP); |