Same for lxdialog and xvmc

lxdialog/checklist.c

@@ -30,7 +30,7 @@ static int list_width, check_x, item_x, checkflag;
  */
 static void
 print_item (WINDOW * win, const char *item, int status,
-        int choice, int selected)
+	    int choice, int selected)
 {
     int i;
 
@@ -38,22 +38,22 @@ print_item (WINDOW * win, const char *item, int status,
     wattrset (win, menubox_attr);
     wmove (win, choice, 0);
     for (i = 0; i < list_width; i++)
-    waddch (win, ' ');
+	waddch (win, ' ');
 
     wmove (win, choice, check_x);
     wattrset (win, selected ? check_selected_attr : check_attr);
     if (checkflag == FLAG_CHECK)
-    wprintw (win, "[%c]", status ? 'X' : ' ');
+	wprintw (win, "[%c]", status ? 'X' : ' ');
     else
-    wprintw (win, "(%c)", status ? 'X' : ' ');
+	wprintw (win, "(%c)", status ? 'X' : ' ');
 
     wattrset (win, selected ? tag_selected_attr : tag_attr);
     mvwaddch(win, choice, item_x, item[0]);
     wattrset (win, selected ? item_selected_attr : item_attr);
     waddstr (win, (char *)item+1);
     if (selected) {
-        wmove (win, choice, check_x+1);
-        wrefresh (win);
+    	wmove (win, choice, check_x+1);
+    	wrefresh (win);
     }
 }
 
@@ -62,37 +62,37 @@ print_item (WINDOW * win, const char *item, int status,
  */
 static void
 print_arrows (WINDOW * win, int choice, int item_no, int scroll,
-        int y, int x, int height)
+		int y, int x, int height)
 {
     wmove(win, y, x);
 
     if (scroll > 0) {
-    wattrset (win, uarrow_attr);
-    waddch (win, ACS_UARROW);
-    waddstr (win, "(-)");
+	wattrset (win, uarrow_attr);
+	waddch (win, ACS_UARROW);
+	waddstr (win, "(-)");
     }
     else {
-    wattrset (win, menubox_attr);
-    waddch (win, ACS_HLINE);
-    waddch (win, ACS_HLINE);
-    waddch (win, ACS_HLINE);
-    waddch (win, ACS_HLINE);
+	wattrset (win, menubox_attr);
+	waddch (win, ACS_HLINE);
+	waddch (win, ACS_HLINE);
+	waddch (win, ACS_HLINE);
+	waddch (win, ACS_HLINE);
     }
 
    y = y + height + 1;
    wmove(win, y, x);
 
    if ((height < item_no) && (scroll + choice < item_no - 1)) {
-    wattrset (win, darrow_attr);
-    waddch (win, ACS_DARROW);
-    waddstr (win, "(+)");
+	wattrset (win, darrow_attr);
+	waddch (win, ACS_DARROW);
+	waddstr (win, "(+)");
     }
     else {
-    wattrset (win, menubox_border_attr);
-    waddch (win, ACS_HLINE);
-    waddch (win, ACS_HLINE);
-    waddch (win, ACS_HLINE);
-    waddch (win, ACS_HLINE);
+	wattrset (win, menubox_border_attr);
+	waddch (win, ACS_HLINE);
+	waddch (win, ACS_HLINE);
+	waddch (win, ACS_HLINE);
+	waddch (win, ACS_HLINE);
    }
 }
 
@@ -118,8 +118,8 @@ print_buttons( WINDOW *dialog, int height, int width, int selected)
  */
 int
 dialog_checklist (const char *title, const char *prompt, int height, int width,
-    int list_height, int item_no, const char * const * items, int flag)
-    
+	int list_height, int item_no, const char * const * items, int flag)
+	
 {
     int i, x, y, box_x, box_y;
     int key = 0, button = 0, choice = 0, scroll = 0, max_choice, *status;
@@ -129,16 +129,16 @@ dialog_checklist (const char *title, const char *prompt, int height, int width,
 
     /* Allocate space for storing item on/off status */
     if ((status = malloc (sizeof (int) * item_no)) == NULL) {
-    endwin ();
-    fprintf (stderr,
-         "\nCan't allocate memory in dialog_checklist().\n");
-    exit (-1);
+	endwin ();
+	fprintf (stderr,
+		 "\nCan't allocate memory in dialog_checklist().\n");
+	exit (-1);
     }
 
     /* Initializes status */
     for (i = 0; i < item_no; i++) {
-    status[i] = !strcasecmp (items[i * 3 + 2], "on");
-    if (!choice && status[i])
+	status[i] = !strcasecmp (items[i * 3 + 2], "on");
+	if (!choice && status[i])
             choice = i;
     }
 
@@ -157,23 +157,23 @@ dialog_checklist (const char *title, const char *prompt, int height, int width,
     wattrset (dialog, border_attr);
     mvwaddch (dialog, height-3, 0, ACS_LTEE);
     for (i = 0; i < width - 2; i++)
-    waddch (dialog, ACS_HLINE);
+	waddch (dialog, ACS_HLINE);
     wattrset (dialog, dialog_attr);
     waddch (dialog, ACS_RTEE);
 
     if (title != NULL && strlen(title) >= width-2 ) {
-    /* truncate long title -- mec */
-    char * title2 = malloc(width-2+1);
-    memcpy( title2, title, width-2 );
-    title2[width-2] = '\0';
-    title = title2;
+	/* truncate long title -- mec */
+	char * title2 = malloc(width-2+1);
+	memcpy( title2, title, width-2 );
+	title2[width-2] = '\0';
+	title = title2;
     }
 
     if (title != NULL) {
-    wattrset (dialog, title_attr);
-    mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' ');
-    waddstr (dialog, (char *)title);
-    waddch (dialog, ' ');
+	wattrset (dialog, title_attr);
+	mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' ');
+	waddstr (dialog, (char *)title);
+	waddch (dialog, ' ');
     }
 
     wattrset (dialog, dialog_attr);
@@ -190,29 +190,29 @@ dialog_checklist (const char *title, const char *prompt, int height, int width,
 
     /* draw a box around the list items */
     draw_box (dialog, box_y, box_x, list_height + 2, list_width + 2,
-          menubox_border_attr, menubox_attr);
+	      menubox_border_attr, menubox_attr);
 
     /* Find length of longest item in order to center checklist */
     check_x = 0;
-    for (i = 0; i < item_no; i++)
-    check_x = MAX (check_x, + strlen (items[i * 3 + 1]) + 4);
+    for (i = 0; i < item_no; i++) 
+	check_x = MAX (check_x, + strlen (items[i * 3 + 1]) + 4);
 
     check_x = (list_width - check_x) / 2;
     item_x = check_x + 4;
 
     if (choice >= list_height) {
-    scroll = choice - list_height + 1;
-    choice -= scroll;
+	scroll = choice - list_height + 1;
+	choice -= scroll;
     }
 
     /* Print the list */
     for (i = 0; i < max_choice; i++) {
-    print_item (list, items[(scroll+i) * 3 + 1],
-            status[i+scroll], i, i == choice);
+	print_item (list, items[(scroll+i) * 3 + 1],
+		    status[i+scroll], i, i == choice);
     }
 
     print_arrows(dialog, choice, item_no, scroll,
-            box_y, box_x + check_x + 5, list_height);
+			box_y, box_x + check_x + 5, list_height);
 
     print_buttons(dialog, height, width, 0);
 
@@ -221,149 +221,149 @@ dialog_checklist (const char *title, const char *prompt, int height, int width,
     doupdate ();
 
     while (key != ESC) {
-    key = wgetch (dialog);
+	key = wgetch (dialog);
 
-        for (i = 0; i < max_choice; i++)
+    	for (i = 0; i < max_choice; i++)
             if (toupper(key) == toupper(items[(scroll+i)*3+1][0]))
                 break;
 
 
-    if ( i < max_choice || key == KEY_UP || key == KEY_DOWN ||
-        key == '+' || key == '-' ) {
-        if (key == KEY_UP || key == '-') {
-        if (!choice) {
-            if (!scroll)
-            continue;
-            /* Scroll list down */
-            if (list_height > 1) {
-            /* De-highlight current first item */
-            print_item (list, items[scroll * 3 + 1],
-                    status[scroll], 0, FALSE);
-            scrollok (list, TRUE);
-            wscrl (list, -1);
-            scrollok (list, FALSE);
+	if ( i < max_choice || key == KEY_UP || key == KEY_DOWN || 
+	    key == '+' || key == '-' ) {
+	    if (key == KEY_UP || key == '-') {
+		if (!choice) {
+		    if (!scroll)
+			continue;
+		    /* Scroll list down */
+		    if (list_height > 1) {
+			/* De-highlight current first item */
+			print_item (list, items[scroll * 3 + 1],
+					status[scroll], 0, FALSE);
+			scrollok (list, TRUE);
+			wscrl (list, -1);
+			scrollok (list, FALSE);
+		    }
+		    scroll--;
+		    print_item (list, items[scroll * 3 + 1],
+				status[scroll], 0, TRUE);
+		    wnoutrefresh (list);
+
+    		    print_arrows(dialog, choice, item_no, scroll,
+				box_y, box_x + check_x + 5, list_height);
+
+		    wrefresh (dialog);
+
+		    continue;	/* wait for another key press */
+		} else
+		    i = choice - 1;
+	    } else if (key == KEY_DOWN || key == '+') {
+		if (choice == max_choice - 1) {
+		    if (scroll + choice >= item_no - 1)
+			continue;
+		    /* Scroll list up */
+		    if (list_height > 1) {
+			/* De-highlight current last item before scrolling up */
+			print_item (list, items[(scroll + max_choice - 1) * 3 + 1],
+				    status[scroll + max_choice - 1],
+				    max_choice - 1, FALSE);
+			scrollok (list, TRUE);
+			scroll (list);
+			scrollok (list, FALSE);
+		    }
+		    scroll++;
+		    print_item (list, items[(scroll + max_choice - 1) * 3 + 1],
+				status[scroll + max_choice - 1],
+				max_choice - 1, TRUE);
+		    wnoutrefresh (list);
+
+    		    print_arrows(dialog, choice, item_no, scroll,
+				box_y, box_x + check_x + 5, list_height);
+
+		    wrefresh (dialog);
+
+		    continue;	/* wait for another key press */
+		} else
+		    i = choice + 1;
+	    }
+	    if (i != choice) {
+		/* De-highlight current item */
+		print_item (list, items[(scroll + choice) * 3 + 1],
+			    status[scroll + choice], choice, FALSE);
+		/* Highlight new item */
+		choice = i;
+		print_item (list, items[(scroll + choice) * 3 + 1],
+			    status[scroll + choice], choice, TRUE);
+		wnoutrefresh (list);
+		wrefresh (dialog);
+	    }
+	    continue;		/* wait for another key press */
+	}
+	switch (key) {
+	case 'H':
+	case 'h':
+	case '?':
+	    delwin (dialog);
+	    free (status);
+	    return 1;
+	case TAB:
+	case KEY_LEFT:
+	case KEY_RIGHT:
+	    button = ((key == KEY_LEFT ? --button : ++button) < 0)
+			? 1 : (button > 1 ? 0 : button);
+
+	    print_buttons(dialog, height, width, button);
+	    wrefresh (dialog);
+	    break;
+	case 'S':
+	case 's':
+	case ' ':
+	case '\n':
+	    if (!button) {
+		if (flag == FLAG_CHECK) {
+		    status[scroll + choice] = !status[scroll + choice];
+		    wmove (list, choice, check_x);
+		    wattrset (list, check_selected_attr);
+		    wprintw (list, "[%c]", status[scroll + choice] ? 'X' : ' ');
+		} else {
+		    if (!status[scroll + choice]) {
+			for (i = 0; i < item_no; i++)
+			    status[i] = 0;
+			status[scroll + choice] = 1;
+			for (i = 0; i < max_choice; i++)
+			    print_item (list, items[(scroll + i) * 3 + 1],
+					status[scroll + i], i, i == choice);
+		    }
+		}
+		wnoutrefresh (list);
+		wrefresh (dialog);
+            
+		for (i = 0; i < item_no; i++) {
+		    if (status[i]) {
+			if (flag == FLAG_CHECK) {
+			    fprintf (stderr, "\"%s\" ", items[i * 3]);
+			} else {
+			    fprintf (stderr, "%s", items[i * 3]);
+			}
+
+		    }
+		}
             }
-            scroll--;
-            print_item (list, items[scroll * 3 + 1],
-                status[scroll], 0, TRUE);
-            wnoutrefresh (list);
-
-                print_arrows(dialog, choice, item_no, scroll,
-                box_y, box_x + check_x + 5, list_height);
-
-            wrefresh (dialog);
-
-            continue;    /* wait for another key press */
-        } else
-            i = choice - 1;
-        } else if (key == KEY_DOWN || key == '+') {
-        if (choice == max_choice - 1) {
-            if (scroll + choice >= item_no - 1)
-            continue;
-            /* Scroll list up */
-            if (list_height > 1) {
-            /* De-highlight current last item before scrolling up */
-            print_item (list, items[(scroll + max_choice - 1) * 3 + 1],
-                    status[scroll + max_choice - 1],
-                    max_choice - 1, FALSE);
-            scrollok (list, TRUE);
-            scroll (list);
-            scrollok (list, FALSE);
-            }
-            scroll++;
-            print_item (list, items[(scroll + max_choice - 1) * 3 + 1],
-                status[scroll + max_choice - 1],
-                max_choice - 1, TRUE);
-            wnoutrefresh (list);
-
-                print_arrows(dialog, choice, item_no, scroll,
-                box_y, box_x + check_x + 5, list_height);
-
-            wrefresh (dialog);
-
-            continue;    /* wait for another key press */
-        } else
-            i = choice + 1;
-        }
-        if (i != choice) {
-        /* De-highlight current item */
-        print_item (list, items[(scroll + choice) * 3 + 1],
-                status[scroll + choice], choice, FALSE);
-        /* Highlight new item */
-        choice = i;
-        print_item (list, items[(scroll + choice) * 3 + 1],
-                status[scroll + choice], choice, TRUE);
-        wnoutrefresh (list);
-        wrefresh (dialog);
-        }
-        continue;        /* wait for another key press */
+	    delwin (dialog);
+	    free (status);
+	    return button;
+	case 'X':
+	case 'x':
+	    key = ESC;
+	case ESC:
+	    break;
+	}
+
+	/* Now, update everything... */
+	doupdate ();
     }
-    switch (key) {
-    case 'H':
-    case 'h':
-    case '?':
-        delwin (dialog);
-        free (status);
-        return 1;
-    case TAB:
-    case KEY_LEFT:
-    case KEY_RIGHT:
-        button = ((key == KEY_LEFT ? --button : ++button) < 0)
-            ? 1 : (button > 1 ? 0 : button);
-
-        print_buttons(dialog, height, width, button);
-        wrefresh (dialog);
-        break;
-    case 'S':
-    case 's':
-    case ' ':
-    case '\n':
-        if (!button) {
-        if (flag == FLAG_CHECK) {
-            status[scroll + choice] = !status[scroll + choice];
-            wmove (list, choice, check_x);
-            wattrset (list, check_selected_attr);
-            wprintw (list, "[%c]", status[scroll + choice] ? 'X' : ' ');
-        } else {
-            if (!status[scroll + choice]) {
-            for (i = 0; i < item_no; i++)
-                status[i] = 0;
-            status[scroll + choice] = 1;
-            for (i = 0; i < max_choice; i++)
-                print_item (list, items[(scroll + i) * 3 + 1],
-                    status[scroll + i], i, i == choice);
-            }
-        }
-        wnoutrefresh (list);
-        wrefresh (dialog);
- 
-        for (i = 0; i < item_no; i++) {
-            if (status[i]) {
-            if (flag == FLAG_CHECK) {
-                fprintf (stderr, "\"%s\" ", items[i * 3]);
-            } else {
-                fprintf (stderr, "%s", items[i * 3]);
-            }
-
-            }
-        }
-            }
-        delwin (dialog);
-        free (status);
-        return button;
-    case 'X':
-    case 'x':
-        key = ESC;
-    case ESC:
-        break;
-    }
-
-    /* Now, update everything... */
-    doupdate ();
-    }
- 
+    
 
     delwin (dialog);
     free (status);
-    return -1;            /* ESC pressed */
+    return -1;			/* ESC pressed */
 }

lxdialog/dialog.h

@@ -85,7 +85,7 @@
 #define ACS_DARROW 'v'
 #endif
 
-/*
+/* 
  * Attribute names
  */
 #define screen_attr                   attributes[0]
@@ -146,23 +146,23 @@ void color_setup (void);
 void print_autowrap (WINDOW * win, const char *prompt, int width, int y, int x);
 void print_button (WINDOW * win, const char *label, int y, int x, int selected);
 void draw_box (WINDOW * win, int y, int x, int height, int width, chtype box,
-        chtype border);
+		chtype border);
 void draw_shadow (WINDOW * win, int y, int x, int height, int width);
 
 int first_alpha (const char *string, const char *exempt);
 int dialog_yesno (const char *title, const char *prompt, int height, int width);
 int dialog_msgbox (const char *title, const char *prompt, int height,
-        int width, int pause);
+		int width, int pause);
 int dialog_textbox (const char *title, const char *file, int height, int width);
 int dialog_menu (const char *title, const char *prompt, int height, int width,
-        int menu_height, const char *choice, int item_no,
-        const char * const * items);
+		int menu_height, const char *choice, int item_no, 
+		const char * const * items);
 int dialog_checklist (const char *title, const char *prompt, int height,
-        int width, int list_height, int item_no,
-        const char * const * items, int flag);
+		int width, int list_height, int item_no,
+		const char * const * items, int flag);
 extern unsigned char dialog_input_result[];
 int dialog_inputbox (const char *title, const char *prompt, int height,
-        int width, const char *init);
+		int width, const char *init);
 
 /*
  * This is the base for fictitious keys, which activate

lxdialog/inputbox.c

@@ -44,7 +44,7 @@ print_buttons(WINDOW *dialog, int height, int width, int selected)
  */
 int
 dialog_inputbox (const char *title, const char *prompt, int height, int width,
-         const char *init)
+		 const char *init)
 {
     int i, x, y, box_y, box_x, box_width;
     int input_x = 0, scroll = 0, key = 0, button = -1;
@@ -65,23 +65,23 @@ dialog_inputbox (const char *title, const char *prompt, int height, int width,
     wattrset (dialog, border_attr);
     mvwaddch (dialog, height-3, 0, ACS_LTEE);
     for (i = 0; i < width - 2; i++)
-    waddch (dialog, ACS_HLINE);
+	waddch (dialog, ACS_HLINE);
     wattrset (dialog, dialog_attr);
     waddch (dialog, ACS_RTEE);
 
     if (title != NULL && strlen(title) >= width-2 ) {
-    /* truncate long title -- mec */
-    char * title2 = malloc(width-2+1);
-    memcpy( title2, title, width-2 );
-    title2[width-2] = '\0';
-    title = title2;
+	/* truncate long title -- mec */
+	char * title2 = malloc(width-2+1);
+	memcpy( title2, title, width-2 );
+	title2[width-2] = '\0';
+	title = title2;
     }
 
     if (title != NULL) {
-    wattrset (dialog, title_attr);
-    mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' ');
-    waddstr (dialog, (char *)title);
-    waddch (dialog, ' ');
+	wattrset (dialog, title_attr);
+	mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' ');
+	waddstr (dialog, (char *)title);
+	waddch (dialog, ' ');
     }
 
     wattrset (dialog, dialog_attr);
@@ -93,7 +93,7 @@ dialog_inputbox (const char *title, const char *prompt, int height, int width,
     box_y = y + 2;
     box_x = (width - box_width) / 2;
     draw_box (dialog, y + 1, box_x - 1, 3, box_width + 2,
-          border_attr, dialog_attr);
+	      border_attr, dialog_attr);
 
     print_buttons(dialog, height, width, 0);
 
@@ -102,139 +102,139 @@ dialog_inputbox (const char *title, const char *prompt, int height, int width,
     wattrset (dialog, inputbox_attr);
 
     if (!init)
-    instr[0] = '\0';
+	instr[0] = '\0';
     else
-    strcpy (instr, init);
+	strcpy (instr, init);
 
     input_x = strlen (instr);
 
     if (input_x >= box_width) {
-    scroll = input_x - box_width + 1;
-    input_x = box_width - 1;
-    for (i = 0; i < box_width - 1; i++)
-        waddch (dialog, instr[scroll + i]);
+	scroll = input_x - box_width + 1;
+	input_x = box_width - 1;
+	for (i = 0; i < box_width - 1; i++)
+	    waddch (dialog, instr[scroll + i]);
     } else
-    waddstr (dialog, instr);
+	waddstr (dialog, instr);
 
     wmove (dialog, box_y, box_x + input_x);
 
     wrefresh (dialog);
 
     while (key != ESC) {
-    key = wgetch (dialog);
-
-    if (button == -1) {    /* Input box selected */
-        switch (key) {
-        case TAB:
-        case KEY_UP:
-        case KEY_DOWN:
-        break;
-        case KEY_LEFT:
-        continue;
-        case KEY_RIGHT:
-        continue;
-        case KEY_BACKSPACE:
-        case 127:
-        if (input_x || scroll) {
-            wattrset (dialog, inputbox_attr);
-            if (!input_x) {
-            scroll = scroll < box_width - 1 ?
-                0 : scroll - (box_width - 1);
-            wmove (dialog, box_y, box_x);
-            for (i = 0; i < box_width; i++)
-                waddch (dialog, instr[scroll + input_x + i] ?
-                    instr[scroll + input_x + i] : ' ');
-            input_x = strlen (instr) - scroll;
-            } else
-            input_x--;
-            instr[scroll + input_x] = '\0';
-            mvwaddch (dialog, box_y, input_x + box_x, ' ');
-            wmove (dialog, box_y, input_x + box_x);
-            wrefresh (dialog);
-        }
-        continue;
-        default:
-        if (key < 0x100 && isprint (key)) {
-            if (scroll + input_x < MAX_LEN) {
-            wattrset (dialog, inputbox_attr);
-            instr[scroll + input_x] = key;
-            instr[scroll + input_x + 1] = '\0';
-            if (input_x == box_width - 1) {
-                scroll++;
-                wmove (dialog, box_y, box_x);
-                for (i = 0; i < box_width - 1; i++)
-                waddch (dialog, instr[scroll + i]);
-            } else {
-                wmove (dialog, box_y, input_x++ + box_x);
-                waddch (dialog, key);
-            }
-            wrefresh (dialog);
-            } else
-            flash ();    /* Alarm user about overflow */
-            continue;
-        }
-        }
-    }
-    switch (key) {
-    case 'O':
-    case 'o':
-        delwin (dialog);
-        return 0;
-    case 'H':
-    case 'h':
-        delwin (dialog);
-        return 1;
-    case KEY_UP:
-    case KEY_LEFT:
-        switch (button) {
-        case -1:
-        button = 1;    /* Indicates "Cancel" button is selected */
-        print_buttons(dialog, height, width, 1);
-        break;
-        case 0:
-        button = -1;    /* Indicates input box is selected */
-        print_buttons(dialog, height, width, 0);
-        wmove (dialog, box_y, box_x + input_x);
-        wrefresh (dialog);
-        break;
-        case 1:
-        button = 0;    /* Indicates "OK" button is selected */
-        print_buttons(dialog, height, width, 0);
-        break;
-        }
-        break;
-    case TAB:
-    case KEY_DOWN:
-    case KEY_RIGHT:
-        switch (button) {
-        case -1:
-        button = 0;    /* Indicates "OK" button is selected */
-        print_buttons(dialog, height, width, 0);
-        break;
-        case 0:
-        button = 1;    /* Indicates "Cancel" button is selected */
-        print_buttons(dialog, height, width, 1);
-        break;
-        case 1:
-        button = -1;    /* Indicates input box is selected */
-        print_buttons(dialog, height, width, 0);
-        wmove (dialog, box_y, box_x + input_x);
-        wrefresh (dialog);
-        break;
-        }
-        break;
-    case ' ':
-    case '\n':
-        delwin (dialog);
-        return (button == -1 ? 0 : button);
-    case 'X':
-    case 'x':
-        key = ESC;
-    case ESC:
-        break;
-    }
+	key = wgetch (dialog);
+
+	if (button == -1) {	/* Input box selected */
+	    switch (key) {
+	    case TAB:
+	    case KEY_UP:
+	    case KEY_DOWN:
+		break;
+	    case KEY_LEFT:
+		continue;
+	    case KEY_RIGHT:
+		continue;
+	    case KEY_BACKSPACE:
+	    case 127:
+		if (input_x || scroll) {
+		    wattrset (dialog, inputbox_attr);
+		    if (!input_x) {
+			scroll = scroll < box_width - 1 ?
+			    0 : scroll - (box_width - 1);
+			wmove (dialog, box_y, box_x);
+			for (i = 0; i < box_width; i++)
+			    waddch (dialog, instr[scroll + input_x + i] ?
+				    instr[scroll + input_x + i] : ' ');
+			input_x = strlen (instr) - scroll;
+		    } else
+			input_x--;
+		    instr[scroll + input_x] = '\0';
+		    mvwaddch (dialog, box_y, input_x + box_x, ' ');
+		    wmove (dialog, box_y, input_x + box_x);
+		    wrefresh (dialog);
+		}
+		continue;
+	    default:
+		if (key < 0x100 && isprint (key)) {
+		    if (scroll + input_x < MAX_LEN) {
+			wattrset (dialog, inputbox_attr);
+			instr[scroll + input_x] = key;
+			instr[scroll + input_x + 1] = '\0';
+			if (input_x == box_width - 1) {
+			    scroll++;
+			    wmove (dialog, box_y, box_x);
+			    for (i = 0; i < box_width - 1; i++)
+				waddch (dialog, instr[scroll + i]);
+			} else {
+			    wmove (dialog, box_y, input_x++ + box_x);
+			    waddch (dialog, key);
+			}
+			wrefresh (dialog);
+		    } else
+			flash ();	/* Alarm user about overflow */
+		    continue;
+		}
+	    }
+	}
+	switch (key) {
+	case 'O':
+	case 'o':
+	    delwin (dialog);
+	    return 0;
+	case 'H':
+	case 'h':
+	    delwin (dialog);
+	    return 1;
+	case KEY_UP:
+	case KEY_LEFT:
+	    switch (button) {
+	    case -1:
+		button = 1;	/* Indicates "Cancel" button is selected */
+		print_buttons(dialog, height, width, 1);
+		break;
+	    case 0:
+		button = -1;	/* Indicates input box is selected */
+		print_buttons(dialog, height, width, 0);
+		wmove (dialog, box_y, box_x + input_x);
+		wrefresh (dialog);
+		break;
+	    case 1:
+		button = 0;	/* Indicates "OK" button is selected */
+		print_buttons(dialog, height, width, 0);
+		break;
+	    }
+	    break;
+	case TAB:
+	case KEY_DOWN:
+	case KEY_RIGHT:
+	    switch (button) {
+	    case -1:
+		button = 0;	/* Indicates "OK" button is selected */
+		print_buttons(dialog, height, width, 0);
+		break;
+	    case 0:
+		button = 1;	/* Indicates "Cancel" button is selected */
+		print_buttons(dialog, height, width, 1);
+		break;
+	    case 1:
+		button = -1;	/* Indicates input box is selected */
+		print_buttons(dialog, height, width, 0);
+		wmove (dialog, box_y, box_x + input_x);
+		wrefresh (dialog);
+		break;
+	    }
+	    break;
+	case ' ':
+	case '\n':
+	    delwin (dialog);
+	    return (button == -1 ? 0 : button);
+	case 'X':
+	case 'x':
+	    key = ESC;
+	case ESC:
+	    break;
+	}
     }
 
     delwin (dialog);
-    return -1;            /* ESC pressed */
+    return -1;			/* ESC pressed */
 }

lxdialog/lxdialog.c

@@ -67,19 +67,19 @@ main (int argc, const char * const * argv)
     trace(TRACE_CALLS|TRACE_UPDATE);
 #endif
     if (argc < 2) {
-    Usage (argv[0]);
-    exit (-1);
+	Usage (argv[0]);
+	exit (-1);
     }
 
-    while (offset < argc - 1 && !end_common_opts) {    /* Common options */
-    if (!strcmp (argv[offset + 1], "--title")) {
-        if (argc - offset < 3 || title != NULL) {
-        Usage (argv[0]);
-        exit (-1);
-        } else {
-        title = argv[offset + 2];
-        offset += 2;
-        }
+    while (offset < argc - 1 && !end_common_opts) {	/* Common options */
+	if (!strcmp (argv[offset + 1], "--title")) {
+	    if (argc - offset < 3 || title != NULL) {
+		Usage (argv[0]);
+		exit (-1);
+	    } else {
+		title = argv[offset + 2];
+		offset += 2;
+	    }
         } else if (!strcmp (argv[offset + 1], "--backtitle")) {
             if (backtitle != NULL) {
                 Usage (argv[0]);
@@ -88,48 +88,48 @@ main (int argc, const char * const * argv)
                 backtitle = argv[offset + 2];
                 offset += 2;
             }
-    } else if (!strcmp (argv[offset + 1], "--clear")) {
-        if (clear_screen) {    /* Hey, "--clear" can't appear twice! */
-        Usage (argv[0]);
-        exit (-1);
-        } else if (argc == 2) {    /* we only want to clear the screen */
-        init_dialog ();
-        refresh ();    /* init_dialog() will clear the screen for us */
-        end_dialog ();
-        return 0;
-        } else {
-        clear_screen = 1;
-        offset++;
-        }
-    } else            /* no more common options */
-        end_common_opts = 1;
+	} else if (!strcmp (argv[offset + 1], "--clear")) {
+	    if (clear_screen) {	/* Hey, "--clear" can't appear twice! */
+		Usage (argv[0]);
+		exit (-1);
+	    } else if (argc == 2) {	/* we only want to clear the screen */
+		init_dialog ();
+		refresh ();	/* init_dialog() will clear the screen for us */
+		end_dialog ();
+		return 0;
+	    } else {
+		clear_screen = 1;
+		offset++;
+	    }
+	} else			/* no more common options */
+	    end_common_opts = 1;
     }
 
-    if (argc - 1 == offset) {    /* no more options */
-    Usage (argv[0]);
-    exit (-1);
+    if (argc - 1 == offset) {	/* no more options */
+	Usage (argv[0]);
+	exit (-1);
     }
     /* use a table to look for the requested mode, to avoid code duplication */
 
-    for (modePtr = modes; modePtr->name; modePtr++)    /* look for the mode */
-    if (!strcmp (argv[offset + 1], modePtr->name))
-        break;
+    for (modePtr = modes; modePtr->name; modePtr++)	/* look for the mode */
+	if (!strcmp (argv[offset + 1], modePtr->name))
+	    break;
 
     if (!modePtr->name)
-    Usage (argv[0]);
+	Usage (argv[0]);
     if (argc - offset < modePtr->argmin)
-    Usage (argv[0]);
+	Usage (argv[0]);
     if (modePtr->argmax && argc - offset > modePtr->argmax)
-    Usage (argv[0]);
+	Usage (argv[0]);
 
 
 
     init_dialog ();
     retval = (*(modePtr->jumper)) (title, argc - offset, argv + offset);
 
-    if (clear_screen) {        /* clear screen before exit */
-    attr_clear (stdscr, LINES, COLS, screen_attr);
-    refresh ();
+    if (clear_screen) {		/* clear screen before exit */
+	attr_clear (stdscr, LINES, COLS, screen_attr);
+	refresh ();
     }
     end_dialog();
 
@@ -173,21 +173,21 @@ int
 j_menu (const char *t, int ac, const char * const * av)
 {
     return dialog_menu (t, av[2], atoi (av[3]), atoi (av[4]),
-            atoi (av[5]), av[6], (ac - 6) / 2, av + 7);
+			atoi (av[5]), av[6], (ac - 6) / 2, av + 7);
 }
 
 int
 j_checklist (const char *t, int ac, const char * const * av)
 {
     return dialog_checklist (t, av[2], atoi (av[3]), atoi (av[4]),
-    atoi (av[5]), (ac - 6) / 3, av + 6, FLAG_CHECK);
+	atoi (av[5]), (ac - 6) / 3, av + 6, FLAG_CHECK);
 }
 
 int
 j_radiolist (const char *t, int ac, const char * const * av)
 {
     return dialog_checklist (t, av[2], atoi (av[3]), atoi (av[4]),
-    atoi (av[5]), (ac - 6) / 3, av + 6, FLAG_RADIO);
+	atoi (av[5]), (ac - 6) / 3, av + 6, FLAG_RADIO);
 }
 
 int

lxdialog/menubox.c

@@ -26,7 +26,7 @@
  *
  *    *)  A bugfix for the Page-Down problem
  *
- *    *)  Formerly when I used Page Down and Page Up, the cursor would be set
+ *    *)  Formerly when I used Page Down and Page Up, the cursor would be set 
  *        to the first position in the menu box.  Now lxdialog is a bit
  *        smarter and works more like other menu systems (just have a look at
  *        it).
@@ -80,7 +80,7 @@ print_item (WINDOW * win, const char *item, int choice, int selected, int hotkey
     {
         int i;
         for (i = 0; i < menu_width; i++)
-        waddch (win, ' ');
+	    waddch (win, ' ');
     }
 #else
     wclrtoeol(win);
@@ -88,12 +88,12 @@ print_item (WINDOW * win, const char *item, int choice, int selected, int hotkey
     wattrset (win, selected ? item_selected_attr : item_attr);
     mvwaddstr (win, choice, item_x, menu_item);
     if (hotkey) {
-        wattrset (win, selected ? tag_key_selected_attr : tag_key_attr);
-        mvwaddch(win, choice, item_x+j, menu_item[j]);
+    	wattrset (win, selected ? tag_key_selected_attr : tag_key_attr);
+    	mvwaddch(win, choice, item_x+j, menu_item[j]);
     }
     if (selected) {
-    wmove (win, choice, item_x+1);
-    wrefresh (win);
+	wmove (win, choice, item_x+1);
+	wrefresh (win);
     }
 }
 
@@ -102,7 +102,7 @@ print_item (WINDOW * win, const char *item, int choice, int selected, int hotkey
  */
 static void
 print_arrows (WINDOW * win, int item_no, int scroll,
-        int y, int x, int height)
+		int y, int x, int height)
 {
     int cur_y, cur_x;
 
@@ -111,32 +111,32 @@ print_arrows (WINDOW * win, int item_no, int scroll,
     wmove(win, y, x);
 
     if (scroll > 0) {
-    wattrset (win, uarrow_attr);
-    waddch (win, ACS_UARROW);
-    waddstr (win, "(-)");
+	wattrset (win, uarrow_attr);
+	waddch (win, ACS_UARROW);
+	waddstr (win, "(-)");
     }
     else {
-    wattrset (win, menubox_attr);
-    waddch (win, ACS_HLINE);
-    waddch (win, ACS_HLINE);
-    waddch (win, ACS_HLINE);
-    waddch (win, ACS_HLINE);
+	wattrset (win, menubox_attr);
+	waddch (win, ACS_HLINE);
+	waddch (win, ACS_HLINE);
+	waddch (win, ACS_HLINE);
+	waddch (win, ACS_HLINE);
     }
 
    y = y + height + 1;
    wmove(win, y, x);
 
    if ((height < item_no) && (scroll + height < item_no)) {
-    wattrset (win, darrow_attr);
-    waddch (win, ACS_DARROW);
-    waddstr (win, "(+)");
+	wattrset (win, darrow_attr);
+	waddch (win, ACS_DARROW);
+	waddstr (win, "(+)");
     }
     else {
-    wattrset (win, menubox_border_attr);
-    waddch (win, ACS_HLINE);
-    waddch (win, ACS_HLINE);
-    waddch (win, ACS_HLINE);
-    waddch (win, ACS_HLINE);
+	wattrset (win, menubox_border_attr);
+	waddch (win, ACS_HLINE);
+	waddch (win, ACS_HLINE);
+	waddch (win, ACS_HLINE);
+	waddch (win, ACS_HLINE);
    }
 
    wmove(win, cur_y, cur_x);
@@ -164,8 +164,8 @@ print_buttons (WINDOW *win, int height, int width, int selected)
  */
 int
 dialog_menu (const char *title, const char *prompt, int height, int width,
-        int menu_height, const char *current, int item_no,
-        const char * const * items)
+		int menu_height, const char *current, int item_no,
+		const char * const * items)
 
 {
     int i, j, x, y, box_x, box_y;
@@ -188,24 +188,24 @@ dialog_menu (const char *title, const char *prompt, int height, int width,
     wattrset (dialog, border_attr);
     mvwaddch (dialog, height - 3, 0, ACS_LTEE);
     for (i = 0; i < width - 2; i++)
-    waddch (dialog, ACS_HLINE);
+	waddch (dialog, ACS_HLINE);
     wattrset (dialog, dialog_attr);
     wbkgdset (dialog, dialog_attr & A_COLOR);
     waddch (dialog, ACS_RTEE);
 
     if (title != NULL && strlen(title) >= width-2 ) {
-    /* truncate long title -- mec */
-    char * title2 = malloc(width-2+1);
-    memcpy( title2, title, width-2 );
-    title2[width-2] = '\0';
-    title = title2;
+	/* truncate long title -- mec */
+	char * title2 = malloc(width-2+1);
+	memcpy( title2, title, width-2 );
+	title2[width-2] = '\0';
+	title = title2;
     }
 
     if (title != NULL) {
-    wattrset (dialog, title_attr);
-    mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' ');
-    waddstr (dialog, (char *)title);
-    waddch (dialog, ' ');
+	wattrset (dialog, title_attr);
+	mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' ');
+	waddstr (dialog, (char *)title);
+	waddch (dialog, ' ');
     }
 
     wattrset (dialog, dialog_attr);
@@ -217,85 +217,85 @@ dialog_menu (const char *title, const char *prompt, int height, int width,
 
     /* create new window for the menu */
     menu = subwin (dialog, menu_height, menu_width,
-        y + box_y + 1, x + box_x + 1);
+		y + box_y + 1, x + box_x + 1);
     keypad (menu, TRUE);
 
     /* draw a box around the menu items */
     draw_box (dialog, box_y, box_x, menu_height + 2, menu_width + 2,
-          menubox_border_attr, menubox_attr);
+	      menubox_border_attr, menubox_attr);
 
     /*
      * Find length of longest item in order to center menu.
-     * Set 'choice' to default item.
+     * Set 'choice' to default item. 
      */
     item_x = 0;
     for (i = 0; i < item_no; i++) {
-    item_x = MAX (item_x, MIN(menu_width, strlen (items[i * 2 + 1]) + 2));
-    if (strcmp(current, items[i*2]) == 0) choice = i;
+	item_x = MAX (item_x, MIN(menu_width, strlen (items[i * 2 + 1]) + 2));
+	if (strcmp(current, items[i*2]) == 0) choice = i;
     }
 
     item_x = (menu_width - item_x) / 2;
 
     /* get the scroll info from the temp file */
     if ( (f=fopen("lxdialog.scrltmp","r")) != NULL ) {
-    if ( (fscanf(f,"%d\n",&scroll) == 1) && (scroll <= choice) &&
-         (scroll+max_choice > choice) && (scroll >= 0) &&
-         (scroll+max_choice <= item_no) ) {
-        first_item = scroll;
-        choice = choice - scroll;
-        fclose(f);
-    } else {
-        scroll=0;
-        remove("lxdialog.scrltmp");
-        fclose(f);
-        f=NULL;
-    }
+	if ( (fscanf(f,"%d\n",&scroll) == 1) && (scroll <= choice) &&
+	     (scroll+max_choice > choice) && (scroll >= 0) &&
+	     (scroll+max_choice <= item_no) ) {
+	    first_item = scroll;
+	    choice = choice - scroll;
+	    fclose(f);
+	} else {
+	    scroll=0;
+	    remove("lxdialog.scrltmp");
+	    fclose(f);
+	    f=NULL;
+	}
     }
     if ( (choice >= max_choice) || (f==NULL && choice >= max_choice/2) ) {
-    if (choice >= item_no-max_choice/2)
-        scroll = first_item = item_no-max_choice;
-    else
-        scroll = first_item = choice - max_choice/2;
-    choice = choice - scroll;
+	if (choice >= item_no-max_choice/2)
+	    scroll = first_item = item_no-max_choice;
+	else
+	    scroll = first_item = choice - max_choice/2;
+	choice = choice - scroll;
     }
 
     /* Print the menu */
     for (i=0; i < max_choice; i++) {
-    print_item (menu, items[(first_item + i) * 2 + 1], i, i == choice,
+	print_item (menu, items[(first_item + i) * 2 + 1], i, i == choice,
                     (items[(first_item + i)*2][0] != ':'));
     }
 
     wnoutrefresh (menu);
 
     print_arrows(dialog, item_no, scroll,
-         box_y, box_x+item_x+1, menu_height);
+		 box_y, box_x+item_x+1, menu_height);
 
     print_buttons (dialog, height, width, 0);
     wmove (menu, choice, item_x+1);
     wrefresh (menu);
 
     while (key != ESC) {
-    key = wgetch(menu);
+	key = wgetch(menu);
 
-    if (key < 256 && isalpha(key)) key = tolower(key);
+	if (key < 256 && isalpha(key)) key = tolower(key);
 
-    if (strchr("ynm", key))
-        i = max_choice;
-    else {
+	if (strchr("ynm", key))
+		i = max_choice;
+	else {
         for (i = choice+1; i < max_choice; i++) {
-        j = first_alpha(items[(scroll+i)*2+1], "YyNnMm");
-        if (key == tolower(items[(scroll+i)*2+1][j]))
-                    break;
-    }
-    if (i == max_choice)
-               for (i = 0; i < max_choice; i++) {
-            j = first_alpha(items[(scroll+i)*2+1], "YyNnMm");
-            if (key == tolower(items[(scroll+i)*2+1][j]))
-                        break;
-        }
-    }
-
-    if (i < max_choice ||
+		j = first_alpha(items[(scroll+i)*2+1], "YyNnMm");
+		if (key == tolower(items[(scroll+i)*2+1][j]))
+                	break;
+	}
+	if (i == max_choice)
+       		for (i = 0; i < max_choice; i++) {
+			j = first_alpha(items[(scroll+i)*2+1], "YyNnMm");
+			if (key == tolower(items[(scroll+i)*2+1][j]))
+                		break;
+		}
+	}
+
+	if (i < max_choice || 
             key == KEY_UP || key == KEY_DOWN ||
             key == '-' || key == '+' ||
             key == KEY_PPAGE || key == KEY_NPAGE) {
@@ -303,9 +303,9 @@ dialog_menu (const char *title, const char *prompt, int height, int width,
             print_item (menu, items[(scroll+choice)*2+1], choice, FALSE,
                        (items[(scroll+choice)*2][0] != ':'));
 
-        if (key == KEY_UP || key == '-') {
+	    if (key == KEY_UP || key == '-') {
                 if (choice < 2 && scroll) {
-                /* Scroll menu down */
+	            /* Scroll menu down */
                     scrollok (menu, TRUE);
                     wscrl (menu, -1);
                     scrollok (menu, FALSE);
@@ -314,19 +314,19 @@ dialog_menu (const char *title, const char *prompt, int height, int width,
 
                     print_item (menu, items[scroll * 2 + 1], 0, FALSE,
                                (items[scroll*2][0] != ':'));
-        } else
-            choice = MAX(choice - 1, 0);
+		} else
+		    choice = MAX(choice - 1, 0);
 
-        } else if (key == KEY_DOWN || key == '+')  {
+	    } else if (key == KEY_DOWN || key == '+')  {
 
-        print_item (menu, items[(scroll+choice)*2+1], choice, FALSE,
+		print_item (menu, items[(scroll+choice)*2+1], choice, FALSE,
                                 (items[(scroll+choice)*2][0] != ':'));
 
                 if ((choice > max_choice-3) &&
                     (scroll + max_choice < item_no)
                    ) {
-            /* Scroll menu up */
-            scrollok (menu, TRUE);
+		    /* Scroll menu up */
+		    scrollok (menu, TRUE);
                     scroll (menu);
                     scrollok (menu, FALSE);
 
@@ -338,14 +338,14 @@ dialog_menu (const char *title, const char *prompt, int height, int width,
                 } else
                     choice = MIN(choice+1, max_choice-1);
 
-        } else if (key == KEY_PPAGE) {
-            scrollok (menu, TRUE);
+	    } else if (key == KEY_PPAGE) {
+	        scrollok (menu, TRUE);
                 for (i=0; (i < max_choice); i++) {
                     if (scroll > 0) {
-                    wscrl (menu, -1);
-                    scroll--;
-                    print_item (menu, items[scroll * 2 + 1], 0, FALSE,
-                    (items[scroll*2][0] != ':'));
+                	wscrl (menu, -1);
+                	scroll--;
+                	print_item (menu, items[scroll * 2 + 1], 0, FALSE,
+                	(items[scroll*2][0] != ':'));
                     } else {
                         if (choice > 0)
                             choice--;
@@ -356,17 +356,17 @@ dialog_menu (const char *title, const char *prompt, int height, int width,
             } else if (key == KEY_NPAGE) {
                 for (i=0; (i < max_choice); i++) {
                     if (scroll+max_choice < item_no) {
-            scrollok (menu, TRUE);
-            scroll(menu);
-            scrollok (menu, FALSE);
-                    scroll++;
-                    print_item (menu, items[(scroll+max_choice-1)*2+1],
-                        max_choice-1, FALSE,
-                        (items[(scroll+max_choice-1)*2][0] != ':'));
-            } else {
-            if (choice+1 < max_choice)
-                choice++;
-            }
+			scrollok (menu, TRUE);
+			scroll(menu);
+			scrollok (menu, FALSE);
+                	scroll++;
+                	print_item (menu, items[(scroll+max_choice-1)*2+1],
+			            max_choice-1, FALSE,
+			            (items[(scroll+max_choice-1)*2][0] != ':'));
+		    } else {
+			if (choice+1 < max_choice)
+			    choice++;
+		    }
                 }
 
             } else
@@ -381,30 +381,30 @@ dialog_menu (const char *title, const char *prompt, int height, int width,
             wnoutrefresh (dialog);
             wrefresh (menu);
 
-        continue;        /* wait for another key press */
+	    continue;		/* wait for another key press */
         }
 
-    switch (key) {
-    case KEY_LEFT:
-    case TAB:
-    case KEY_RIGHT:
-        button = ((key == KEY_LEFT ? --button : ++button) < 0)
-            ? 2 : (button > 2 ? 0 : button);
-
-        print_buttons(dialog, height, width, button);
-        wrefresh (menu);
-        break;
-    case ' ':
-    case 's':
-    case 'y':
-    case 'n':
-    case 'm':
-        /* save scroll info */
-        if ( (f=fopen("lxdialog.scrltmp","w")) != NULL ) {
-        fprintf(f,"%d\n",scroll);
-        fclose(f);
-        }
-        delwin (dialog);
+	switch (key) {
+	case KEY_LEFT:
+	case TAB:
+	case KEY_RIGHT:
+	    button = ((key == KEY_LEFT ? --button : ++button) < 0)
+			? 2 : (button > 2 ? 0 : button);
+
+	    print_buttons(dialog, height, width, button);
+	    wrefresh (menu);
+	    break;
+	case ' ':
+	case 's':
+	case 'y':
+	case 'n':
+	case 'm':
+	    /* save scroll info */
+	    if ( (f=fopen("lxdialog.scrltmp","w")) != NULL ) {
+		fprintf(f,"%d\n",scroll);
+		fclose(f);
+	    }
+	    delwin (dialog);
             fprintf(stderr, "%s\n", items[(scroll + choice) * 2]);
             switch (key) {
             case 's': return 3;
@@ -413,31 +413,31 @@ dialog_menu (const char *title, const char *prompt, int height, int width,
             case 'm': return 5;
             case ' ': return 6;
             }
-        return 0;
-    case 'h':
-    case '?':
-        button = 2;
-    case '\n':
-        delwin (dialog);
-        if (button == 2)
-                fprintf(stderr, "%s \"%s\"\n",
-            items[(scroll + choice) * 2],
-            items[(scroll + choice) * 2 + 1] +
-            first_alpha(items[(scroll + choice) * 2 + 1],""));
-        else
-                fprintf(stderr, "%s\n", items[(scroll + choice) * 2]);
-
-        remove("lxdialog.scrltmp");
-        return button;
-    case 'e':
-    case 'x':
-        key = ESC;
-    case ESC:
-        break;
-    }
+	    return 0;
+	case 'h':
+	case '?':
+	    button = 2;
+	case '\n':
+	    delwin (dialog);
+	    if (button == 2) 
+            	fprintf(stderr, "%s \"%s\"\n", 
+			items[(scroll + choice) * 2],
+			items[(scroll + choice) * 2 + 1] +
+			first_alpha(items[(scroll + choice) * 2 + 1],""));
+	    else
+            	fprintf(stderr, "%s\n", items[(scroll + choice) * 2]);
+
+	    remove("lxdialog.scrltmp");
+	    return button;
+	case 'e':
+	case 'x':
+	    key = ESC;
+	case ESC:
+	    break;
+	}
     }
 
     delwin (dialog);
     remove("lxdialog.scrltmp");
-    return -1;            /* ESC pressed */
+    return -1;			/* ESC pressed */
 }

lxdialog/msgbox.c

@@ -27,7 +27,7 @@
  */
 int
 dialog_msgbox (const char *title, const char *prompt, int height, int width,
-        int pause)
+		int pause)
 {
     int i, x, y, key = 0;
     WINDOW *dialog;
@@ -44,40 +44,40 @@ dialog_msgbox (const char *title, const char *prompt, int height, int width,
     draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr);
 
     if (title != NULL && strlen(title) >= width-2 ) {
-    /* truncate long title -- mec */
-    char * title2 = malloc(width-2+1);
-    memcpy( title2, title, width-2 );
-    title2[width-2] = '\0';
-    title = title2;
+	/* truncate long title -- mec */
+	char * title2 = malloc(width-2+1);
+	memcpy( title2, title, width-2 );
+	title2[width-2] = '\0';
+	title = title2;
     }
 
     if (title != NULL) {
-    wattrset (dialog, title_attr);
-    mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' ');
-    waddstr (dialog, (char *)title);
-    waddch (dialog, ' ');
+	wattrset (dialog, title_attr);
+	mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' ');
+	waddstr (dialog, (char *)title);
+	waddch (dialog, ' ');
     }
     wattrset (dialog, dialog_attr);
     print_autowrap (dialog, prompt, width - 2, 1, 2);
 
     if (pause) {
-    wattrset (dialog, border_attr);
-    mvwaddch (dialog, height - 3, 0, ACS_LTEE);
-    for (i = 0; i < width - 2; i++)
-        waddch (dialog, ACS_HLINE);
-    wattrset (dialog, dialog_attr);
-    waddch (dialog, ACS_RTEE);
+	wattrset (dialog, border_attr);
+	mvwaddch (dialog, height - 3, 0, ACS_LTEE);
+	for (i = 0; i < width - 2; i++)
+	    waddch (dialog, ACS_HLINE);
+	wattrset (dialog, dialog_attr);
+	waddch (dialog, ACS_RTEE);
 
-    print_button (dialog, "  Ok  ",
-              height - 2, width / 2 - 4, TRUE);
+	print_button (dialog, "  Ok  ",
+		      height - 2, width / 2 - 4, TRUE);
 
-    wrefresh (dialog);
-    while (key != ESC && key != '\n' && key != ' ' &&
+	wrefresh (dialog);
+	while (key != ESC && key != '\n' && key != ' ' &&
                key != 'O' && key != 'o' && key != 'X' && key != 'x')
-        key = wgetch (dialog);
+	    key = wgetch (dialog);
     } else {
-    key = '\n';
-    wrefresh (dialog);
+	key = '\n';
+	wrefresh (dialog);
     }
 
     delwin (dialog);

lxdialog/textbox.c

@@ -42,41 +42,41 @@ dialog_textbox (const char *title, const char *file, int height, int width)
     char search_term[MAX_LEN + 1];
     WINDOW *dialog, *text;
 
-    search_term[0] = '\0';    /* no search term entered yet */
+    search_term[0] = '\0';	/* no search term entered yet */
 
     /* Open input file for reading */
     if ((fd = open (file, O_RDONLY)) == -1) {
-    endwin ();
-    fprintf (stderr,
-         "\nCan't open input file in dialog_textbox().\n");
-    exit (-1);
+	endwin ();
+	fprintf (stderr,
+		 "\nCan't open input file in dialog_textbox().\n");
+	exit (-1);
     }
     /* Get file size. Actually, 'file_size' is the real file size - 1,
        since it's only the last byte offset from the beginning */
     if ((file_size = lseek (fd, 0, SEEK_END)) == -1) {
-    endwin ();
-    fprintf (stderr, "\nError getting file size in dialog_textbox().\n");
-    exit (-1);
+	endwin ();
+	fprintf (stderr, "\nError getting file size in dialog_textbox().\n");
+	exit (-1);
     }
     /* Restore file pointer to beginning of file after getting file size */
     if (lseek (fd, 0, SEEK_SET) == -1) {
-    endwin ();
-    fprintf (stderr, "\nError moving file pointer in dialog_textbox().\n");
-    exit (-1);
+	endwin ();
+	fprintf (stderr, "\nError moving file pointer in dialog_textbox().\n");
+	exit (-1);
     }
     /* Allocate space for read buffer */
     if ((buf = malloc (BUF_SIZE + 1)) == NULL) {
-    endwin ();
-    fprintf (stderr, "\nCan't allocate memory in dialog_textbox().\n");
-    exit (-1);
+	endwin ();
+	fprintf (stderr, "\nCan't allocate memory in dialog_textbox().\n");
+	exit (-1);
     }
     if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
-    endwin ();
-    fprintf (stderr, "\nError reading file in dialog_textbox().\n");
-    exit (-1);
+	endwin ();
+	fprintf (stderr, "\nError reading file in dialog_textbox().\n");
+	exit (-1);
     }
-    buf[bytes_read] = '\0';    /* mark end of valid data */
-    page = buf;            /* page is pointer to start of page to be displayed */
+    buf[bytes_read] = '\0';	/* mark end of valid data */
+    page = buf;			/* page is pointer to start of page to be displayed */
 
     /* center dialog box on screen */
     x = (COLS - width) / 2;
@@ -101,223 +101,223 @@ dialog_textbox (const char *title, const char *file, int height, int width)
     wattrset (dialog, border_attr);
     mvwaddch (dialog, height-3, 0, ACS_LTEE);
     for (i = 0; i < width - 2; i++)
-    waddch (dialog, ACS_HLINE);
+	waddch (dialog, ACS_HLINE);
     wattrset (dialog, dialog_attr);
     wbkgdset (dialog, dialog_attr & A_COLOR);
     waddch (dialog, ACS_RTEE);
 
     if (title != NULL && strlen(title) >= width-2 ) {
-    /* truncate long title -- mec */
-    char * title2 = malloc(width-2+1);
-    memcpy( title2, title, width-2 );
-    title2[width-2] = '\0';
-    title = title2;
+	/* truncate long title -- mec */
+	char * title2 = malloc(width-2+1);
+	memcpy( title2, title, width-2 );
+	title2[width-2] = '\0';
+	title = title2;
     }
 
     if (title != NULL) {
-    wattrset (dialog, title_attr);
-    mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' ');
-    waddstr (dialog, (char *)title);
-    waddch (dialog, ' ');
+	wattrset (dialog, title_attr);
+	mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' ');
+	waddstr (dialog, (char *)title);
+	waddch (dialog, ' ');
     }
     print_button (dialog, " Exit ", height - 2, width / 2 - 4, TRUE);
     wnoutrefresh (dialog);
-    getyx (dialog, cur_y, cur_x);    /* Save cursor position */
+    getyx (dialog, cur_y, cur_x);	/* Save cursor position */
 
     /* Print first page of text */
     attr_clear (text, height - 4, width - 2, dialog_attr);
     print_page (text, height - 4, width - 2);
     print_position (dialog, height, width);
-    wmove (dialog, cur_y, cur_x);    /* Restore cursor position */
+    wmove (dialog, cur_y, cur_x);	/* Restore cursor position */
     wrefresh (dialog);
 
     while ((key != ESC) && (key != '\n')) {
-    key = wgetch (dialog);
-    switch (key) {
-    case 'E':        /* Exit */
-    case 'e':
-    case 'X':
-    case 'x':
-        delwin (dialog);
-        free (buf);
-        close (fd);
-        return 0;
-    case 'g':        /* First page */
-    case KEY_HOME:
-        if (!begin_reached) {
-        begin_reached = 1;
-        /* First page not in buffer? */
-        if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) {
-            endwin ();
-            fprintf (stderr,
-              "\nError moving file pointer in dialog_textbox().\n");
-            exit (-1);
-        }
-        if (fpos > bytes_read) {    /* Yes, we have to read it in */
-            if (lseek (fd, 0, SEEK_SET) == -1) {
-            endwin ();
-            fprintf (stderr, "\nError moving file pointer in "
-                 "dialog_textbox().\n");
-            exit (-1);
-            }
-            if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
-            endwin ();
-            fprintf (stderr,
-                 "\nError reading file in dialog_textbox().\n");
-            exit (-1);
-            }
-            buf[bytes_read] = '\0';
-        }
-        page = buf;
-        print_page (text, height - 4, width - 2);
-        print_position (dialog, height, width);
-        wmove (dialog, cur_y, cur_x);    /* Restore cursor position */
-        wrefresh (dialog);
-        }
-        break;
-    case 'G':        /* Last page */
-    case KEY_END:
-
-        end_reached = 1;
-        /* Last page not in buffer? */
-        if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) {
-        endwin ();
-        fprintf (stderr,
-              "\nError moving file pointer in dialog_textbox().\n");
-        exit (-1);
-        }
-        if (fpos < file_size) {    /* Yes, we have to read it in */
-        if (lseek (fd, -BUF_SIZE, SEEK_END) == -1) {
-            endwin ();
-            fprintf (stderr,
-              "\nError moving file pointer in dialog_textbox().\n");
-            exit (-1);
-        }
-        if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
-            endwin ();
-            fprintf (stderr,
-                 "\nError reading file in dialog_textbox().\n");
-            exit (-1);
-        }
-        buf[bytes_read] = '\0';
-        }
-        page = buf + bytes_read;
-        back_lines (height - 4);
-        print_page (text, height - 4, width - 2);
-        print_position (dialog, height, width);
-        wmove (dialog, cur_y, cur_x);    /* Restore cursor position */
-        wrefresh (dialog);
-        break;
-    case 'K':        /* Previous line */
-    case 'k':
-    case KEY_UP:
-        if (!begin_reached) {
-        back_lines (page_length + 1);
-
-        /* We don't call print_page() here but use scrolling to ensure
-           faster screen update. However, 'end_reached' and
-           'page_length' should still be updated, and 'page' should
-           point to start of next page. This is done by calling
-           get_line() in the following 'for' loop. */
-        scrollok (text, TRUE);
-        wscrl (text, -1);    /* Scroll text region down one line */
-        scrollok (text, FALSE);
-        page_length = 0;
-        passed_end = 0;
-        for (i = 0; i < height - 4; i++) {
-            if (!i) {
-            /* print first line of page */
-            print_line (text, 0, width - 2);
-            wnoutrefresh (text);
-            } else
-            /* Called to update 'end_reached' and 'page' */
-            get_line ();
-            if (!passed_end)
-            page_length++;
-            if (end_reached && !passed_end)
-            passed_end = 1;
-        }
-
-        print_position (dialog, height, width);
-        wmove (dialog, cur_y, cur_x);    /* Restore cursor position */
-        wrefresh (dialog);
-        }
-        break;
-    case 'B':        /* Previous page */
-    case 'b':
-    case KEY_PPAGE:
-        if (begin_reached)
-        break;
-        back_lines (page_length + height - 4);
-        print_page (text, height - 4, width - 2);
-        print_position (dialog, height, width);
-        wmove (dialog, cur_y, cur_x);
-        wrefresh (dialog);
-        break;
-    case 'J':        /* Next line */
-    case 'j':
-    case KEY_DOWN:
-        if (!end_reached) {
-        begin_reached = 0;
-        scrollok (text, TRUE);
-        scroll (text);    /* Scroll text region up one line */
-        scrollok (text, FALSE);
-        print_line (text, height - 5, width - 2);
-        wnoutrefresh (text);
-        print_position (dialog, height, width);
-        wmove (dialog, cur_y, cur_x);    /* Restore cursor position */
-        wrefresh (dialog);
-        }
-        break;
-    case KEY_NPAGE:        /* Next page */
-    case ' ':
-        if (end_reached)
-        break;
-
-        begin_reached = 0;
-        print_page (text, height - 4, width - 2);
-        print_position (dialog, height, width);
-        wmove (dialog, cur_y, cur_x);
-        wrefresh (dialog);
-        break;
-    case '0':        /* Beginning of line */
-    case 'H':        /* Scroll left */
-    case 'h':
-    case KEY_LEFT:
-        if (hscroll <= 0)
-        break;
-
-        if (key == '0')
-        hscroll = 0;
-        else
-        hscroll--;
-        /* Reprint current page to scroll horizontally */
-        back_lines (page_length);
-        print_page (text, height - 4, width - 2);
-        wmove (dialog, cur_y, cur_x);
-        wrefresh (dialog);
-        break;
-    case 'L':        /* Scroll right */
-    case 'l':
-    case KEY_RIGHT:
-        if (hscroll >= MAX_LEN)
-        break;
-        hscroll++;
-        /* Reprint current page to scroll horizontally */
-        back_lines (page_length);
-        print_page (text, height - 4, width - 2);
-        wmove (dialog, cur_y, cur_x);
-        wrefresh (dialog);
-        break;
-    case ESC:
-        break;
-    }
+	key = wgetch (dialog);
+	switch (key) {
+	case 'E':		/* Exit */
+	case 'e':
+	case 'X':
+	case 'x':
+	    delwin (dialog);
+	    free (buf);
+	    close (fd);
+	    return 0;
+	case 'g':		/* First page */
+	case KEY_HOME:
+	    if (!begin_reached) {
+		begin_reached = 1;
+		/* First page not in buffer? */
+		if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) {
+		    endwin ();
+		    fprintf (stderr,
+		      "\nError moving file pointer in dialog_textbox().\n");
+		    exit (-1);
+		}
+		if (fpos > bytes_read) {	/* Yes, we have to read it in */
+		    if (lseek (fd, 0, SEEK_SET) == -1) {
+			endwin ();
+			fprintf (stderr, "\nError moving file pointer in "
+				 "dialog_textbox().\n");
+			exit (-1);
+		    }
+		    if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
+			endwin ();
+			fprintf (stderr,
+			     "\nError reading file in dialog_textbox().\n");
+			exit (-1);
+		    }
+		    buf[bytes_read] = '\0';
+		}
+		page = buf;
+		print_page (text, height - 4, width - 2);
+		print_position (dialog, height, width);
+		wmove (dialog, cur_y, cur_x);	/* Restore cursor position */
+		wrefresh (dialog);
+	    }
+	    break;
+	case 'G':		/* Last page */
+	case KEY_END:
+
+	    end_reached = 1;
+	    /* Last page not in buffer? */
+	    if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) {
+		endwin ();
+		fprintf (stderr,
+		      "\nError moving file pointer in dialog_textbox().\n");
+		exit (-1);
+	    }
+	    if (fpos < file_size) {	/* Yes, we have to read it in */
+		if (lseek (fd, -BUF_SIZE, SEEK_END) == -1) {
+		    endwin ();
+		    fprintf (stderr,
+		      "\nError moving file pointer in dialog_textbox().\n");
+		    exit (-1);
+		}
+		if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
+		    endwin ();
+		    fprintf (stderr,
+			     "\nError reading file in dialog_textbox().\n");
+		    exit (-1);
+		}
+		buf[bytes_read] = '\0';
+	    }
+	    page = buf + bytes_read;
+	    back_lines (height - 4);
+	    print_page (text, height - 4, width - 2);
+	    print_position (dialog, height, width);
+	    wmove (dialog, cur_y, cur_x);	/* Restore cursor position */
+	    wrefresh (dialog);
+	    break;
+	case 'K':		/* Previous line */
+	case 'k':
+	case KEY_UP:
+	    if (!begin_reached) {
+		back_lines (page_length + 1);
+
+		/* We don't call print_page() here but use scrolling to ensure
+		   faster screen update. However, 'end_reached' and
+		   'page_length' should still be updated, and 'page' should
+		   point to start of next page. This is done by calling
+		   get_line() in the following 'for' loop. */
+		scrollok (text, TRUE);
+		wscrl (text, -1);	/* Scroll text region down one line */
+		scrollok (text, FALSE);
+		page_length = 0;
+		passed_end = 0;
+		for (i = 0; i < height - 4; i++) {
+		    if (!i) {
+			/* print first line of page */
+			print_line (text, 0, width - 2);
+			wnoutrefresh (text);
+		    } else
+			/* Called to update 'end_reached' and 'page' */
+			get_line ();
+		    if (!passed_end)
+			page_length++;
+		    if (end_reached && !passed_end)
+			passed_end = 1;
+		}
+
+		print_position (dialog, height, width);
+		wmove (dialog, cur_y, cur_x);	/* Restore cursor position */
+		wrefresh (dialog);
+	    }
+	    break;
+	case 'B':		/* Previous page */
+	case 'b':
+	case KEY_PPAGE:
+	    if (begin_reached)
+		break;
+	    back_lines (page_length + height - 4);
+	    print_page (text, height - 4, width - 2);
+	    print_position (dialog, height, width);
+	    wmove (dialog, cur_y, cur_x);
+	    wrefresh (dialog);
+	    break;
+	case 'J':		/* Next line */
+	case 'j':
+	case KEY_DOWN:
+	    if (!end_reached) {
+		begin_reached = 0;
+		scrollok (text, TRUE);
+		scroll (text);	/* Scroll text region up one line */
+		scrollok (text, FALSE);
+		print_line (text, height - 5, width - 2);
+		wnoutrefresh (text);
+		print_position (dialog, height, width);
+		wmove (dialog, cur_y, cur_x);	/* Restore cursor position */
+		wrefresh (dialog);
+	    }
+	    break;
+	case KEY_NPAGE:		/* Next page */
+	case ' ':
+	    if (end_reached)
+		break;
+
+	    begin_reached = 0;
+	    print_page (text, height - 4, width - 2);
+	    print_position (dialog, height, width);
+	    wmove (dialog, cur_y, cur_x);
+	    wrefresh (dialog);
+	    break;
+	case '0':		/* Beginning of line */
+	case 'H':		/* Scroll left */
+	case 'h':
+	case KEY_LEFT:
+	    if (hscroll <= 0)
+		break;
+
+	    if (key == '0')
+		hscroll = 0;
+	    else
+		hscroll--;
+	    /* Reprint current page to scroll horizontally */
+	    back_lines (page_length);
+	    print_page (text, height - 4, width - 2);
+	    wmove (dialog, cur_y, cur_x);
+	    wrefresh (dialog);
+	    break;
+	case 'L':		/* Scroll right */
+	case 'l':
+	case KEY_RIGHT:
+	    if (hscroll >= MAX_LEN)
+		break;
+	    hscroll++;
+	    /* Reprint current page to scroll horizontally */
+	    back_lines (page_length);
+	    print_page (text, height - 4, width - 2);
+	    wmove (dialog, cur_y, cur_x);
+	    wrefresh (dialog);
+	    break;
+	case ESC:
+	    break;
+	}
     }
 
     delwin (dialog);
     free (buf);
     close (fd);
-    return -1;            /* ESC pressed */
+    return -1;			/* ESC pressed */
 }
 
 /*
@@ -335,102 +335,102 @@ back_lines (int n)
        The code inside 'if' basically does a '--page' to move one
        character backward so as to skip '\n' of the previous line */
     if (!end_reached) {
-    /* Either beginning of buffer or beginning of file reached? */
-    if (page == buf) {
-        if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) {
-        endwin ();
-        fprintf (stderr, "\nError moving file pointer in "
-             "back_lines().\n");
-        exit (-1);
-        }
-        if (fpos > bytes_read) {    /* Not beginning of file yet */
-        /* We've reached beginning of buffer, but not beginning of
-           file yet, so read previous part of file into buffer.
-           Note that we only move backward for BUF_SIZE/2 bytes,
-           but not BUF_SIZE bytes to avoid re-reading again in
-           print_page() later */
-        /* Really possible to move backward BUF_SIZE/2 bytes? */
-        if (fpos < BUF_SIZE / 2 + bytes_read) {
-            /* No, move less then */
-            if (lseek (fd, 0, SEEK_SET) == -1) {
-            endwin ();
-            fprintf (stderr, "\nError moving file pointer in "
-                 "back_lines().\n");
-            exit (-1);
-            }
-            page = buf + fpos - bytes_read;
-        } else {    /* Move backward BUF_SIZE/2 bytes */
-            if (lseek (fd, -(BUF_SIZE / 2 + bytes_read), SEEK_CUR)
-            == -1) {
-            endwin ();
-            fprintf (stderr, "\nError moving file pointer "
-                 "in back_lines().\n");
-            exit (-1);
-            }
-            page = buf + BUF_SIZE / 2;
-        }
-        if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
-            endwin ();
-            fprintf (stderr, "\nError reading file in back_lines().\n");
-            exit (-1);
-        }
-        buf[bytes_read] = '\0';
-        } else {        /* Beginning of file reached */
-        begin_reached = 1;
-        return;
-        }
-    }
-    if (*(--page) != '\n') {    /* '--page' here */
-        /* Something's wrong... */
-        endwin ();
-        fprintf (stderr, "\nInternal error in back_lines().\n");
-        exit (-1);
-    }
+	/* Either beginning of buffer or beginning of file reached? */
+	if (page == buf) {
+	    if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) {
+		endwin ();
+		fprintf (stderr, "\nError moving file pointer in "
+			 "back_lines().\n");
+		exit (-1);
+	    }
+	    if (fpos > bytes_read) {	/* Not beginning of file yet */
+		/* We've reached beginning of buffer, but not beginning of
+		   file yet, so read previous part of file into buffer.
+		   Note that we only move backward for BUF_SIZE/2 bytes,
+		   but not BUF_SIZE bytes to avoid re-reading again in
+		   print_page() later */
+		/* Really possible to move backward BUF_SIZE/2 bytes? */
+		if (fpos < BUF_SIZE / 2 + bytes_read) {
+		    /* No, move less then */
+		    if (lseek (fd, 0, SEEK_SET) == -1) {
+			endwin ();
+			fprintf (stderr, "\nError moving file pointer in "
+				 "back_lines().\n");
+			exit (-1);
+		    }
+		    page = buf + fpos - bytes_read;
+		} else {	/* Move backward BUF_SIZE/2 bytes */
+		    if (lseek (fd, -(BUF_SIZE / 2 + bytes_read), SEEK_CUR)
+			== -1) {
+			endwin ();
+			fprintf (stderr, "\nError moving file pointer "
+				 "in back_lines().\n");
+			exit (-1);
+		    }
+		    page = buf + BUF_SIZE / 2;
+		}
+		if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
+		    endwin ();
+		    fprintf (stderr, "\nError reading file in back_lines().\n");
+		    exit (-1);
+		}
+		buf[bytes_read] = '\0';
+	    } else {		/* Beginning of file reached */
+		begin_reached = 1;
+		return;
+	    }
+	}
+	if (*(--page) != '\n') {	/* '--page' here */
+	    /* Something's wrong... */
+	    endwin ();
+	    fprintf (stderr, "\nInternal error in back_lines().\n");
+	    exit (-1);
+	}
     }
     /* Go back 'n' lines */
     for (i = 0; i < n; i++)
-    do {
-        if (page == buf) {
-        if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) {
-            endwin ();
-            fprintf (stderr,
-              "\nError moving file pointer in back_lines().\n");
-            exit (-1);
-        }
-        if (fpos > bytes_read) {
-            /* Really possible to move backward BUF_SIZE/2 bytes? */
-            if (fpos < BUF_SIZE / 2 + bytes_read) {
-            /* No, move less then */
-            if (lseek (fd, 0, SEEK_SET) == -1) {
-                endwin ();
-                fprintf (stderr, "\nError moving file pointer "
-                     "in back_lines().\n");
-                exit (-1);
-            }
-            page = buf + fpos - bytes_read;
-            } else {    /* Move backward BUF_SIZE/2 bytes */
-            if (lseek (fd, -(BUF_SIZE / 2 + bytes_read),
-                   SEEK_CUR) == -1) {
-                endwin ();
-                fprintf (stderr, "\nError moving file pointer"
-                     " in back_lines().\n");
-                exit (-1);
-            }
-            page = buf + BUF_SIZE / 2;
-            }
-            if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
-            endwin ();
-            fprintf (stderr, "\nError reading file in "
-                 "back_lines().\n");
-            exit (-1);
-            }
-            buf[bytes_read] = '\0';
-        } else {    /* Beginning of file reached */
-            begin_reached = 1;
-            return;
-        }
-        }
-    } while (*(--page) != '\n');
+	do {
+	    if (page == buf) {
+		if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) {
+		    endwin ();
+		    fprintf (stderr,
+			  "\nError moving file pointer in back_lines().\n");
+		    exit (-1);
+		}
+		if (fpos > bytes_read) {
+		    /* Really possible to move backward BUF_SIZE/2 bytes? */
+		    if (fpos < BUF_SIZE / 2 + bytes_read) {
+			/* No, move less then */
+			if (lseek (fd, 0, SEEK_SET) == -1) {
+			    endwin ();
+			    fprintf (stderr, "\nError moving file pointer "
+				     "in back_lines().\n");
+			    exit (-1);
+			}
+			page = buf + fpos - bytes_read;
+		    } else {	/* Move backward BUF_SIZE/2 bytes */
+			if (lseek (fd, -(BUF_SIZE / 2 + bytes_read),
+				   SEEK_CUR) == -1) {
+			    endwin ();
+			    fprintf (stderr, "\nError moving file pointer"
+				     " in back_lines().\n");
+			    exit (-1);
+			}
+			page = buf + BUF_SIZE / 2;
+		    }
+		    if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
+			endwin ();
+			fprintf (stderr, "\nError reading file in "
+				 "back_lines().\n");
+			exit (-1);
+		    }
+		    buf[bytes_read] = '\0';
+		} else {	/* Beginning of file reached */
+		    begin_reached = 1;
+		    return;
+		}
+	    }
+	} while (*(--page) != '\n');
     page++;
 }
 
@@ -444,11 +444,11 @@ print_page (WINDOW * win, int height, int width)
 
     page_length = 0;
     for (i = 0; i < height; i++) {
-    print_line (win, i, width);
-    if (!passed_end)
-        page_length++;
-    if (end_reached && !passed_end)
-        passed_end = 1;
+	print_line (win, i, width);
+	if (!passed_end)
+	    page_length++;
+	if (end_reached && !passed_end)
+	    passed_end = 1;
     }
     wnoutrefresh (win);
 }
@@ -463,8 +463,8 @@ print_line (WINDOW * win, int row, int width)
     char *line;
 
     line = get_line ();
-    line += MIN (strlen (line), hscroll);    /* Scroll horizontally */
-    wmove (win, row, 0);    /* move cursor to correct line */
+    line += MIN (strlen (line), hscroll);	/* Scroll horizontally */
+    wmove (win, row, 0);	/* move cursor to correct line */
     waddch (win, ' ');
     waddnstr (win, line, MIN (strlen (line), width - 2));
 
@@ -474,7 +474,7 @@ print_line (WINDOW * win, int row, int width)
     {
         int i;
         for (i = 0; i < width - x; i++)
-        waddch (win, ' ');
+	    waddch (win, ' ');
     }
 #else
     wclrtoeol(win);
@@ -494,42 +494,42 @@ get_line (void)
 
     end_reached = 0;
     while (*page != '\n') {
-    if (*page == '\0') {
-        /* Either end of file or end of buffer reached */
-        if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) {
-        endwin ();
-        fprintf (stderr, "\nError moving file pointer in "
-             "get_line().\n");
-        exit (-1);
-        }
-        if (fpos < file_size) {    /* Not end of file yet */
-        /* We've reached end of buffer, but not end of file yet,
-           so read next part of file into buffer */
-        if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
-            endwin ();
-            fprintf (stderr, "\nError reading file in get_line().\n");
-            exit (-1);
-        }
-        buf[bytes_read] = '\0';
-        page = buf;
-        } else {
-        if (!end_reached)
-            end_reached = 1;
-        break;
-        }
-    } else if (i < MAX_LEN)
-        line[i++] = *(page++);
-    else {
-        /* Truncate lines longer than MAX_LEN characters */
-        if (i == MAX_LEN)
-        line[i++] = '\0';
-        page++;
-    }
+	if (*page == '\0') {
+	    /* Either end of file or end of buffer reached */
+	    if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) {
+		endwin ();
+		fprintf (stderr, "\nError moving file pointer in "
+			 "get_line().\n");
+		exit (-1);
+	    }
+	    if (fpos < file_size) {	/* Not end of file yet */
+		/* We've reached end of buffer, but not end of file yet,
+		   so read next part of file into buffer */
+		if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) {
+		    endwin ();
+		    fprintf (stderr, "\nError reading file in get_line().\n");
+		    exit (-1);
+		}
+		buf[bytes_read] = '\0';
+		page = buf;
+	    } else {
+		if (!end_reached)
+		    end_reached = 1;
+		break;
+	    }
+	} else if (i < MAX_LEN)
+	    line[i++] = *(page++);
+	else {
+	    /* Truncate lines longer than MAX_LEN characters */
+	    if (i == MAX_LEN)
+		line[i++] = '\0';
+	    page++;
+	}
     }
     if (i <= MAX_LEN)
-    line[i] = '\0';
+	line[i] = '\0';
     if (!end_reached)
-    page++;            /* move pass '\n' */
+	page++;			/* move pass '\n' */
 
     return line;
 }
@@ -543,14 +543,14 @@ print_position (WINDOW * win, int height, int width)
     int fpos, percent;
 
     if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) {
-    endwin ();
-    fprintf (stderr, "\nError moving file pointer in print_position().\n");
-    exit (-1);
+	endwin ();
+	fprintf (stderr, "\nError moving file pointer in print_position().\n");
+	exit (-1);
     }
     wattrset (win, position_indicator_attr);
     wbkgdset (win, position_indicator_attr & A_COLOR);
     percent = !file_size ?
-    100 : ((fpos - bytes_read + page - buf) * 100) / file_size;
+	100 : ((fpos - bytes_read + page - buf) * 100) / file_size;
     wmove (win, height - 3, width - 9);
     wprintw (win, "(%3d%%)", percent);
 }

lxdialog/util.c

@@ -29,40 +29,40 @@ const char *backtitle = NULL;
 
 const char *dialog_result;
 
-/*
+/* 
  * Attribute values, default is for mono display
  */
 chtype attributes[] =
 {
-    A_NORMAL,            /* screen_attr */
-    A_NORMAL,            /* shadow_attr */
-    A_NORMAL,            /* dialog_attr */
-    A_BOLD,            /* title_attr */
-    A_NORMAL,            /* border_attr */
-    A_REVERSE,            /* button_active_attr */
-    A_DIM,            /* button_inactive_attr */
-    A_REVERSE,            /* button_key_active_attr */
-    A_BOLD,            /* button_key_inactive_attr */
-    A_REVERSE,            /* button_label_active_attr */
-    A_NORMAL,            /* button_label_inactive_attr */
-    A_NORMAL,            /* inputbox_attr */
-    A_NORMAL,            /* inputbox_border_attr */
-    A_NORMAL,            /* searchbox_attr */
-    A_BOLD,            /* searchbox_title_attr */
-    A_NORMAL,            /* searchbox_border_attr */
-    A_BOLD,            /* position_indicator_attr */
-    A_NORMAL,            /* menubox_attr */
-    A_NORMAL,            /* menubox_border_attr */
-    A_NORMAL,            /* item_attr */
-    A_REVERSE,            /* item_selected_attr */
-    A_BOLD,            /* tag_attr */
-    A_REVERSE,            /* tag_selected_attr */
-    A_BOLD,            /* tag_key_attr */
-    A_REVERSE,            /* tag_key_selected_attr */
-    A_BOLD,            /* check_attr */
-    A_REVERSE,            /* check_selected_attr */
-    A_BOLD,            /* uarrow_attr */
-    A_BOLD            /* darrow_attr */
+    A_NORMAL,			/* screen_attr */
+    A_NORMAL,			/* shadow_attr */
+    A_NORMAL,			/* dialog_attr */
+    A_BOLD,			/* title_attr */
+    A_NORMAL,			/* border_attr */
+    A_REVERSE,			/* button_active_attr */
+    A_DIM,			/* button_inactive_attr */
+    A_REVERSE,			/* button_key_active_attr */
+    A_BOLD,			/* button_key_inactive_attr */
+    A_REVERSE,			/* button_label_active_attr */
+    A_NORMAL,			/* button_label_inactive_attr */
+    A_NORMAL,			/* inputbox_attr */
+    A_NORMAL,			/* inputbox_border_attr */
+    A_NORMAL,			/* searchbox_attr */
+    A_BOLD,			/* searchbox_title_attr */
+    A_NORMAL,			/* searchbox_border_attr */
+    A_BOLD,			/* position_indicator_attr */
+    A_NORMAL,			/* menubox_attr */
+    A_NORMAL,			/* menubox_border_attr */
+    A_NORMAL,			/* item_attr */
+    A_REVERSE,			/* item_selected_attr */
+    A_BOLD,			/* tag_attr */
+    A_REVERSE,			/* tag_selected_attr */
+    A_BOLD,			/* tag_key_attr */
+    A_REVERSE,			/* tag_key_selected_attr */
+    A_BOLD,			/* check_attr */
+    A_REVERSE,			/* check_selected_attr */
+    A_BOLD,			/* uarrow_attr */
+    A_BOLD			/* darrow_attr */
 };
 
 
@@ -103,7 +103,7 @@ int color_table[][3] =
     {CHECK_SELECTED_FG, CHECK_SELECTED_BG, CHECK_SELECTED_HL},
     {UARROW_FG, UARROW_BG, UARROW_HL},
     {DARROW_FG, DARROW_BG, DARROW_HL},
-};                /* color_table */
+};				/* color_table */
 
 /*
  * Set window to attribute 'attr'
@@ -115,9 +115,9 @@ attr_clear (WINDOW * win, int height, int width, chtype attr)
 
     wattrset (win, attr);
     for (i = 0; i < height; i++) {
-    wmove (win, i, 0);
-    for (j = 0; j < width; j++)
-        waddch (win, ' ');
+	wmove (win, i, 0);
+	for (j = 0; j < width; j++)
+	    waddch (win, ' ');
     }
     touchwin (win);
 }
@@ -144,14 +144,14 @@ void dialog_clear (void)
 void
 init_dialog (void)
 {
-    initscr ();            /* Init curses */
+    initscr ();			/* Init curses */
     keypad (stdscr, TRUE);
     cbreak ();
     noecho ();
 
 
-    if (use_colors)    /* Set up colors */
-    color_setup ();
+    if (use_colors)	/* Set up colors */
+	color_setup ();
 
 
     dialog_clear ();
@@ -165,16 +165,16 @@ color_setup (void)
 {
     int i;
 
-    if (has_colors ()) {    /* Terminal supports color? */
-    start_color ();
+    if (has_colors ()) {	/* Terminal supports color? */
+	start_color ();
 
-    /* Initialize color pairs */
-    for (i = 0; i < ATTRIBUTE_COUNT; i++)
-        init_pair (i + 1, color_table[i][0], color_table[i][1]);
+	/* Initialize color pairs */
+	for (i = 0; i < ATTRIBUTE_COUNT; i++)
+	    init_pair (i + 1, color_table[i][0], color_table[i][1]);
 
-    /* Setup color attributes */
-    for (i = 0; i < ATTRIBUTE_COUNT; i++)
-        attributes[i] = C_ATTR (color_table[i][2], i + 1);
+	/* Setup color attributes */
+	for (i = 0; i < ATTRIBUTE_COUNT; i++)
+	    attributes[i] = C_ATTR (color_table[i][2], i + 1);
     }
 }
 
@@ -204,50 +204,50 @@ print_autowrap (WINDOW * win, const char *prompt, int width, int y, int x)
     strcpy (tempstr, prompt);
 
     prompt_len = strlen(tempstr);
-    
+	
     /*
      * Remove newlines
      */
     for(i=0; i<prompt_len; i++) {
-    if(tempstr[i] == '\n') tempstr[i] = ' ';
+	if(tempstr[i] == '\n') tempstr[i] = ' ';
     }
 
-    if (prompt_len <= width - x * 2) {    /* If prompt is short */
-    wmove (win, y, (width - prompt_len) / 2);
-    waddstr (win, tempstr);
+    if (prompt_len <= width - x * 2) {	/* If prompt is short */
+	wmove (win, y, (width - prompt_len) / 2);
+	waddstr (win, tempstr);
     } else {
-    cur_x = x;
-    cur_y = y;
-    newl = 1;
-    word = tempstr;
-    while (word && *word) {
-        sp = index(word, ' ');
-        if (sp)
-            *sp++ = 0;
-
-        /* Wrap to next line if either the word does not fit,
-           or it is the first word of a new sentence, and it is
-           short, and the next word does not fit. */
-        room = width - cur_x;
-        wlen = strlen(word);
-        if (wlen > room ||
-           (newl && wlen < 4 && sp && wlen+1+strlen(sp) > room
-             && (!(sp2 = index(sp, ' ')) || wlen+1+(sp2-sp) > room))) {
-        cur_y++;
-        cur_x = x;
-        }
-        wmove (win, cur_y, cur_x);
-        waddstr (win, word);
-        getyx (win, cur_y, cur_x);
-        cur_x++;
-        if (sp && *sp == ' ') {
-            cur_x++;    /* double space */
-        while (*++sp == ' ');
-        newl = 1;
-        } else
-            newl = 0;
-        word = sp;
-    }
+	cur_x = x;
+	cur_y = y;
+	newl = 1;
+	word = tempstr;
+	while (word && *word) {
+	    sp = index(word, ' ');
+	    if (sp)
+	        *sp++ = 0;
+
+	    /* Wrap to next line if either the word does not fit,
+	       or it is the first word of a new sentence, and it is
+	       short, and the next word does not fit. */
+	    room = width - cur_x;
+	    wlen = strlen(word);
+	    if (wlen > room ||
+	       (newl && wlen < 4 && sp && wlen+1+strlen(sp) > room
+		     && (!(sp2 = index(sp, ' ')) || wlen+1+(sp2-sp) > room))) {
+		cur_y++;
+		cur_x = x;
+	    }
+	    wmove (win, cur_y, cur_x);
+	    waddstr (win, word);
+	    getyx (win, cur_y, cur_x);
+	    cur_x++;
+	    if (sp && *sp == ' ') {
+	        cur_x++;	/* double space */
+		while (*++sp == ' ');
+		newl = 1;
+	    } else
+	        newl = 0;
+	    word = sp;
+	}
     }
 }
 
@@ -265,14 +265,14 @@ print_button (WINDOW * win, const char *label, int y, int x, int selected)
     temp = strspn (label, " ");
     label += temp;
     wattrset (win, selected ? button_label_active_attr
-          : button_label_inactive_attr);
+	      : button_label_inactive_attr);
     for (i = 0; i < temp; i++)
-    waddch (win, ' ');
+	waddch (win, ' ');
     wattrset (win, selected ? button_key_active_attr
-          : button_key_inactive_attr);
+	      : button_key_inactive_attr);
     waddch (win, label[0]);
     wattrset (win, selected ? button_label_active_attr
-          : button_label_inactive_attr);
+	      : button_label_inactive_attr);
     waddstr (win, (char *)label + 1);
     wattrset (win, selected ? button_active_attr : button_inactive_attr);
     waddstr (win, ">");
@@ -284,32 +284,32 @@ print_button (WINDOW * win, const char *label, int y, int x, int selected)
  */
 void
 draw_box (WINDOW * win, int y, int x, int height, int width,
-      chtype box, chtype border)
+	  chtype box, chtype border)
 {
     int i, j;
 
     wattrset (win, 0);
     for (i = 0; i < height; i++) {
-    wmove (win, y + i, x);
-    for (j = 0; j < width; j++)
-        if (!i && !j)
-        waddch (win, border | ACS_ULCORNER);
-        else if (i == height - 1 && !j)
-        waddch (win, border | ACS_LLCORNER);
-        else if (!i && j == width - 1)
-        waddch (win, box | ACS_URCORNER);
-        else if (i == height - 1 && j == width - 1)
-        waddch (win, box | ACS_LRCORNER);
-        else if (!i)
-        waddch (win, border | ACS_HLINE);
-        else if (i == height - 1)
-        waddch (win, box | ACS_HLINE);
-        else if (!j)
-        waddch (win, border | ACS_VLINE);
-        else if (j == width - 1)
-        waddch (win, box | ACS_VLINE);
-        else
-        waddch (win, box | ' ');
+	wmove (win, y + i, x);
+	for (j = 0; j < width; j++)
+	    if (!i && !j)
+		waddch (win, border | ACS_ULCORNER);
+	    else if (i == height - 1 && !j)
+		waddch (win, border | ACS_LLCORNER);
+	    else if (!i && j == width - 1)
+		waddch (win, box | ACS_URCORNER);
+	    else if (i == height - 1 && j == width - 1)
+		waddch (win, box | ACS_LRCORNER);
+	    else if (!i)
+		waddch (win, border | ACS_HLINE);
+	    else if (i == height - 1)
+		waddch (win, box | ACS_HLINE);
+	    else if (!j)
+		waddch (win, border | ACS_VLINE);
+	    else if (j == width - 1)
+		waddch (win, box | ACS_VLINE);
+	    else
+		waddch (win, box | ' ');
     }
 }
 
@@ -322,17 +322,17 @@ draw_shadow (WINDOW * win, int y, int x, int height, int width)
 {
     int i;
 
-    if (has_colors ()) {    /* Whether terminal supports color? */
-    wattrset (win, shadow_attr);
-    wmove (win, y + height, x + 2);
-    for (i = 0; i < width; i++)
-        waddch (win, winch (win) & A_CHARTEXT);
-    for (i = y + 1; i < y + height + 1; i++) {
-        wmove (win, i, x + width);
-        waddch (win, winch (win) & A_CHARTEXT);
-        waddch (win, winch (win) & A_CHARTEXT);
-    }
-    wnoutrefresh (win);
+    if (has_colors ()) {	/* Whether terminal supports color? */
+	wattrset (win, shadow_attr);
+	wmove (win, y + height, x + 2);
+	for (i = 0; i < width; i++)
+	    waddch (win, winch (win) & A_CHARTEXT);
+	for (i = y + 1; i < y + height + 1; i++) {
+	    wmove (win, i, x + width);
+	    waddch (win, winch (win) & A_CHARTEXT);
+	    waddch (win, winch (win) & A_CHARTEXT);
+	}
+	wnoutrefresh (win);
     }
 }
 
@@ -342,18 +342,18 @@ draw_shadow (WINDOW * win, int y, int x, int height, int width)
 int
 first_alpha(const char *string, const char *exempt)
 {
-    int i, in_paren=0, c;
+	int i, in_paren=0, c;
 
-    for (i = 0; i < strlen(string); i++) {
-        c = tolower(string[i]);
+	for (i = 0; i < strlen(string); i++) {
+		c = tolower(string[i]);
 
-        if (strchr("<[(", c)) ++in_paren;
-        if (strchr(">])", c)) --in_paren;
+		if (strchr("<[(", c)) ++in_paren;
+		if (strchr(">])", c)) --in_paren;
 
-        if ((! in_paren) && isalpha(c) &&
-             strchr(exempt, c) == 0)
-            return i;
-    }
+		if ((! in_paren) && isalpha(c) && 
+		     strchr(exempt, c) == 0)
+			return i;
+	}
 
-    return 0;
+	return 0;
 }

lxdialog/yesno.c

@@ -59,23 +59,23 @@ dialog_yesno (const char *title, const char *prompt, int height, int width)
     wattrset (dialog, border_attr);
     mvwaddch (dialog, height-3, 0, ACS_LTEE);
     for (i = 0; i < width - 2; i++)
-    waddch (dialog, ACS_HLINE);
+	waddch (dialog, ACS_HLINE);
     wattrset (dialog, dialog_attr);
     waddch (dialog, ACS_RTEE);
 
     if (title != NULL && strlen(title) >= width-2 ) {
-    /* truncate long title -- mec */
-    char * title2 = malloc(width-2+1);
-    memcpy( title2, title, width-2 );
-    title2[width-2] = '\0';
-    title = title2;
+	/* truncate long title -- mec */
+	char * title2 = malloc(width-2+1);
+	memcpy( title2, title, width-2 );
+	title2[width-2] = '\0';
+	title = title2;
     }
 
     if (title != NULL) {
-    wattrset (dialog, title_attr);
-    mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' ');
-    waddstr (dialog, (char *)title);
-    waddch (dialog, ' ');
+	wattrset (dialog, title_attr);
+	mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' ');
+	waddstr (dialog, (char *)title);
+	waddch (dialog, ' ');
     }
 
     wattrset (dialog, dialog_attr);
@@ -84,35 +84,35 @@ dialog_yesno (const char *title, const char *prompt, int height, int width)
     print_buttons(dialog, height, width, 0);
 
     while (key != ESC) {
-    key = wgetch (dialog);
-    switch (key) {
-    case 'Y':
-    case 'y':
-        delwin (dialog);
-        return 0;
-    case 'N':
-    case 'n':
-        delwin (dialog);
-        return 1;
-
-    case TAB:
-    case KEY_LEFT:
-    case KEY_RIGHT:
-        button = ((key == KEY_LEFT ? --button : ++button) < 0)
-            ? 1 : (button > 1 ? 0 : button);
-
-        print_buttons(dialog, height, width, button);
-        wrefresh (dialog);
-        break;
-    case ' ':
-    case '\n':
-        delwin (dialog);
-        return button;
-    case ESC:
-        break;
-    }
+	key = wgetch (dialog);
+	switch (key) {
+	case 'Y':
+	case 'y':
+	    delwin (dialog);
+	    return 0;
+	case 'N':
+	case 'n':
+	    delwin (dialog);
+	    return 1;
+
+	case TAB:
+	case KEY_LEFT:
+	case KEY_RIGHT:
+	    button = ((key == KEY_LEFT ? --button : ++button) < 0)
+			? 1 : (button > 1 ? 0 : button);
+
+	    print_buttons(dialog, height, width, button);
+	    wrefresh (dialog);
+	    break;
+	case ' ':
+	case '\n':
+	    delwin (dialog);
+	    return button;
+	case ESC:
+	    break;
+	}
     }
 
     delwin (dialog);
-    return -1;            /* ESC pressed */
+    return -1;			/* ESC pressed */
 }

modules/codec/xvmc/cpu_accel.c

@@ -81,15 +81,15 @@ static inline uint32_t arch_accel( void )
     AMD = (ebx == 0x68747541) && (ecx == 0x444d4163) && (edx == 0x69746e65);
 
     cpuid (0x00000001, eax, ebx, ecx, edx);
-    if (! (edx & 0x00800000))    /* no MMX */
+    if (! (edx & 0x00800000))	/* no MMX */
         return 0;
 
     caps = MPEG2_ACCEL_X86_MMX;
-    if (edx & 0x02000000)    /* SSE - identical to AMD MMX extensions */
+    if (edx & 0x02000000)	/* SSE - identical to AMD MMX extensions */
         caps = MPEG2_ACCEL_X86_MMX | MPEG2_ACCEL_X86_MMXEXT;
 
     cpuid (0x80000000, eax, ebx, ecx, edx);
-    if (eax < 0x80000001)    /* no extended capabilities */
+    if (eax < 0x80000001)	/* no extended capabilities */
         return caps;
 
     cpuid (0x80000001, eax, ebx, ecx, edx);
@@ -97,7 +97,7 @@ static inline uint32_t arch_accel( void )
     if (edx & 0x80000000)
         caps |= MPEG2_ACCEL_X86_3DNOW;
 
-    if (AMD && (edx & 0x00400000))    /* AMD MMX extensions */
+    if (AMD && (edx & 0x00400000))	/* AMD MMX extensions */
         caps |= MPEG2_ACCEL_X86_MMXEXT;
 
     return caps;

modules/codec/xvmc/decode.c

@@ -99,7 +99,7 @@ static inline int copy_chunk( mpeg2dec_t * mpeg2dec, int bytes )
 
             mpeg2dec->shift = 0xffffff00;
             mpeg2dec->chunk_size = chunk_ptr - mpeg2dec->chunk_start - 3;
-            mpeg2dec->chunk_ptr = chunk_ptr + 1;
+            mpeg2dec->chunk_ptr = chunk_ptr + 1;   
             copied = current - mpeg2dec->buf_start;
             mpeg2dec->buf_start = current;
             return copied;

modules/codec/xvmc/header.c

@@ -108,7 +108,7 @@ void mpeg2_header_state_init( mpeg2dec_t *mpeg2dec )
     }
     mpeg2dec->decoder.coding_type = I_TYPE;
     mpeg2dec->decoder.convert = NULL;
-    mpeg2dec->decoder.convert_id = NULL;
+    mpeg2dec->decoder.convert_id = NULL; 
     mpeg2dec->decoder.load_intra_quantizer_matrix = 1;
     mpeg2dec->decoder.load_non_intra_quantizer_matrix = 1;
     mpeg2dec->picture = mpeg2dec->pictures;
@@ -249,11 +249,11 @@ static int sequence_ext( mpeg2dec_t * mpeg2dec )
 
     switch( buffer[1] & 6 )
     {
-        case 0:    /* invalid */
+        case 0:	/* invalid */
             return 1;
-        case 2:    /* 4:2:0 */
+        case 2:	/* 4:2:0 */
             sequence->chroma_height >>= 1;
-        case 4:    /* 4:2:2 */
+        case 4:	/* 4:2:2 */
             sequence->chroma_width >>= 1;
     }
 
@@ -337,13 +337,13 @@ static inline void finalize_sequence( mpeg2_sequence_t * sequence )
                 sequence->pixel_width = sequence->pixel_height = 1;
                 return;
             case 3: /* 720x576 16:9 */
-                sequence->pixel_width = 64;    sequence->pixel_height = 45;
+                sequence->pixel_width = 64;	sequence->pixel_height = 45;
                 return;
             case 6: /* 720x480 16:9 */
-                sequence->pixel_width = 32;    sequence->pixel_height = 27;
+                sequence->pixel_width = 32;	sequence->pixel_height = 27;
                 return;
             case 12: /* 720*480 4:3 */
-                sequence->pixel_width = 8;    sequence->pixel_height = 9;
+                sequence->pixel_width = 8;	sequence->pixel_height = 9;
                 return;
             default:
                 height = 88 * sequence->pixel_width + 1171;
@@ -577,7 +577,7 @@ int mpeg2_header_picture( mpeg2dec_t * mpeg2dec )
     decoder->concealment_motion_vectors = 0;
     decoder->scan = mpeg2_scan_norm;
     decoder->picture_structure = FRAME_PICTURE;
-    mpeg2dec->copy_matrix = 0;
+    mpeg2dec->copy_matrix = 0;  
     return 0;
 }
 
@@ -814,7 +814,7 @@ void mpeg2_header_picture_finalize( mpeg2dec_t * mpeg2dec, uint32_t accels )
     else
     {
         /* decoder->second_field = 1; */
-        mpeg2dec->picture++;    /* second field picture */
+        mpeg2dec->picture++;	/* second field picture */
         *(mpeg2dec->picture) = mpeg2dec->new_picture;
         mpeg2dec->info.current_picture_2nd = mpeg2dec->picture;
         if (low_delay || decoder->coding_type == B_TYPE)

modules/codec/xvmc/motion_comp.c

@@ -50,53 +50,53 @@ void mpeg2_mc_init (uint32_t accel)
 #define predict_x(i) (avg2 (ref[i], ref[i+1]))
 #define predict_y(i) (avg2 (ref[i], (ref+stride)[i]))
 #define predict_xy(i) (avg4 (ref[i], ref[i+1], \
-                 (ref+stride)[i], (ref+stride)[i+1]))
+			     (ref+stride)[i], (ref+stride)[i+1]))
 
 #define put(predictor,i) dest[i] = predictor (i)
 #define avg(predictor,i) dest[i] = avg2 (predictor (i), dest[i])
 
 /* mc function template */
 
-#define MC_FUNC(op,xy)                            \
-static void MC_##op##_##xy##_16_c (uint8_t * dest, const uint8_t * ref,    \
-                   const int stride, int height)    \
-{                                    \
-    do {                                \
-    op (predict_##xy, 0);                        \
-    op (predict_##xy, 1);                        \
-    op (predict_##xy, 2);                        \
-    op (predict_##xy, 3);                        \
-    op (predict_##xy, 4);                        \
-    op (predict_##xy, 5);                        \
-    op (predict_##xy, 6);                        \
-    op (predict_##xy, 7);                        \
-    op (predict_##xy, 8);                        \
-    op (predict_##xy, 9);                        \
-    op (predict_##xy, 10);                        \
-    op (predict_##xy, 11);                        \
-    op (predict_##xy, 12);                        \
-    op (predict_##xy, 13);                        \
-    op (predict_##xy, 14);                        \
-    op (predict_##xy, 15);                        \
-    ref += stride;                            \
-    dest += stride;                            \
-    } while (--height);                            \
-}                                    \
-static void MC_##op##_##xy##_8_c (uint8_t * dest, const uint8_t * ref,    \
-                  const int stride, int height)        \
-{                                    \
-    do {                                \
-    op (predict_##xy, 0);                        \
-    op (predict_##xy, 1);                        \
-    op (predict_##xy, 2);                        \
-    op (predict_##xy, 3);                        \
-    op (predict_##xy, 4);                        \
-    op (predict_##xy, 5);                        \
-    op (predict_##xy, 6);                        \
-    op (predict_##xy, 7);                        \
-    ref += stride;                            \
-    dest += stride;                            \
-    } while (--height);                            \
+#define MC_FUNC(op,xy)							\
+static void MC_##op##_##xy##_16_c (uint8_t * dest, const uint8_t * ref,	\
+				   const int stride, int height)	\
+{									\
+    do {								\
+	op (predict_##xy, 0);						\
+	op (predict_##xy, 1);						\
+	op (predict_##xy, 2);						\
+	op (predict_##xy, 3);						\
+	op (predict_##xy, 4);						\
+	op (predict_##xy, 5);						\
+	op (predict_##xy, 6);						\
+	op (predict_##xy, 7);						\
+	op (predict_##xy, 8);						\
+	op (predict_##xy, 9);						\
+	op (predict_##xy, 10);						\
+	op (predict_##xy, 11);						\
+	op (predict_##xy, 12);						\
+	op (predict_##xy, 13);						\
+	op (predict_##xy, 14);						\
+	op (predict_##xy, 15);						\
+	ref += stride;							\
+	dest += stride;							\
+    } while (--height);							\
+}									\
+static void MC_##op##_##xy##_8_c (uint8_t * dest, const uint8_t * ref,	\
+				  const int stride, int height)		\
+{									\
+    do {								\
+	op (predict_##xy, 0);						\
+	op (predict_##xy, 1);						\
+	op (predict_##xy, 2);						\
+	op (predict_##xy, 3);						\
+	op (predict_##xy, 4);						\
+	op (predict_##xy, 5);						\
+	op (predict_##xy, 6);						\
+	op (predict_##xy, 7);						\
+	ref += stride;							\
+	dest += stride;							\
+    } while (--height);							\
 }
 
 /* definitions of the actual mc functions */

modules/codec/xvmc/motion_comp_mmx.c

@@ -67,175 +67,175 @@ static inline void mmx_zero_reg ()
 }
 
 static inline void mmx_average_2_U8 (uint8_t * dest, const uint8_t * src1,
-                     const uint8_t * src2)
+				     const uint8_t * src2)
 {
     /* *dest = (*src1 + *src2 + 1)/ 2; */
 
-    movq_m2r (*src1, mm1);    /* load 8 src1 bytes */
-    movq_r2r (mm1, mm2);    /* copy 8 src1 bytes */
+    movq_m2r (*src1, mm1);	/* load 8 src1 bytes */
+    movq_r2r (mm1, mm2);	/* copy 8 src1 bytes */
 
-    movq_m2r (*src2, mm3);    /* load 8 src2 bytes */
-    movq_r2r (mm3, mm4);    /* copy 8 src2 bytes */
+    movq_m2r (*src2, mm3);	/* load 8 src2 bytes */
+    movq_r2r (mm3, mm4);	/* copy 8 src2 bytes */
 
-    pxor_r2r (mm1, mm3);    /* xor src1 and src2 */
-    pand_m2r (mask1, mm3);    /* mask lower bits */
-    psrlq_i2r (1, mm3);        /* /2 */
-    por_r2r (mm2, mm4);        /* or src1 and src2 */
-    psubb_r2r (mm3, mm4);    /* subtract subresults */
-    movq_r2m (mm4, *dest);    /* store result in dest */
+    pxor_r2r (mm1, mm3);	/* xor src1 and src2 */
+    pand_m2r (mask1, mm3);	/* mask lower bits */
+    psrlq_i2r (1, mm3);		/* /2 */
+    por_r2r (mm2, mm4);		/* or src1 and src2 */
+    psubb_r2r (mm3, mm4);	/* subtract subresults */
+    movq_r2m (mm4, *dest);	/* store result in dest */
 }
 
 static inline void mmx_interp_average_2_U8 (uint8_t * dest,
-                        const uint8_t * src1,
-                        const uint8_t * src2)
+					    const uint8_t * src1,
+					    const uint8_t * src2)
 {
     /* *dest = (*dest + (*src1 + *src2 + 1)/ 2 + 1)/ 2; */
 
-    movq_m2r (*dest, mm1);    /* load 8 dest bytes */
-    movq_r2r (mm1, mm2);    /* copy 8 dest bytes */
+    movq_m2r (*dest, mm1);	/* load 8 dest bytes */
+    movq_r2r (mm1, mm2);	/* copy 8 dest bytes */
 
-    movq_m2r (*src1, mm3);    /* load 8 src1 bytes */
-    movq_r2r (mm3, mm4);    /* copy 8 src1 bytes */
+    movq_m2r (*src1, mm3);	/* load 8 src1 bytes */
+    movq_r2r (mm3, mm4);	/* copy 8 src1 bytes */
 
-    movq_m2r (*src2, mm5);    /* load 8 src2 bytes */
-    movq_r2r (mm5, mm6);    /* copy 8 src2 bytes */
+    movq_m2r (*src2, mm5);	/* load 8 src2 bytes */
+    movq_r2r (mm5, mm6);	/* copy 8 src2 bytes */
 
-    pxor_r2r (mm3, mm5);    /* xor src1 and src2 */
-    pand_m2r (mask1, mm5);    /* mask lower bits */
-    psrlq_i2r (1, mm5);        /* /2 */
-    por_r2r (mm4, mm6);        /* or src1 and src2 */
-    psubb_r2r (mm5, mm6);    /* subtract subresults */
-    movq_r2r (mm6, mm5);    /* copy subresult */
+    pxor_r2r (mm3, mm5);	/* xor src1 and src2 */
+    pand_m2r (mask1, mm5);	/* mask lower bits */
+    psrlq_i2r (1, mm5);		/* /2 */
+    por_r2r (mm4, mm6);		/* or src1 and src2 */
+    psubb_r2r (mm5, mm6);	/* subtract subresults */
+    movq_r2r (mm6, mm5);	/* copy subresult */
 
-    pxor_r2r (mm1, mm5);    /* xor srcavg and dest */
-    pand_m2r (mask1, mm5);    /* mask lower bits */
-    psrlq_i2r (1, mm5);        /* /2 */
-    por_r2r (mm2, mm6);        /* or srcavg and dest */
-    psubb_r2r (mm5, mm6);    /* subtract subresults */
-    movq_r2m (mm6, *dest);    /* store result in dest */
+    pxor_r2r (mm1, mm5);	/* xor srcavg and dest */
+    pand_m2r (mask1, mm5);	/* mask lower bits */
+    psrlq_i2r (1, mm5);		/* /2 */
+    por_r2r (mm2, mm6);		/* or srcavg and dest */
+    psubb_r2r (mm5, mm6);	/* subtract subresults */
+    movq_r2m (mm6, *dest);	/* store result in dest */
 }
 
 static inline void mmx_average_4_U8 (uint8_t * dest, const uint8_t * src1,
-                     const uint8_t * src2,
-                     const uint8_t * src3,
-                     const uint8_t * src4)
+				     const uint8_t * src2,
+				     const uint8_t * src3,
+				     const uint8_t * src4)
 {
     /* *dest = (*src1 + *src2 + *src3 + *src4 + 2)/ 4; */
 
-    movq_m2r (*src1, mm1);    /* load 8 src1 bytes */
-    movq_r2r (mm1, mm2);    /* copy 8 src1 bytes */
+    movq_m2r (*src1, mm1);	/* load 8 src1 bytes */
+    movq_r2r (mm1, mm2);	/* copy 8 src1 bytes */
 
-    punpcklbw_r2r (mm0, mm1);    /* unpack low src1 bytes */
-    punpckhbw_r2r (mm0, mm2);    /* unpack high src1 bytes */
+    punpcklbw_r2r (mm0, mm1);	/* unpack low src1 bytes */
+    punpckhbw_r2r (mm0, mm2);	/* unpack high src1 bytes */
 
-    movq_m2r (*src2, mm3);    /* load 8 src2 bytes */
-    movq_r2r (mm3, mm4);    /* copy 8 src2 bytes */
+    movq_m2r (*src2, mm3);	/* load 8 src2 bytes */
+    movq_r2r (mm3, mm4);	/* copy 8 src2 bytes */
 
-    punpcklbw_r2r (mm0, mm3);    /* unpack low src2 bytes */
-    punpckhbw_r2r (mm0, mm4);    /* unpack high src2 bytes */
+    punpcklbw_r2r (mm0, mm3);	/* unpack low src2 bytes */
+    punpckhbw_r2r (mm0, mm4);	/* unpack high src2 bytes */
 
-    paddw_r2r (mm3, mm1);    /* add lows */
-    paddw_r2r (mm4, mm2);    /* add highs */
+    paddw_r2r (mm3, mm1);	/* add lows */
+    paddw_r2r (mm4, mm2);	/* add highs */
 
     /* now have partials in mm1 and mm2 */
 
-    movq_m2r (*src3, mm3);    /* load 8 src3 bytes */
-    movq_r2r (mm3, mm4);    /* copy 8 src3 bytes */
+    movq_m2r (*src3, mm3);	/* load 8 src3 bytes */
+    movq_r2r (mm3, mm4);	/* copy 8 src3 bytes */
 
-    punpcklbw_r2r (mm0, mm3);    /* unpack low src3 bytes */
-    punpckhbw_r2r (mm0, mm4);    /* unpack high src3 bytes */
+    punpcklbw_r2r (mm0, mm3);	/* unpack low src3 bytes */
+    punpckhbw_r2r (mm0, mm4);	/* unpack high src3 bytes */
 
-    paddw_r2r (mm3, mm1);    /* add lows */
-    paddw_r2r (mm4, mm2);    /* add highs */
+    paddw_r2r (mm3, mm1);	/* add lows */
+    paddw_r2r (mm4, mm2);	/* add highs */
 
-    movq_m2r (*src4, mm5);    /* load 8 src4 bytes */
-    movq_r2r (mm5, mm6);    /* copy 8 src4 bytes */
+    movq_m2r (*src4, mm5);	/* load 8 src4 bytes */
+    movq_r2r (mm5, mm6);	/* copy 8 src4 bytes */
 
-    punpcklbw_r2r (mm0, mm5);    /* unpack low src4 bytes */
-    punpckhbw_r2r (mm0, mm6);    /* unpack high src4 bytes */
+    punpcklbw_r2r (mm0, mm5);	/* unpack low src4 bytes */
+    punpckhbw_r2r (mm0, mm6);	/* unpack high src4 bytes */
 
-    paddw_r2r (mm5, mm1);    /* add lows */
-    paddw_r2r (mm6, mm2);    /* add highs */
+    paddw_r2r (mm5, mm1);	/* add lows */
+    paddw_r2r (mm6, mm2);	/* add highs */
 
     /* now have subtotal in mm1 and mm2 */
 
     paddw_m2r (round4, mm1);
-    psraw_i2r (2, mm1);        /* /4 */
+    psraw_i2r (2, mm1);		/* /4 */
     paddw_m2r (round4, mm2);
-    psraw_i2r (2, mm2);        /* /4 */
+    psraw_i2r (2, mm2);		/* /4 */
 
-    packuswb_r2r (mm2, mm1);    /* pack (w/ saturation) */
-    movq_r2m (mm1, *dest);    /* store result in dest */
+    packuswb_r2r (mm2, mm1);	/* pack (w/ saturation) */
+    movq_r2m (mm1, *dest);	/* store result in dest */
 }
 
 static inline void mmx_interp_average_4_U8 (uint8_t * dest,
-                        const uint8_t * src1,
-                        const uint8_t * src2,
-                        const uint8_t * src3,
-                        const uint8_t * src4)
+					    const uint8_t * src1,
+					    const uint8_t * src2,
+					    const uint8_t * src3,
+					    const uint8_t * src4)
 {
     /* *dest = (*dest + (*src1 + *src2 + *src3 + *src4 + 2)/ 4 + 1)/ 2; */
 
-    movq_m2r (*src1, mm1);    /* load 8 src1 bytes */
-    movq_r2r (mm1, mm2);    /* copy 8 src1 bytes */
+    movq_m2r (*src1, mm1);	/* load 8 src1 bytes */
+    movq_r2r (mm1, mm2);	/* copy 8 src1 bytes */
 
-    punpcklbw_r2r (mm0, mm1);    /* unpack low src1 bytes */
-    punpckhbw_r2r (mm0, mm2);    /* unpack high src1 bytes */
+    punpcklbw_r2r (mm0, mm1);	/* unpack low src1 bytes */
+    punpckhbw_r2r (mm0, mm2);	/* unpack high src1 bytes */
 
-    movq_m2r (*src2, mm3);    /* load 8 src2 bytes */
-    movq_r2r (mm3, mm4);    /* copy 8 src2 bytes */
+    movq_m2r (*src2, mm3);	/* load 8 src2 bytes */
+    movq_r2r (mm3, mm4);	/* copy 8 src2 bytes */
 
-    punpcklbw_r2r (mm0, mm3);    /* unpack low src2 bytes */
-    punpckhbw_r2r (mm0, mm4);    /* unpack high src2 bytes */
+    punpcklbw_r2r (mm0, mm3);	/* unpack low src2 bytes */
+    punpckhbw_r2r (mm0, mm4);	/* unpack high src2 bytes */
 
-    paddw_r2r (mm3, mm1);    /* add lows */
-    paddw_r2r (mm4, mm2);    /* add highs */
+    paddw_r2r (mm3, mm1);	/* add lows */
+    paddw_r2r (mm4, mm2);	/* add highs */
 
     /* now have partials in mm1 and mm2 */
 
-    movq_m2r (*src3, mm3);    /* load 8 src3 bytes */
-    movq_r2r (mm3, mm4);    /* copy 8 src3 bytes */
+    movq_m2r (*src3, mm3);	/* load 8 src3 bytes */
+    movq_r2r (mm3, mm4);	/* copy 8 src3 bytes */
 
-    punpcklbw_r2r (mm0, mm3);    /* unpack low src3 bytes */
-    punpckhbw_r2r (mm0, mm4);    /* unpack high src3 bytes */
+    punpcklbw_r2r (mm0, mm3);	/* unpack low src3 bytes */
+    punpckhbw_r2r (mm0, mm4);	/* unpack high src3 bytes */
 
-    paddw_r2r (mm3, mm1);    /* add lows */
-    paddw_r2r (mm4, mm2);    /* add highs */
+    paddw_r2r (mm3, mm1);	/* add lows */
+    paddw_r2r (mm4, mm2);	/* add highs */
 
-    movq_m2r (*src4, mm5);    /* load 8 src4 bytes */
-    movq_r2r (mm5, mm6);    /* copy 8 src4 bytes */
+    movq_m2r (*src4, mm5);	/* load 8 src4 bytes */
+    movq_r2r (mm5, mm6);	/* copy 8 src4 bytes */
 
-    punpcklbw_r2r (mm0, mm5);    /* unpack low src4 bytes */
-    punpckhbw_r2r (mm0, mm6);    /* unpack high src4 bytes */
+    punpcklbw_r2r (mm0, mm5);	/* unpack low src4 bytes */
+    punpckhbw_r2r (mm0, mm6);	/* unpack high src4 bytes */
 
-    paddw_r2r (mm5, mm1);    /* add lows */
-    paddw_r2r (mm6, mm2);    /* add highs */
+    paddw_r2r (mm5, mm1);	/* add lows */
+    paddw_r2r (mm6, mm2);	/* add highs */
 
     paddw_m2r (round4, mm1);
-    psraw_i2r (2, mm1);        /* /4 */
+    psraw_i2r (2, mm1);		/* /4 */
     paddw_m2r (round4, mm2);
-    psraw_i2r (2, mm2);        /* /4 */
+    psraw_i2r (2, mm2);		/* /4 */
 
     /* now have subtotal/4 in mm1 and mm2 */
 
-    movq_m2r (*dest, mm3);    /* load 8 dest bytes */
-    movq_r2r (mm3, mm4);    /* copy 8 dest bytes */
+    movq_m2r (*dest, mm3);	/* load 8 dest bytes */
+    movq_r2r (mm3, mm4);	/* copy 8 dest bytes */
 
-    packuswb_r2r (mm2, mm1);    /* pack (w/ saturation) */
-    movq_r2r (mm1,mm2);        /* copy subresult */
+    packuswb_r2r (mm2, mm1);	/* pack (w/ saturation) */
+    movq_r2r (mm1,mm2);		/* copy subresult */
 
-    pxor_r2r (mm1, mm3);    /* xor srcavg and dest */
-    pand_m2r (mask1, mm3);    /* mask lower bits */
-    psrlq_i2r (1, mm3);        /* /2 */
-    por_r2r (mm2, mm4);        /* or srcavg and dest */
-    psubb_r2r (mm3, mm4);    /* subtract subresults */
-    movq_r2m (mm4, *dest);    /* store result in dest */
+    pxor_r2r (mm1, mm3);	/* xor srcavg and dest */
+    pand_m2r (mask1, mm3);	/* mask lower bits */
+    psrlq_i2r (1, mm3);		/* /2 */
+    por_r2r (mm2, mm4);		/* or srcavg and dest */
+    psubb_r2r (mm3, mm4);	/* subtract subresults */
+    movq_r2m (mm4, *dest);	/* store result in dest */
 }
 
 /*-----------------------------------------------------------------------*/
 
 static inline void MC_avg_mmx (const int width, int height, uint8_t * dest,
-                   const uint8_t * ref, const int stride)
+			       const uint8_t * ref, const int stride)
 {
     mmx_zero_reg ();
 
@@ -252,13 +252,13 @@ static inline void MC_avg_mmx (const int width, int height, uint8_t * dest,
 }
 
 static void MC_avg_o_16_mmx (uint8_t * dest, const uint8_t * ref,
-                 int stride, int height)
+			     int stride, int height)
 {
     MC_avg_mmx (16, height, dest, ref, stride);
 }
 
 static void MC_avg_o_8_mmx (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+			    int stride, int height)
 {
     MC_avg_mmx (8, height, dest, ref, stride);
 }
@@ -266,19 +266,19 @@ static void MC_avg_o_8_mmx (uint8_t * dest, const uint8_t * ref,
 /*-----------------------------------------------------------------------*/
 
 static inline void MC_put_mmx (const int width, int height, uint8_t * dest,
-                   const uint8_t * ref, const int stride)
+			       const uint8_t * ref, const int stride)
 {
     mmx_zero_reg ();
 
     do
     {
-        movq_m2r (* ref, mm1);    /* load 8 ref bytes */
-        movq_r2m (mm1,* dest);    /* store 8 bytes at curr */
+        movq_m2r (* ref, mm1);	/* load 8 ref bytes */
+        movq_r2m (mm1,* dest);	/* store 8 bytes at curr */
 
         if( width == 16 )
         {
-            movq_m2r (* (ref+8), mm1);    /* load 8 ref bytes */
-            movq_r2m (mm1,* (dest+8));    /* store 8 bytes at curr */
+            movq_m2r (* (ref+8), mm1);	/* load 8 ref bytes */
+            movq_r2m (mm1,* (dest+8));	/* store 8 bytes at curr */
         }
         dest += stride;
         ref += stride;
@@ -286,13 +286,13 @@ static inline void MC_put_mmx (const int width, int height, uint8_t * dest,
 }
 
 static void MC_put_o_16_mmx (uint8_t * dest, const uint8_t * ref,
-                 int stride, int height)
+			     int stride, int height)
 {
     MC_put_mmx (16, height, dest, ref, stride);
 }
 
 static void MC_put_o_8_mmx (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+			    int stride, int height)
 {
     MC_put_mmx (8, height, dest, ref, stride);
 }
@@ -301,7 +301,7 @@ static void MC_put_o_8_mmx (uint8_t * dest, const uint8_t * ref,
 
 /* Half pixel interpolation in the x direction */
 static inline void MC_avg_x_mmx (const int width, int height, uint8_t * dest,
-                 const uint8_t * ref, const int stride)
+				 const uint8_t * ref, const int stride)
 {
     mmx_zero_reg ();
 
@@ -318,13 +318,13 @@ static inline void MC_avg_x_mmx (const int width, int height, uint8_t * dest,
 }
 
 static void MC_avg_x_16_mmx (uint8_t * dest, const uint8_t * ref,
-                 int stride, int height)
+			     int stride, int height)
 {
     MC_avg_x_mmx (16, height, dest, ref, stride);
 }
 
 static void MC_avg_x_8_mmx (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+			    int stride, int height)
 {
     MC_avg_x_mmx (8, height, dest, ref, stride);
 }
@@ -332,7 +332,7 @@ static void MC_avg_x_8_mmx (uint8_t * dest, const uint8_t * ref,
 /*-----------------------------------------------------------------------*/
 
 static inline void MC_put_x_mmx (const int width, int height, uint8_t * dest,
-                 const uint8_t * ref, const int stride)
+				 const uint8_t * ref, const int stride)
 {
     mmx_zero_reg ();
 
@@ -349,13 +349,13 @@ static inline void MC_put_x_mmx (const int width, int height, uint8_t * dest,
 }
 
 static void MC_put_x_16_mmx (uint8_t * dest, const uint8_t * ref,
-                 int stride, int height)
+			     int stride, int height)
 {
     MC_put_x_mmx (16, height, dest, ref, stride);
 }
 
 static void MC_put_x_8_mmx (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+			    int stride, int height)
 {
     MC_put_x_mmx (8, height, dest, ref, stride);
 }
@@ -363,7 +363,7 @@ static void MC_put_x_8_mmx (uint8_t * dest, const uint8_t * ref,
 /*-----------------------------------------------------------------------*/
 
 static inline void MC_avg_xy_mmx (const int width, int height, uint8_t * dest,
-                  const uint8_t * ref, const int stride)
+				  const uint8_t * ref, const int stride)
 {
     const uint8_t * ref_next = ref + stride;
 
@@ -384,13 +384,13 @@ static inline void MC_avg_xy_mmx (const int width, int height, uint8_t * dest,
 }
 
 static void MC_avg_xy_16_mmx (uint8_t * dest, const uint8_t * ref,
-                  int stride, int height)
+			      int stride, int height)
 {
     MC_avg_xy_mmx (16, height, dest, ref, stride);
 }
 
 static void MC_avg_xy_8_mmx (uint8_t * dest, const uint8_t * ref,
-                 int stride, int height)
+			     int stride, int height)
 {
     MC_avg_xy_mmx (8, height, dest, ref, stride);
 }
@@ -398,7 +398,7 @@ static void MC_avg_xy_8_mmx (uint8_t * dest, const uint8_t * ref,
 /*-----------------------------------------------------------------------*/
 
 static inline void MC_put_xy_mmx (const int width, int height, uint8_t * dest,
-                  const uint8_t * ref, const int stride)
+				  const uint8_t * ref, const int stride)
 {
     const uint8_t * ref_next = ref + stride;
 
@@ -418,13 +418,13 @@ static inline void MC_put_xy_mmx (const int width, int height, uint8_t * dest,
 }
 
 static void MC_put_xy_16_mmx (uint8_t * dest, const uint8_t * ref,
-                  int stride, int height)
+			      int stride, int height)
 {
     MC_put_xy_mmx (16, height, dest, ref, stride);
 }
 
 static void MC_put_xy_8_mmx (uint8_t * dest, const uint8_t * ref,
-                 int stride, int height)
+			     int stride, int height)
 {
     MC_put_xy_mmx (8, height, dest, ref, stride);
 }
@@ -432,7 +432,7 @@ static void MC_put_xy_8_mmx (uint8_t * dest, const uint8_t * ref,
 /*-----------------------------------------------------------------------*/
 
 static inline void MC_avg_y_mmx (const int width, int height, uint8_t * dest,
-                 const uint8_t * ref, const int stride)
+				 const uint8_t * ref, const int stride)
 {
     const uint8_t * ref_next = ref + stride;
 
@@ -452,13 +452,13 @@ static inline void MC_avg_y_mmx (const int width, int height, uint8_t * dest,
 }
 
 static void MC_avg_y_16_mmx (uint8_t * dest, const uint8_t * ref,
-                 int stride, int height)
+			     int stride, int height)
 {
     MC_avg_y_mmx (16, height, dest, ref, stride);
 }
 
 static void MC_avg_y_8_mmx (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+			    int stride, int height)
 {
     MC_avg_y_mmx (8, height, dest, ref, stride);
 }
@@ -466,7 +466,7 @@ static void MC_avg_y_8_mmx (uint8_t * dest, const uint8_t * ref,
 /*-----------------------------------------------------------------------*/
 
 static inline void MC_put_y_mmx (const int width, int height, uint8_t * dest,
-                 const uint8_t * ref, const int stride)
+				 const uint8_t * ref, const int stride)
 {
     const uint8_t * ref_next = ref + stride;
 
@@ -486,13 +486,13 @@ static inline void MC_put_y_mmx (const int width, int height, uint8_t * dest,
 }
 
 static void MC_put_y_16_mmx (uint8_t * dest, const uint8_t * ref,
-                 int stride, int height)
+			     int stride, int height)
 {
     MC_put_y_mmx (16, height, dest, ref, stride);
 }
 
 static void MC_put_y_8_mmx (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+			    int stride, int height)
 {
     MC_put_y_mmx (8, height, dest, ref, stride);
 }
@@ -502,20 +502,20 @@ MPEG2_MC_EXTERN (mmx)
 
 /* CPU_MMXEXT/CPU_3DNOW adaptation layer */
 
-#define pavg_r2r(src,dest)        \
-do {                    \
-    if (cpu == CPU_MMXEXT)        \
-    pavgb_r2r (src, dest);        \
-    else                \
-    pavgusb_r2r (src, dest);    \
+#define pavg_r2r(src,dest)		\
+do {					\
+    if (cpu == CPU_MMXEXT)		\
+	pavgb_r2r (src, dest);		\
+    else				\
+	pavgusb_r2r (src, dest);	\
 } while (0)
 
-#define pavg_m2r(src,dest)        \
-do {                    \
-    if (cpu == CPU_MMXEXT)        \
-    pavgb_m2r (src, dest);        \
-    else                \
-    pavgusb_m2r (src, dest);    \
+#define pavg_m2r(src,dest)		\
+do {					\
+    if (cpu == CPU_MMXEXT)		\
+	pavgb_m2r (src, dest);		\
+    else				\
+	pavgusb_m2r (src, dest);	\
 } while (0)
 
 
@@ -523,7 +523,7 @@ do {                    \
 
 
 static inline void MC_put1_8 (int height, uint8_t * dest, const uint8_t * ref,
-                  const int stride)
+			      const int stride)
 {
     do {
         movq_m2r (*ref, mm0);
@@ -534,7 +534,7 @@ static inline void MC_put1_8 (int height, uint8_t * dest, const uint8_t * ref,
 }
 
 static inline void MC_put1_16 (int height, uint8_t * dest, const uint8_t * ref,
-                   const int stride)
+			       const int stride)
 {
     do {
         movq_m2r (*ref, mm0);
@@ -547,7 +547,7 @@ static inline void MC_put1_16 (int height, uint8_t * dest, const uint8_t * ref,
 }
 
 static inline void MC_avg1_8 (int height, uint8_t * dest, const uint8_t * ref,
-                  const int stride, const int cpu)
+			      const int stride, const int cpu)
 {
     do {
         movq_m2r (*ref, mm0);
@@ -559,7 +559,7 @@ static inline void MC_avg1_8 (int height, uint8_t * dest, const uint8_t * ref,
 }
 
 static inline void MC_avg1_16 (int height, uint8_t * dest, const uint8_t * ref,
-                   const int stride, const int cpu)
+			       const int stride, const int cpu)
 {
     do {
         movq_m2r (*ref, mm0);
@@ -574,8 +574,8 @@ static inline void MC_avg1_16 (int height, uint8_t * dest, const uint8_t * ref,
 }
 
 static inline void MC_put2_8 (int height, uint8_t * dest, const uint8_t * ref,
-                  const int stride, const int offset,
-                  const int cpu)
+			      const int stride, const int offset,
+			      const int cpu)
 {
     do {
         movq_m2r (*ref, mm0);
@@ -587,8 +587,8 @@ static inline void MC_put2_8 (int height, uint8_t * dest, const uint8_t * ref,
 }
 
 static inline void MC_put2_16 (int height, uint8_t * dest, const uint8_t * ref,
-                   const int stride, const int offset,
-                   const int cpu)
+			       const int stride, const int offset,
+			       const int cpu)
 {
     do {
         movq_m2r (*ref, mm0);
@@ -603,8 +603,8 @@ static inline void MC_put2_16 (int height, uint8_t * dest, const uint8_t * ref,
 }
 
 static inline void MC_avg2_8 (int height, uint8_t * dest, const uint8_t * ref,
-                  const int stride, const int offset,
-                  const int cpu)
+			      const int stride, const int offset,
+			      const int cpu)
 {
     do {
         movq_m2r (*ref, mm0);
@@ -617,8 +617,8 @@ static inline void MC_avg2_8 (int height, uint8_t * dest, const uint8_t * ref,
 }
 
 static inline void MC_avg2_16 (int height, uint8_t * dest, const uint8_t * ref,
-                   const int stride, const int offset,
-                   const int cpu)
+			       const int stride, const int offset,
+			       const int cpu)
 {
     do {
         movq_m2r (*ref, mm0);
@@ -637,7 +637,7 @@ static inline void MC_avg2_16 (int height, uint8_t * dest, const uint8_t * ref,
 static mmx_t mask_one = {0x0101010101010101LL};
 
 static inline void MC_put4_8 (int height, uint8_t * dest, const uint8_t * ref,
-                  const int stride, const int cpu)
+			      const int stride, const int cpu)
 {
     movq_m2r (*ref, mm0);
     movq_m2r (*(ref+1), mm1);
@@ -670,13 +670,13 @@ static inline void MC_put4_8 (int height, uint8_t * dest, const uint8_t * ref,
         movq_r2m (mm0, *dest);
         dest += stride;
 
-        movq_r2r (mm6, mm7);    /* unroll ! */
-        movq_r2r (mm2, mm0);    /* unroll ! */
+        movq_r2r (mm6, mm7);	/* unroll ! */
+        movq_r2r (mm2, mm0);	/* unroll ! */
     } while (--height);
 }
 
 static inline void MC_put4_16 (int height, uint8_t * dest, const uint8_t * ref,
-                   const int stride, const int cpu)
+			       const int stride, const int cpu)
 {
     do {
         movq_m2r (*ref, mm0);
@@ -722,7 +722,7 @@ static inline void MC_put4_16 (int height, uint8_t * dest, const uint8_t * ref,
 }
 
 static inline void MC_avg4_8 (int height, uint8_t * dest, const uint8_t * ref,
-                  const int stride, const int cpu)
+			      const int stride, const int cpu)
 {
     do {
         movq_m2r (*ref, mm0);
@@ -751,7 +751,7 @@ static inline void MC_avg4_8 (int height, uint8_t * dest, const uint8_t * ref,
 }
 
 static inline void MC_avg4_16 (int height, uint8_t * dest, const uint8_t * ref,
-                   const int stride, const int cpu)
+			       const int stride, const int cpu)
 {
     do {
         movq_m2r (*ref, mm0);
@@ -801,97 +801,97 @@ static inline void MC_avg4_16 (int height, uint8_t * dest, const uint8_t * ref,
 }
 
 static void MC_avg_o_16_mmxext (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+				int stride, int height)
 {
     MC_avg1_16 (height, dest, ref, stride, CPU_MMXEXT);
 }
 
 static void MC_avg_o_8_mmxext (uint8_t * dest, const uint8_t * ref,
-                   int stride, int height)
+			       int stride, int height)
 {
     MC_avg1_8 (height, dest, ref, stride, CPU_MMXEXT);
 }
 
 static void MC_put_o_16_mmxext (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+				int stride, int height)
 {
     MC_put1_16 (height, dest, ref, stride);
 }
 
 static void MC_put_o_8_mmxext (uint8_t * dest, const uint8_t * ref,
-                   int stride, int height)
+			       int stride, int height)
 {
     MC_put1_8 (height, dest, ref, stride);
 }
 
 static void MC_avg_x_16_mmxext (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+				int stride, int height)
 {
     MC_avg2_16 (height, dest, ref, stride, 1, CPU_MMXEXT);
 }
 
 static void MC_avg_x_8_mmxext (uint8_t * dest, const uint8_t * ref,
-                   int stride, int height)
+			       int stride, int height)
 {
     MC_avg2_8 (height, dest, ref, stride, 1, CPU_MMXEXT);
 }
 
 static void MC_put_x_16_mmxext (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+				int stride, int height)
 {
     MC_put2_16 (height, dest, ref, stride, 1, CPU_MMXEXT);
 }
 
 static void MC_put_x_8_mmxext (uint8_t * dest, const uint8_t * ref,
-                   int stride, int height)
+			       int stride, int height)
 {
     MC_put2_8 (height, dest, ref, stride, 1, CPU_MMXEXT);
 }
 
 static void MC_avg_y_16_mmxext (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+				int stride, int height)
 {
     MC_avg2_16 (height, dest, ref, stride, stride, CPU_MMXEXT);
 }
 
 static void MC_avg_y_8_mmxext (uint8_t * dest, const uint8_t * ref,
-                   int stride, int height)
+			       int stride, int height)
 {
     MC_avg2_8 (height, dest, ref, stride, stride, CPU_MMXEXT);
 }
 
 static void MC_put_y_16_mmxext (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+				int stride, int height)
 {
     MC_put2_16 (height, dest, ref, stride, stride, CPU_MMXEXT);
 }
 
 static void MC_put_y_8_mmxext (uint8_t * dest, const uint8_t * ref,
-                   int stride, int height)
+			       int stride, int height)
 {
     MC_put2_8 (height, dest, ref, stride, stride, CPU_MMXEXT);
 }
 
 static void MC_avg_xy_16_mmxext (uint8_t * dest, const uint8_t * ref,
-                 int stride, int height)
+				 int stride, int height)
 {
     MC_avg4_16 (height, dest, ref, stride, CPU_MMXEXT);
 }
 
 static void MC_avg_xy_8_mmxext (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+				int stride, int height)
 {
     MC_avg4_8 (height, dest, ref, stride, CPU_MMXEXT);
 }
 
 static void MC_put_xy_16_mmxext (uint8_t * dest, const uint8_t * ref,
-                 int stride, int height)
+				 int stride, int height)
 {
     MC_put4_16 (height, dest, ref, stride, CPU_MMXEXT);
 }
 
 static void MC_put_xy_8_mmxext (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+				int stride, int height)
 {
     MC_put4_8 (height, dest, ref, stride, CPU_MMXEXT);
 }
@@ -899,97 +899,97 @@ static void MC_put_xy_8_mmxext (uint8_t * dest, const uint8_t * ref,
 MPEG2_MC_EXTERN (mmxext)
 
 static void MC_avg_o_16_3dnow (uint8_t * dest, const uint8_t * ref,
-                   int stride, int height)
+			       int stride, int height)
 {
     MC_avg1_16 (height, dest, ref, stride, CPU_3DNOW);
 }
 
 static void MC_avg_o_8_3dnow (uint8_t * dest, const uint8_t * ref,
-                  int stride, int height)
+			      int stride, int height)
 {
     MC_avg1_8 (height, dest, ref, stride, CPU_3DNOW);
 }
 
 static void MC_put_o_16_3dnow (uint8_t * dest, const uint8_t * ref,
-                   int stride, int height)
+			       int stride, int height)
 {
     MC_put1_16 (height, dest, ref, stride);
 }
 
 static void MC_put_o_8_3dnow (uint8_t * dest, const uint8_t * ref,
-                  int stride, int height)
+			      int stride, int height)
 {
     MC_put1_8 (height, dest, ref, stride);
 }
 
 static void MC_avg_x_16_3dnow (uint8_t * dest, const uint8_t * ref,
-                   int stride, int height)
+			       int stride, int height)
 {
     MC_avg2_16 (height, dest, ref, stride, 1, CPU_3DNOW);
 }
 
 static void MC_avg_x_8_3dnow (uint8_t * dest, const uint8_t * ref,
-                  int stride, int height)
+			      int stride, int height)
 {
     MC_avg2_8 (height, dest, ref, stride, 1, CPU_3DNOW);
 }
 
 static void MC_put_x_16_3dnow (uint8_t * dest, const uint8_t * ref,
-                   int stride, int height)
+			       int stride, int height)
 {
     MC_put2_16 (height, dest, ref, stride, 1, CPU_3DNOW);
 }
 
 static void MC_put_x_8_3dnow (uint8_t * dest, const uint8_t * ref,
-                  int stride, int height)
+			      int stride, int height)
 {
     MC_put2_8 (height, dest, ref, stride, 1, CPU_3DNOW);
 }
 
 static void MC_avg_y_16_3dnow (uint8_t * dest, const uint8_t * ref,
-                   int stride, int height)
+			       int stride, int height)
 {
     MC_avg2_16 (height, dest, ref, stride, stride, CPU_3DNOW);
 }
 
 static void MC_avg_y_8_3dnow (uint8_t * dest, const uint8_t * ref,
-                  int stride, int height)
+			      int stride, int height)
 {
     MC_avg2_8 (height, dest, ref, stride, stride, CPU_3DNOW);
 }
 
 static void MC_put_y_16_3dnow (uint8_t * dest, const uint8_t * ref,
-                   int stride, int height)
+			       int stride, int height)
 {
     MC_put2_16 (height, dest, ref, stride, stride, CPU_3DNOW);
 }
 
 static void MC_put_y_8_3dnow (uint8_t * dest, const uint8_t * ref,
-                  int stride, int height)
+			      int stride, int height)
 {
     MC_put2_8 (height, dest, ref, stride, stride, CPU_3DNOW);
 }
 
 static void MC_avg_xy_16_3dnow (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+				int stride, int height)
 {
     MC_avg4_16 (height, dest, ref, stride, CPU_3DNOW);
 }
 
 static void MC_avg_xy_8_3dnow (uint8_t * dest, const uint8_t * ref,
-                   int stride, int height)
+			       int stride, int height)
 {
     MC_avg4_8 (height, dest, ref, stride, CPU_3DNOW);
 }
 
 static void MC_put_xy_16_3dnow (uint8_t * dest, const uint8_t * ref,
-                int stride, int height)
+				int stride, int height)
 {
     MC_put4_16 (height, dest, ref, stride, CPU_3DNOW);
 }
 
 static void MC_put_xy_8_3dnow (uint8_t * dest, const uint8_t * ref,
-                   int stride, int height)
+			       int stride, int height)
 {
     MC_put4_8 (height, dest, ref, stride, CPU_3DNOW);
 }

modules/codec/xvmc/mpeg2.h

@@ -25,7 +25,7 @@
 #define MPEG2_H
 
 #define MPEG2_VERSION(a,b,c) (((a)<<16)|((b)<<8)|(c))
-#define MPEG2_RELEASE MPEG2_VERSION (0, 4, 0)    /* 0.4.0 */
+#define MPEG2_RELEASE MPEG2_VERSION (0, 4, 0)	/* 0.4.0 */
 
 #define SEQ_FLAG_MPEG2 1
 #define SEQ_FLAG_CONSTRAINED_PARAMETERS 2
@@ -154,9 +154,9 @@ typedef enum
 } mpeg2_convert_stage_t;
 
 typedef int mpeg2_convert_t (int stage, void * id,
-                 const mpeg2_sequence_t * sequence, int stride,
-                 uint32_t accel, void * arg,
-                 mpeg2_convert_init_t * result);
+			     const mpeg2_sequence_t * sequence, int stride,
+			     uint32_t accel, void * arg,
+			     mpeg2_convert_init_t * result);
 int mpeg2_convert (mpeg2dec_t * mpeg2dec, mpeg2_convert_t convert, void * arg);
 int mpeg2_stride (mpeg2dec_t * mpeg2dec, int stride);
 void mpeg2_set_buf (mpeg2dec_t * mpeg2dec, uint8_t * buf[3], void * id);
@@ -188,7 +188,7 @@ void mpeg2_slice_region (mpeg2dec_t * mpeg2dec, int start, int end);
 void mpeg2_tag_picture (mpeg2dec_t * mpeg2dec, uint32_t tag, uint32_t tag2);
 
 void mpeg2_init_fbuf (mpeg2_decoder_t * decoder, uint8_t * current_fbuf[3],
-              uint8_t * forward_fbuf[3], uint8_t * backward_fbuf[3]);
+		      uint8_t * forward_fbuf[3], uint8_t * backward_fbuf[3]);
 
 typedef enum
 {
@@ -202,6 +202,6 @@ typedef enum
 void * mpeg2_malloc (unsigned size, mpeg2_alloc_t reason);
 void mpeg2_free (void * buf);
 void mpeg2_malloc_hooks (void * malloc (unsigned, mpeg2_alloc_t),
-             int free (void *));
+			 int free (void *));
 
 #endif /* MPEG2_H */

modules/codec/xvmc/mpeg2_internal.h

@@ -66,9 +66,9 @@ struct mpeg2_decoder_s
     /* next inside a slice, and is never used outside of mpeg2_slice() */
 
     /* bit parsing stuff */
-    uint32_t bitstream_buf;        /* current 32 bit working set */
-    int bitstream_bits;            /* used bits in working set */
-    const uint8_t * bitstream_ptr;    /* buffer with stream data */
+    uint32_t bitstream_buf;		/* current 32 bit working set */
+    int bitstream_bits;			/* used bits in working set */
+    const uint8_t * bitstream_ptr;	/* buffer with stream data */
 
     uint8_t * dest[3];
 
@@ -203,7 +203,7 @@ struct mpeg2dec_s
     mpeg2_picture_t new_picture;
     mpeg2_picture_t pictures[4];
     mpeg2_picture_t * picture;
-    /*const*/ mpeg2_fbuf_t * fbuf[3];    /* 0: current fbuf, 1-2: prediction fbufs */
+    /*const*/ mpeg2_fbuf_t * fbuf[3];	/* 0: current fbuf, 1-2: prediction fbufs */
 
     fbuf_alloc_t fbuf_alloc[3];
     int custom_fbuf;
@@ -281,7 +281,7 @@ typedef struct {
     mpeg2_mc_fct * avg [8];
 } mpeg2_mc_t;
 
-#define MPEG2_MC_EXTERN(x) mpeg2_mc_t mpeg2_mc_##x = {              \
+#define MPEG2_MC_EXTERN(x) mpeg2_mc_t mpeg2_mc_##x = {			  \
     {MC_put_o_16_##x, MC_put_x_16_##x, MC_put_y_16_##x, MC_put_xy_16_##x, \
      MC_put_o_8_##x,  MC_put_x_8_##x,  MC_put_y_8_##x,  MC_put_xy_8_##x}, \
     {MC_avg_o_16_##x, MC_avg_x_16_##x, MC_avg_y_16_##x, MC_avg_xy_16_##x, \

modules/codec/xvmc/slice.c

@@ -37,7 +37,7 @@ extern void (* mpeg2_cpu_state_restore) (cpu_state_t * state);
 #include "vlc.h"
 
 static inline int get_motion_delta( mpeg2_decoder_t * const decoder,
-                    const int f_code )
+				    const int f_code )
 {
 #define bit_buf (decoder->bitstream_buf)
 #define bits (decoder->bitstream_bits)
@@ -112,292 +112,292 @@ static inline int get_dmv (mpeg2_decoder_t * const decoder)
 #undef bit_ptr
 }
 
-#define MOTION_420(table,ref,motion_x,motion_y,size,y)                  \
-    pos_x = 2 * decoder->offset + motion_x;                      \
-    pos_y = 2 * decoder->v_offset + motion_y + 2 * y;                  \
-    if (unlikely (pos_x > decoder->limit_x)) {                      \
-    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
-    motion_x = pos_x - 2 * decoder->offset;                      \
-    }                                          \
-    if (unlikely (pos_y > decoder->limit_y_ ## size)) {                  \
-    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size;          \
-    motion_y = pos_y - 2 * decoder->v_offset - 2 * y;              \
-    }                                          \
-    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                      \
+#define MOTION_420(table,ref,motion_x,motion_y,size,y)			      \
+    pos_x = 2 * decoder->offset + motion_x;				      \
+    pos_y = 2 * decoder->v_offset + motion_y + 2 * y;			      \
+    if (unlikely (pos_x > decoder->limit_x)) {				      \
+	pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;		      \
+	motion_x = pos_x - 2 * decoder->offset;				      \
+    }									      \
+    if (unlikely (pos_y > decoder->limit_y_ ## size)) {			      \
+	pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size;	      \
+	motion_y = pos_y - 2 * decoder->v_offset - 2 * y;		      \
+    }									      \
+    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);				      \
     table[xy_half] (decoder->dest[0] + y * decoder->stride + decoder->offset, \
-            ref[0] + (pos_x >> 1) + (pos_y >> 1) * decoder->stride,   \
-            decoder->stride, size);                      \
-    motion_x /= 2;    motion_y /= 2;                          \
-    xy_half = ((motion_y & 1) << 1) | (motion_x & 1);                  \
-    offset = (((decoder->offset + motion_x) >> 1) +                  \
-          ((((decoder->v_offset + motion_y) >> 1) + y/2) *              \
-           decoder->uv_stride));                          \
-    table[4+xy_half] (decoder->dest[1] + y/2 * decoder->uv_stride +          \
-              (decoder->offset >> 1), ref[1] + offset,              \
-              decoder->uv_stride, size/2);                  \
-    table[4+xy_half] (decoder->dest[2] + y/2 * decoder->uv_stride +          \
-              (decoder->offset >> 1), ref[2] + offset,              \
-              decoder->uv_stride, size/2)
+		    ref[0] + (pos_x >> 1) + (pos_y >> 1) * decoder->stride,   \
+		    decoder->stride, size);				      \
+    motion_x /= 2;	motion_y /= 2;					      \
+    xy_half = ((motion_y & 1) << 1) | (motion_x & 1);			      \
+    offset = (((decoder->offset + motion_x) >> 1) +			      \
+	      ((((decoder->v_offset + motion_y) >> 1) + y/2) *		      \
+	       decoder->uv_stride));					      \
+    table[4+xy_half] (decoder->dest[1] + y/2 * decoder->uv_stride +	      \
+		      (decoder->offset >> 1), ref[1] + offset,		      \
+		      decoder->uv_stride, size/2);			      \
+    table[4+xy_half] (decoder->dest[2] + y/2 * decoder->uv_stride +	      \
+		      (decoder->offset >> 1), ref[2] + offset,		      \
+		      decoder->uv_stride, size/2)
 
 #define MOTION_FIELD_420(table,ref,motion_x,motion_y,dest_field,op,src_field) \
-    pos_x = 2 * decoder->offset + motion_x;                      \
-    pos_y = decoder->v_offset + motion_y;                      \
-    if (unlikely (pos_x > decoder->limit_x)) {                      \
-    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
-    motion_x = pos_x - 2 * decoder->offset;                      \
-    }                                          \
-    if (unlikely (pos_y > decoder->limit_y)) {                      \
-    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;              \
-    motion_y = pos_y - decoder->v_offset;                      \
-    }                                          \
-    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                      \
-    table[xy_half] (decoder->dest[0] + dest_field * decoder->stride +          \
-            decoder->offset,                          \
-            (ref[0] + (pos_x >> 1) +                      \
-             ((pos_y op) + src_field) * decoder->stride),          \
-            2 * decoder->stride, 8);                      \
-    motion_x /= 2;    motion_y /= 2;                          \
-    xy_half = ((motion_y & 1) << 1) | (motion_x & 1);                  \
-    offset = (((decoder->offset + motion_x) >> 1) +                  \
-          (((decoder->v_offset >> 1) + (motion_y op) + src_field) *          \
-           decoder->uv_stride));                          \
+    pos_x = 2 * decoder->offset + motion_x;				      \
+    pos_y = decoder->v_offset + motion_y;				      \
+    if (unlikely (pos_x > decoder->limit_x)) {				      \
+	pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;		      \
+	motion_x = pos_x - 2 * decoder->offset;				      \
+    }									      \
+    if (unlikely (pos_y > decoder->limit_y)) {				      \
+	pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;		      \
+	motion_y = pos_y - decoder->v_offset;				      \
+    }									      \
+    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);				      \
+    table[xy_half] (decoder->dest[0] + dest_field * decoder->stride +	      \
+		    decoder->offset,					      \
+		    (ref[0] + (pos_x >> 1) +				      \
+		     ((pos_y op) + src_field) * decoder->stride),	      \
+		    2 * decoder->stride, 8);				      \
+    motion_x /= 2;	motion_y /= 2;					      \
+    xy_half = ((motion_y & 1) << 1) | (motion_x & 1);			      \
+    offset = (((decoder->offset + motion_x) >> 1) +			      \
+	      (((decoder->v_offset >> 1) + (motion_y op) + src_field) *	      \
+	       decoder->uv_stride));					      \
     table[4+xy_half] (decoder->dest[1] + dest_field * decoder->uv_stride +    \
-              (decoder->offset >> 1), ref[1] + offset,              \
-              2 * decoder->uv_stride, 4);                  \
+		      (decoder->offset >> 1), ref[1] + offset,		      \
+		      2 * decoder->uv_stride, 4);			      \
     table[4+xy_half] (decoder->dest[2] + dest_field * decoder->uv_stride +    \
-              (decoder->offset >> 1), ref[2] + offset,              \
-              2 * decoder->uv_stride, 4)
-
-#define MOTION_DMV_420(table,ref,motion_x,motion_y)                  \
-    pos_x = 2 * decoder->offset + motion_x;                      \
-    pos_y = decoder->v_offset + motion_y;                      \
-    if (unlikely (pos_x > decoder->limit_x)) {                      \
-    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
-    motion_x = pos_x - 2 * decoder->offset;                      \
-    }                                          \
-    if (unlikely (pos_y > decoder->limit_y)) {                      \
-    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;              \
-    motion_y = pos_y - decoder->v_offset;                      \
-    }                                          \
-    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                      \
-    offset = (pos_x >> 1) + (pos_y & ~1) * decoder->stride;              \
-    table[xy_half] (decoder->dest[0] + decoder->offset,                  \
-            ref[0] + offset, 2 * decoder->stride, 8);              \
+		      (decoder->offset >> 1), ref[2] + offset,		      \
+		      2 * decoder->uv_stride, 4)
+
+#define MOTION_DMV_420(table,ref,motion_x,motion_y)			      \
+    pos_x = 2 * decoder->offset + motion_x;				      \
+    pos_y = decoder->v_offset + motion_y;				      \
+    if (unlikely (pos_x > decoder->limit_x)) {				      \
+	pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;		      \
+	motion_x = pos_x - 2 * decoder->offset;				      \
+    }									      \
+    if (unlikely (pos_y > decoder->limit_y)) {				      \
+	pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;		      \
+	motion_y = pos_y - decoder->v_offset;				      \
+    }									      \
+    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);				      \
+    offset = (pos_x >> 1) + (pos_y & ~1) * decoder->stride;		      \
+    table[xy_half] (decoder->dest[0] + decoder->offset,			      \
+		    ref[0] + offset, 2 * decoder->stride, 8);		      \
     table[xy_half] (decoder->dest[0] + decoder->stride + decoder->offset,     \
-            ref[0] + decoder->stride + offset,                  \
-            2 * decoder->stride, 8);                      \
-    motion_x /= 2;    motion_y /= 2;                          \
-    xy_half = ((motion_y & 1) << 1) | (motion_x & 1);                  \
-    offset = (((decoder->offset + motion_x) >> 1) +                  \
-          (((decoder->v_offset >> 1) + (motion_y & ~1)) *              \
-           decoder->uv_stride));                          \
-    table[4+xy_half] (decoder->dest[1] + (decoder->offset >> 1),          \
-              ref[1] + offset, 2 * decoder->uv_stride, 4);          \
-    table[4+xy_half] (decoder->dest[1] + decoder->uv_stride +              \
-              (decoder->offset >> 1),                      \
-              ref[1] + decoder->uv_stride + offset,              \
-              2 * decoder->uv_stride, 4);                  \
-    table[4+xy_half] (decoder->dest[2] + (decoder->offset >> 1),          \
-              ref[2] + offset, 2 * decoder->uv_stride, 4);          \
-    table[4+xy_half] (decoder->dest[2] + decoder->uv_stride +              \
-              (decoder->offset >> 1),                      \
-              ref[2] + decoder->uv_stride + offset,              \
-              2 * decoder->uv_stride, 4)
-
-#define MOTION_ZERO_420(table,ref)                          \
-    table[0] (decoder->dest[0] + decoder->offset,                  \
-          (ref[0] + decoder->offset +                      \
-           decoder->v_offset * decoder->stride), decoder->stride, 16);    \
-    offset = ((decoder->offset >> 1) +                          \
-          (decoder->v_offset >> 1) * decoder->uv_stride);              \
-    table[4] (decoder->dest[1] + (decoder->offset >> 1),              \
-          ref[1] + offset, decoder->uv_stride, 8);                  \
-    table[4] (decoder->dest[2] + (decoder->offset >> 1),              \
-          ref[2] + offset, decoder->uv_stride, 8)
-
-#define MOTION_422(table,ref,motion_x,motion_y,size,y)                  \
-    pos_x = 2 * decoder->offset + motion_x;                      \
-    pos_y = 2 * decoder->v_offset + motion_y + 2 * y;                  \
-    if (unlikely (pos_x > decoder->limit_x)) {                      \
-    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
-    motion_x = pos_x - 2 * decoder->offset;                      \
-    }                                          \
-    if (unlikely (pos_y > decoder->limit_y_ ## size)) {                  \
-    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size;          \
-    motion_y = pos_y - 2 * decoder->v_offset - 2 * y;              \
-    }                                          \
-    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                      \
-    offset = (pos_x >> 1) + (pos_y >> 1) * decoder->stride;              \
+		    ref[0] + decoder->stride + offset,			      \
+		    2 * decoder->stride, 8);				      \
+    motion_x /= 2;	motion_y /= 2;					      \
+    xy_half = ((motion_y & 1) << 1) | (motion_x & 1);			      \
+    offset = (((decoder->offset + motion_x) >> 1) +			      \
+	      (((decoder->v_offset >> 1) + (motion_y & ~1)) *		      \
+	       decoder->uv_stride));					      \
+    table[4+xy_half] (decoder->dest[1] + (decoder->offset >> 1),	      \
+		      ref[1] + offset, 2 * decoder->uv_stride, 4);	      \
+    table[4+xy_half] (decoder->dest[1] + decoder->uv_stride +		      \
+		      (decoder->offset >> 1),				      \
+		      ref[1] + decoder->uv_stride + offset,		      \
+		      2 * decoder->uv_stride, 4);			      \
+    table[4+xy_half] (decoder->dest[2] + (decoder->offset >> 1),	      \
+		      ref[2] + offset, 2 * decoder->uv_stride, 4);	      \
+    table[4+xy_half] (decoder->dest[2] + decoder->uv_stride +		      \
+		      (decoder->offset >> 1),				      \
+		      ref[2] + decoder->uv_stride + offset,		      \
+		      2 * decoder->uv_stride, 4)
+
+#define MOTION_ZERO_420(table,ref)					      \
+    table[0] (decoder->dest[0] + decoder->offset,			      \
+	      (ref[0] + decoder->offset +				      \
+	       decoder->v_offset * decoder->stride), decoder->stride, 16);    \
+    offset = ((decoder->offset >> 1) +					      \
+	      (decoder->v_offset >> 1) * decoder->uv_stride);		      \
+    table[4] (decoder->dest[1] + (decoder->offset >> 1),		      \
+	      ref[1] + offset, decoder->uv_stride, 8);			      \
+    table[4] (decoder->dest[2] + (decoder->offset >> 1),		      \
+	      ref[2] + offset, decoder->uv_stride, 8)
+
+#define MOTION_422(table,ref,motion_x,motion_y,size,y)			      \
+    pos_x = 2 * decoder->offset + motion_x;				      \
+    pos_y = 2 * decoder->v_offset + motion_y + 2 * y;			      \
+    if (unlikely (pos_x > decoder->limit_x)) {				      \
+	pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;		      \
+	motion_x = pos_x - 2 * decoder->offset;				      \
+    }									      \
+    if (unlikely (pos_y > decoder->limit_y_ ## size)) {			      \
+	pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size;	      \
+	motion_y = pos_y - 2 * decoder->v_offset - 2 * y;		      \
+    }									      \
+    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);				      \
+    offset = (pos_x >> 1) + (pos_y >> 1) * decoder->stride;		      \
     table[xy_half] (decoder->dest[0] + y * decoder->stride + decoder->offset, \
-            ref[0] + offset, decoder->stride, size);              \
-    offset = (offset + (motion_x & (motion_x < 0))) >> 1;              \
-    motion_x /= 2;                                  \
-    xy_half = ((pos_y & 1) << 1) | (motion_x & 1);                  \
-    table[4+xy_half] (decoder->dest[1] + y * decoder->uv_stride +          \
-              (decoder->offset >> 1), ref[1] + offset,              \
-              decoder->uv_stride, size);                  \
-    table[4+xy_half] (decoder->dest[2] + y * decoder->uv_stride +          \
-              (decoder->offset >> 1), ref[2] + offset,              \
-              decoder->uv_stride, size)
+		    ref[0] + offset, decoder->stride, size);		      \
+    offset = (offset + (motion_x & (motion_x < 0))) >> 1;		      \
+    motion_x /= 2;							      \
+    xy_half = ((pos_y & 1) << 1) | (motion_x & 1);			      \
+    table[4+xy_half] (decoder->dest[1] + y * decoder->uv_stride +	      \
+		      (decoder->offset >> 1), ref[1] + offset,		      \
+		      decoder->uv_stride, size);			      \
+    table[4+xy_half] (decoder->dest[2] + y * decoder->uv_stride +	      \
+		      (decoder->offset >> 1), ref[2] + offset,		      \
+		      decoder->uv_stride, size)
 
 #define MOTION_FIELD_422(table,ref,motion_x,motion_y,dest_field,op,src_field) \
-    pos_x = 2 * decoder->offset + motion_x;                      \
-    pos_y = decoder->v_offset + motion_y;                      \
-    if (unlikely (pos_x > decoder->limit_x)) {                      \
-    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
-    motion_x = pos_x - 2 * decoder->offset;                      \
-    }                                          \
-    if (unlikely (pos_y > decoder->limit_y)) {                      \
-    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;              \
-    motion_y = pos_y - decoder->v_offset;                      \
-    }                                          \
-    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                      \
-    offset = (pos_x >> 1) + ((pos_y op) + src_field) * decoder->stride;          \
-    table[xy_half] (decoder->dest[0] + dest_field * decoder->stride +          \
-            decoder->offset, ref[0] + offset,                  \
-            2 * decoder->stride, 8);                      \
-    offset = (offset + (motion_x & (motion_x < 0))) >> 1;              \
-    motion_x /= 2;                                  \
-    xy_half = ((pos_y & 1) << 1) | (motion_x & 1);                  \
+    pos_x = 2 * decoder->offset + motion_x;				      \
+    pos_y = decoder->v_offset + motion_y;				      \
+    if (unlikely (pos_x > decoder->limit_x)) {				      \
+	pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;		      \
+	motion_x = pos_x - 2 * decoder->offset;				      \
+    }									      \
+    if (unlikely (pos_y > decoder->limit_y)) {				      \
+	pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;		      \
+	motion_y = pos_y - decoder->v_offset;				      \
+    }									      \
+    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);				      \
+    offset = (pos_x >> 1) + ((pos_y op) + src_field) * decoder->stride;	      \
+    table[xy_half] (decoder->dest[0] + dest_field * decoder->stride +	      \
+		    decoder->offset, ref[0] + offset,			      \
+		    2 * decoder->stride, 8);				      \
+    offset = (offset + (motion_x & (motion_x < 0))) >> 1;		      \
+    motion_x /= 2;							      \
+    xy_half = ((pos_y & 1) << 1) | (motion_x & 1);			      \
     table[4+xy_half] (decoder->dest[1] + dest_field * decoder->uv_stride +    \
-              (decoder->offset >> 1), ref[1] + offset,              \
-              2 * decoder->uv_stride, 8);                  \
+		      (decoder->offset >> 1), ref[1] + offset,		      \
+		      2 * decoder->uv_stride, 8);			      \
     table[4+xy_half] (decoder->dest[2] + dest_field * decoder->uv_stride +    \
-              (decoder->offset >> 1), ref[2] + offset,              \
-              2 * decoder->uv_stride, 8)
-
-#define MOTION_DMV_422(table,ref,motion_x,motion_y)                  \
-    pos_x = 2 * decoder->offset + motion_x;                      \
-    pos_y = decoder->v_offset + motion_y;                      \
-    if (unlikely (pos_x > decoder->limit_x)) {                      \
-    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
-    motion_x = pos_x - 2 * decoder->offset;                      \
-    }                                          \
-    if (unlikely (pos_y > decoder->limit_y)) {                      \
-    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;              \
-    motion_y = pos_y - decoder->v_offset;                      \
-    }                                          \
-    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                      \
-    offset = (pos_x >> 1) + (pos_y & ~1) * decoder->stride;              \
-    table[xy_half] (decoder->dest[0] + decoder->offset,                  \
-            ref[0] + offset, 2 * decoder->stride, 8);              \
+		      (decoder->offset >> 1), ref[2] + offset,		      \
+		      2 * decoder->uv_stride, 8)
+
+#define MOTION_DMV_422(table,ref,motion_x,motion_y)			      \
+    pos_x = 2 * decoder->offset + motion_x;				      \
+    pos_y = decoder->v_offset + motion_y;				      \
+    if (unlikely (pos_x > decoder->limit_x)) {				      \
+	pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;		      \
+	motion_x = pos_x - 2 * decoder->offset;				      \
+    }									      \
+    if (unlikely (pos_y > decoder->limit_y)) {				      \
+	pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;		      \
+	motion_y = pos_y - decoder->v_offset;				      \
+    }									      \
+    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);				      \
+    offset = (pos_x >> 1) + (pos_y & ~1) * decoder->stride;		      \
+    table[xy_half] (decoder->dest[0] + decoder->offset,			      \
+		    ref[0] + offset, 2 * decoder->stride, 8);		      \
     table[xy_half] (decoder->dest[0] + decoder->stride + decoder->offset,     \
-            ref[0] + decoder->stride + offset,                  \
-            2 * decoder->stride, 8);                      \
-    offset = (offset + (motion_x & (motion_x < 0))) >> 1;              \
-    motion_x /= 2;                                  \
-    xy_half = ((pos_y & 1) << 1) | (motion_x & 1);                  \
-    table[4+xy_half] (decoder->dest[1] + (decoder->offset >> 1),          \
-              ref[1] + offset, 2 * decoder->uv_stride, 8);          \
-    table[4+xy_half] (decoder->dest[1] + decoder->uv_stride +              \
-              (decoder->offset >> 1),                      \
-              ref[1] + decoder->uv_stride + offset,              \
-              2 * decoder->uv_stride, 8);                  \
-    table[4+xy_half] (decoder->dest[2] + (decoder->offset >> 1),          \
-              ref[2] + offset, 2 * decoder->uv_stride, 8);          \
-    table[4+xy_half] (decoder->dest[2] + decoder->uv_stride +              \
-              (decoder->offset >> 1),                      \
-              ref[2] + decoder->uv_stride + offset,              \
-              2 * decoder->uv_stride, 8)
-
-#define MOTION_ZERO_422(table,ref)                          \
-    offset = decoder->offset + decoder->v_offset * decoder->stride;          \
-    table[0] (decoder->dest[0] + decoder->offset,                  \
-          ref[0] + offset, decoder->stride, 16);                  \
-    offset >>= 1;                                  \
-    table[4] (decoder->dest[1] + (decoder->offset >> 1),              \
-          ref[1] + offset, decoder->uv_stride, 16);                  \
-    table[4] (decoder->dest[2] + (decoder->offset >> 1),              \
-          ref[2] + offset, decoder->uv_stride, 16)
-
-#define MOTION_444(table,ref,motion_x,motion_y,size,y)                  \
-    pos_x = 2 * decoder->offset + motion_x;                      \
-    pos_y = 2 * decoder->v_offset + motion_y + 2 * y;                  \
-    if (unlikely (pos_x > decoder->limit_x)) {                      \
-    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
-    motion_x = pos_x - 2 * decoder->offset;                      \
-    }                                          \
-    if (unlikely (pos_y > decoder->limit_y_ ## size)) {                  \
-    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size;          \
-    motion_y = pos_y - 2 * decoder->v_offset - 2 * y;              \
-    }                                          \
-    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                      \
-    offset = (pos_x >> 1) + (pos_y >> 1) * decoder->stride;              \
+		    ref[0] + decoder->stride + offset,			      \
+		    2 * decoder->stride, 8);				      \
+    offset = (offset + (motion_x & (motion_x < 0))) >> 1;		      \
+    motion_x /= 2;							      \
+    xy_half = ((pos_y & 1) << 1) | (motion_x & 1);			      \
+    table[4+xy_half] (decoder->dest[1] + (decoder->offset >> 1),	      \
+		      ref[1] + offset, 2 * decoder->uv_stride, 8);	      \
+    table[4+xy_half] (decoder->dest[1] + decoder->uv_stride +		      \
+		      (decoder->offset >> 1),				      \
+		      ref[1] + decoder->uv_stride + offset,		      \
+		      2 * decoder->uv_stride, 8);			      \
+    table[4+xy_half] (decoder->dest[2] + (decoder->offset >> 1),	      \
+		      ref[2] + offset, 2 * decoder->uv_stride, 8);	      \
+    table[4+xy_half] (decoder->dest[2] + decoder->uv_stride +		      \
+		      (decoder->offset >> 1),				      \
+		      ref[2] + decoder->uv_stride + offset,		      \
+		      2 * decoder->uv_stride, 8)
+
+#define MOTION_ZERO_422(table,ref)					      \
+    offset = decoder->offset + decoder->v_offset * decoder->stride;	      \
+    table[0] (decoder->dest[0] + decoder->offset,			      \
+	      ref[0] + offset, decoder->stride, 16);			      \
+    offset >>= 1;							      \
+    table[4] (decoder->dest[1] + (decoder->offset >> 1),		      \
+	      ref[1] + offset, decoder->uv_stride, 16);			      \
+    table[4] (decoder->dest[2] + (decoder->offset >> 1),		      \
+	      ref[2] + offset, decoder->uv_stride, 16)
+
+#define MOTION_444(table,ref,motion_x,motion_y,size,y)			      \
+    pos_x = 2 * decoder->offset + motion_x;				      \
+    pos_y = 2 * decoder->v_offset + motion_y + 2 * y;			      \
+    if (unlikely (pos_x > decoder->limit_x)) {				      \
+	pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;		      \
+	motion_x = pos_x - 2 * decoder->offset;				      \
+    }									      \
+    if (unlikely (pos_y > decoder->limit_y_ ## size)) {			      \
+	pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size;	      \
+	motion_y = pos_y - 2 * decoder->v_offset - 2 * y;		      \
+    }									      \
+    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);				      \
+    offset = (pos_x >> 1) + (pos_y >> 1) * decoder->stride;		      \
     table[xy_half] (decoder->dest[0] + y * decoder->stride + decoder->offset, \
-            ref[0] + offset, decoder->stride, size);              \
+		    ref[0] + offset, decoder->stride, size);		      \
     table[xy_half] (decoder->dest[1] + y * decoder->stride + decoder->offset, \
-            ref[1] + offset, decoder->stride, size);              \
+		    ref[1] + offset, decoder->stride, size);		      \
     table[xy_half] (decoder->dest[2] + y * decoder->stride + decoder->offset, \
-            ref[2] + offset, decoder->stride, size)
+		    ref[2] + offset, decoder->stride, size)
 
 #define MOTION_FIELD_444(table,ref,motion_x,motion_y,dest_field,op,src_field) \
-    pos_x = 2 * decoder->offset + motion_x;                      \
-    pos_y = decoder->v_offset + motion_y;                      \
-    if (unlikely (pos_x > decoder->limit_x)) {                      \
-    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
-    motion_x = pos_x - 2 * decoder->offset;                      \
-    }                                          \
-    if (unlikely (pos_y > decoder->limit_y)) {                      \
-    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;              \
-    motion_y = pos_y - decoder->v_offset;                      \
-    }                                          \
-    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                      \
-    offset = (pos_x >> 1) + ((pos_y op) + src_field) * decoder->stride;          \
-    table[xy_half] (decoder->dest[0] + dest_field * decoder->stride +          \
-            decoder->offset, ref[0] + offset,                  \
-            2 * decoder->stride, 8);                      \
-    table[xy_half] (decoder->dest[1] + dest_field * decoder->stride +          \
-            decoder->offset, ref[1] + offset,                  \
-            2 * decoder->stride, 8);                      \
-    table[xy_half] (decoder->dest[2] + dest_field * decoder->stride +          \
-            decoder->offset, ref[2] + offset,                  \
-            2 * decoder->stride, 8)
-
-#define MOTION_DMV_444(table,ref,motion_x,motion_y)                  \
-    pos_x = 2 * decoder->offset + motion_x;                      \
-    pos_y = decoder->v_offset + motion_y;                      \
-    if (unlikely (pos_x > decoder->limit_x)) {                      \
-    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
-    motion_x = pos_x - 2 * decoder->offset;                      \
-    }                                          \
-    if (unlikely (pos_y > decoder->limit_y)) {                      \
-    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;              \
-    motion_y = pos_y - decoder->v_offset;                      \
-    }                                          \
-    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                      \
-    offset = (pos_x >> 1) + (pos_y & ~1) * decoder->stride;              \
-    table[xy_half] (decoder->dest[0] + decoder->offset,                  \
-            ref[0] + offset, 2 * decoder->stride, 8);              \
+    pos_x = 2 * decoder->offset + motion_x;				      \
+    pos_y = decoder->v_offset + motion_y;				      \
+    if (unlikely (pos_x > decoder->limit_x)) {				      \
+	pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;		      \
+	motion_x = pos_x - 2 * decoder->offset;				      \
+    }									      \
+    if (unlikely (pos_y > decoder->limit_y)) {				      \
+	pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;		      \
+	motion_y = pos_y - decoder->v_offset;				      \
+    }									      \
+    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);				      \
+    offset = (pos_x >> 1) + ((pos_y op) + src_field) * decoder->stride;	      \
+    table[xy_half] (decoder->dest[0] + dest_field * decoder->stride +	      \
+		    decoder->offset, ref[0] + offset,			      \
+		    2 * decoder->stride, 8);				      \
+    table[xy_half] (decoder->dest[1] + dest_field * decoder->stride +	      \
+		    decoder->offset, ref[1] + offset,			      \
+		    2 * decoder->stride, 8);				      \
+    table[xy_half] (decoder->dest[2] + dest_field * decoder->stride +	      \
+		    decoder->offset, ref[2] + offset,			      \
+		    2 * decoder->stride, 8)
+
+#define MOTION_DMV_444(table,ref,motion_x,motion_y)			      \
+    pos_x = 2 * decoder->offset + motion_x;				      \
+    pos_y = decoder->v_offset + motion_y;				      \
+    if (unlikely (pos_x > decoder->limit_x)) {				      \
+	pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;		      \
+	motion_x = pos_x - 2 * decoder->offset;				      \
+    }									      \
+    if (unlikely (pos_y > decoder->limit_y)) {				      \
+	pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;		      \
+	motion_y = pos_y - decoder->v_offset;				      \
+    }									      \
+    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);				      \
+    offset = (pos_x >> 1) + (pos_y & ~1) * decoder->stride;		      \
+    table[xy_half] (decoder->dest[0] + decoder->offset,			      \
+		    ref[0] + offset, 2 * decoder->stride, 8);		      \
     table[xy_half] (decoder->dest[0] + decoder->stride + decoder->offset,     \
-            ref[0] + decoder->stride + offset,                  \
-            2 * decoder->stride, 8);                      \
-    table[xy_half] (decoder->dest[1] + decoder->offset,                  \
-            ref[1] + offset, 2 * decoder->stride, 8);              \
+		    ref[0] + decoder->stride + offset,			      \
+		    2 * decoder->stride, 8);				      \
+    table[xy_half] (decoder->dest[1] + decoder->offset,			      \
+		    ref[1] + offset, 2 * decoder->stride, 8);		      \
     table[xy_half] (decoder->dest[1] + decoder->stride + decoder->offset,     \
-            ref[1] + decoder->stride + offset,                  \
-            2 * decoder->stride, 8);                      \
-    table[xy_half] (decoder->dest[2] + decoder->offset,                  \
-            ref[2] + offset, 2 * decoder->stride, 8);              \
+		    ref[1] + decoder->stride + offset,			      \
+		    2 * decoder->stride, 8);				      \
+    table[xy_half] (decoder->dest[2] + decoder->offset,			      \
+		    ref[2] + offset, 2 * decoder->stride, 8);		      \
     table[xy_half] (decoder->dest[2] + decoder->stride + decoder->offset,     \
-            ref[2] + decoder->stride + offset,                  \
-            2 * decoder->stride, 8)
-
-#define MOTION_ZERO_444(table,ref)                          \
-    offset = decoder->offset + decoder->v_offset * decoder->stride;          \
-    table[0] (decoder->dest[0] + decoder->offset,                  \
-          ref[0] + offset, decoder->stride, 16);                  \
-    table[4] (decoder->dest[1] + decoder->offset,                  \
-          ref[1] + offset, decoder->stride, 16);                  \
-    table[4] (decoder->dest[2] + (decoder->offset >> 1),              \
-          ref[2] + offset, decoder->stride, 16)
+		    ref[2] + decoder->stride + offset,			      \
+		    2 * decoder->stride, 8)
+
+#define MOTION_ZERO_444(table,ref)					      \
+    offset = decoder->offset + decoder->v_offset * decoder->stride;	      \
+    table[0] (decoder->dest[0] + decoder->offset,			      \
+	      ref[0] + offset, decoder->stride, 16);			      \
+    table[4] (decoder->dest[1] + decoder->offset,			      \
+	      ref[1] + offset, decoder->stride, 16);			      \
+    table[4] (decoder->dest[2] + (decoder->offset >> 1),		      \
+	      ref[2] + offset, decoder->stride, 16)
 
 #define bit_buf (decoder->bitstream_buf)
 #define bits (decoder->bitstream_bits)
 #define bit_ptr (decoder->bitstream_ptr)
 
 static void motion_mp1 (mpeg2_decoder_t * const decoder,
-            motion_t * const motion,
-            mpeg2_mc_fct * const * const table)
+			motion_t * const motion,
+			mpeg2_mc_fct * const * const table)
 {
     int motion_x, motion_y;
     unsigned int pos_x, pos_y, xy_half, offset;
@@ -421,231 +421,231 @@ static void motion_mp1 (mpeg2_decoder_t * const decoder,
 }
 
 #define MOTION_FUNCTIONS(FORMAT,MOTION,MOTION_FIELD,MOTION_DMV,MOTION_ZERO)   \
-                                          \
-static void motion_fr_frame_##FORMAT (mpeg2_decoder_t * const decoder,          \
-                      motion_t * const motion,              \
-                      mpeg2_mc_fct * const * const table)     \
-{                                          \
-    int motion_x, motion_y;                              \
-    unsigned int pos_x, pos_y, xy_half, offset;                      \
-                                          \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    motion_x = motion->pmv[0][0] + get_motion_delta (decoder,              \
-                             motion->f_code[0]);      \
-    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);          \
-    motion->pmv[1][0] = motion->pmv[0][0] = motion_x;                  \
-                                          \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    motion_y = motion->pmv[0][1] + get_motion_delta (decoder,              \
-                             motion->f_code[1]);      \
-    motion_y = bound_motion_vector (motion_y, motion->f_code[1]);          \
-    motion->pmv[1][1] = motion->pmv[0][1] = motion_y;                  \
-                                          \
-    MOTION (table, motion->ref[0], motion_x, motion_y, 16, 0);              \
-}                                          \
-                                          \
-static void motion_fr_field_##FORMAT (mpeg2_decoder_t * const decoder,          \
-                      motion_t * const motion,              \
-                      mpeg2_mc_fct * const * const table)     \
-{                                          \
-    int motion_x, motion_y, field;                          \
-    unsigned int pos_x, pos_y, xy_half, offset;                      \
-                                          \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    field = UBITS (bit_buf, 1);                              \
-    DUMPBITS (bit_buf, bits, 1);                          \
-                                          \
-    motion_x = motion->pmv[0][0] + get_motion_delta (decoder,              \
-                             motion->f_code[0]);      \
-    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);          \
-    motion->pmv[0][0] = motion_x;                          \
-                                          \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    motion_y = ((motion->pmv[0][1] >> 1) +                      \
-        get_motion_delta (decoder, motion->f_code[1]));              \
-    /* motion_y = bound_motion_vector (motion_y, motion->f_code[1]); */          \
-    motion->pmv[0][1] = motion_y << 1;                          \
-                                          \
+									      \
+static void motion_fr_frame_##FORMAT (mpeg2_decoder_t * const decoder,	      \
+				      motion_t * const motion,		      \
+				      mpeg2_mc_fct * const * const table)     \
+{									      \
+    int motion_x, motion_y;						      \
+    unsigned int pos_x, pos_y, xy_half, offset;				      \
+									      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    motion_x = motion->pmv[0][0] + get_motion_delta (decoder,		      \
+						     motion->f_code[0]);      \
+    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);	      \
+    motion->pmv[1][0] = motion->pmv[0][0] = motion_x;			      \
+									      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    motion_y = motion->pmv[0][1] + get_motion_delta (decoder,		      \
+						     motion->f_code[1]);      \
+    motion_y = bound_motion_vector (motion_y, motion->f_code[1]);	      \
+    motion->pmv[1][1] = motion->pmv[0][1] = motion_y;			      \
+									      \
+    MOTION (table, motion->ref[0], motion_x, motion_y, 16, 0);		      \
+}									      \
+									      \
+static void motion_fr_field_##FORMAT (mpeg2_decoder_t * const decoder,	      \
+				      motion_t * const motion,		      \
+				      mpeg2_mc_fct * const * const table)     \
+{									      \
+    int motion_x, motion_y, field;					      \
+    unsigned int pos_x, pos_y, xy_half, offset;				      \
+									      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    field = UBITS (bit_buf, 1);						      \
+    DUMPBITS (bit_buf, bits, 1);					      \
+									      \
+    motion_x = motion->pmv[0][0] + get_motion_delta (decoder,		      \
+						     motion->f_code[0]);      \
+    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);	      \
+    motion->pmv[0][0] = motion_x;					      \
+									      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    motion_y = ((motion->pmv[0][1] >> 1) +				      \
+		get_motion_delta (decoder, motion->f_code[1]));		      \
+    /* motion_y = bound_motion_vector (motion_y, motion->f_code[1]); */	      \
+    motion->pmv[0][1] = motion_y << 1;					      \
+									      \
     MOTION_FIELD (table, motion->ref[0], motion_x, motion_y, 0, & ~1, field); \
-                                          \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    field = UBITS (bit_buf, 1);                              \
-    DUMPBITS (bit_buf, bits, 1);                          \
-                                          \
-    motion_x = motion->pmv[1][0] + get_motion_delta (decoder,              \
-                             motion->f_code[0]);      \
-    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);          \
-    motion->pmv[1][0] = motion_x;                          \
-                                          \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    motion_y = ((motion->pmv[1][1] >> 1) +                      \
-        get_motion_delta (decoder, motion->f_code[1]));              \
-    /* motion_y = bound_motion_vector (motion_y, motion->f_code[1]); */          \
-    motion->pmv[1][1] = motion_y << 1;                          \
-                                          \
+									      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    field = UBITS (bit_buf, 1);						      \
+    DUMPBITS (bit_buf, bits, 1);					      \
+									      \
+    motion_x = motion->pmv[1][0] + get_motion_delta (decoder,		      \
+						     motion->f_code[0]);      \
+    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);	      \
+    motion->pmv[1][0] = motion_x;					      \
+									      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    motion_y = ((motion->pmv[1][1] >> 1) +				      \
+		get_motion_delta (decoder, motion->f_code[1]));		      \
+    /* motion_y = bound_motion_vector (motion_y, motion->f_code[1]); */	      \
+    motion->pmv[1][1] = motion_y << 1;					      \
+									      \
     MOTION_FIELD (table, motion->ref[0], motion_x, motion_y, 1, & ~1, field); \
-}                                          \
-                                          \
-static void motion_fr_dmv_##FORMAT (mpeg2_decoder_t * const decoder,          \
-                    motion_t * const motion,              \
-                    mpeg2_mc_fct * const * const table)          \
-{                                          \
-    int motion_x, motion_y, dmv_x, dmv_y, m, other_x, other_y;              \
-    unsigned int pos_x, pos_y, xy_half, offset;                      \
-                                          \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    motion_x = motion->pmv[0][0] + get_motion_delta (decoder,              \
-                             motion->f_code[0]);      \
-    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);          \
-    motion->pmv[1][0] = motion->pmv[0][0] = motion_x;                  \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    dmv_x = get_dmv (decoder);                              \
-                                          \
-    motion_y = ((motion->pmv[0][1] >> 1) +                      \
-        get_motion_delta (decoder, motion->f_code[1]));              \
-    /* motion_y = bound_motion_vector (motion_y, motion->f_code[1]); */          \
-    motion->pmv[1][1] = motion->pmv[0][1] = motion_y << 1;              \
-    dmv_y = get_dmv (decoder);                              \
-                                          \
-    m = decoder->top_field_first ? 1 : 3;                      \
-    other_x = ((motion_x * m + (motion_x > 0)) >> 1) + dmv_x;              \
-    other_y = ((motion_y * m + (motion_y > 0)) >> 1) + dmv_y - 1;          \
+}									      \
+									      \
+static void motion_fr_dmv_##FORMAT (mpeg2_decoder_t * const decoder,	      \
+				    motion_t * const motion,		      \
+				    mpeg2_mc_fct * const * const table)	      \
+{									      \
+    int motion_x, motion_y, dmv_x, dmv_y, m, other_x, other_y;		      \
+    unsigned int pos_x, pos_y, xy_half, offset;				      \
+									      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    motion_x = motion->pmv[0][0] + get_motion_delta (decoder,		      \
+						     motion->f_code[0]);      \
+    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);	      \
+    motion->pmv[1][0] = motion->pmv[0][0] = motion_x;			      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    dmv_x = get_dmv (decoder);						      \
+									      \
+    motion_y = ((motion->pmv[0][1] >> 1) +				      \
+		get_motion_delta (decoder, motion->f_code[1]));		      \
+    /* motion_y = bound_motion_vector (motion_y, motion->f_code[1]); */	      \
+    motion->pmv[1][1] = motion->pmv[0][1] = motion_y << 1;		      \
+    dmv_y = get_dmv (decoder);						      \
+									      \
+    m = decoder->top_field_first ? 1 : 3;				      \
+    other_x = ((motion_x * m + (motion_x > 0)) >> 1) + dmv_x;		      \
+    other_y = ((motion_y * m + (motion_y > 0)) >> 1) + dmv_y - 1;	      \
     MOTION_FIELD (mpeg2_mc.put, motion->ref[0], other_x, other_y, 0, | 1, 0); \
-                                          \
-    m = decoder->top_field_first ? 3 : 1;                      \
-    other_x = ((motion_x * m + (motion_x > 0)) >> 1) + dmv_x;              \
-    other_y = ((motion_y * m + (motion_y > 0)) >> 1) + dmv_y + 1;          \
+									      \
+    m = decoder->top_field_first ? 3 : 1;				      \
+    other_x = ((motion_x * m + (motion_x > 0)) >> 1) + dmv_x;		      \
+    other_y = ((motion_y * m + (motion_y > 0)) >> 1) + dmv_y + 1;	      \
     MOTION_FIELD (mpeg2_mc.put, motion->ref[0], other_x, other_y, 1, & ~1, 0);\
-                                          \
-    MOTION_DMV (mpeg2_mc.avg, motion->ref[0], motion_x, motion_y);          \
-}                                          \
-                                          \
-static void motion_reuse_##FORMAT (mpeg2_decoder_t * const decoder,          \
-                   motion_t * const motion,              \
-                   mpeg2_mc_fct * const * const table)          \
-{                                          \
-    int motion_x, motion_y;                              \
-    unsigned int pos_x, pos_y, xy_half, offset;                      \
-                                          \
-    motion_x = motion->pmv[0][0];                          \
-    motion_y = motion->pmv[0][1];                          \
-                                          \
-    MOTION (table, motion->ref[0], motion_x, motion_y, 16, 0);              \
-}                                          \
-                                          \
-static void motion_zero_##FORMAT (mpeg2_decoder_t * const decoder,          \
-                  motion_t * const motion,              \
-                  mpeg2_mc_fct * const * const table)          \
-{                                          \
-    unsigned int offset;                              \
-                                          \
-    motion->pmv[0][0] = motion->pmv[0][1] = 0;                      \
-    motion->pmv[1][0] = motion->pmv[1][1] = 0;                      \
-                                          \
-    MOTION_ZERO (table, motion->ref[0]);                      \
-}                                          \
-                                          \
-static void motion_fi_field_##FORMAT (mpeg2_decoder_t * const decoder,          \
-                      motion_t * const motion,              \
-                      mpeg2_mc_fct * const * const table)     \
-{                                          \
-    int motion_x, motion_y;                              \
-    uint8_t ** ref_field;                              \
-    unsigned int pos_x, pos_y, xy_half, offset;                      \
-                                          \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    ref_field = motion->ref2[UBITS (bit_buf, 1)];                  \
-    DUMPBITS (bit_buf, bits, 1);                          \
-                                          \
-    motion_x = motion->pmv[0][0] + get_motion_delta (decoder,              \
-                             motion->f_code[0]);      \
-    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);          \
-    motion->pmv[1][0] = motion->pmv[0][0] = motion_x;                  \
-                                          \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    motion_y = motion->pmv[0][1] + get_motion_delta (decoder,              \
-                             motion->f_code[1]);      \
-    motion_y = bound_motion_vector (motion_y, motion->f_code[1]);          \
-    motion->pmv[1][1] = motion->pmv[0][1] = motion_y;                  \
-                                          \
-    MOTION (table, ref_field, motion_x, motion_y, 16, 0);              \
-}                                          \
-                                          \
-static void motion_fi_16x8_##FORMAT (mpeg2_decoder_t * const decoder,          \
-                     motion_t * const motion,              \
-                     mpeg2_mc_fct * const * const table)      \
-{                                          \
-    int motion_x, motion_y;                              \
-    uint8_t ** ref_field;                              \
-    unsigned int pos_x, pos_y, xy_half, offset;                      \
-                                          \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    ref_field = motion->ref2[UBITS (bit_buf, 1)];                  \
-    DUMPBITS (bit_buf, bits, 1);                          \
-                                          \
-    motion_x = motion->pmv[0][0] + get_motion_delta (decoder,              \
-                             motion->f_code[0]);      \
-    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);          \
-    motion->pmv[0][0] = motion_x;                          \
-                                          \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    motion_y = motion->pmv[0][1] + get_motion_delta (decoder,              \
-                             motion->f_code[1]);      \
-    motion_y = bound_motion_vector (motion_y, motion->f_code[1]);          \
-    motion->pmv[0][1] = motion_y;                          \
-                                          \
-    MOTION (table, ref_field, motion_x, motion_y, 8, 0);              \
-                                          \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    ref_field = motion->ref2[UBITS (bit_buf, 1)];                  \
-    DUMPBITS (bit_buf, bits, 1);                          \
-                                          \
-    motion_x = motion->pmv[1][0] + get_motion_delta (decoder,              \
-                             motion->f_code[0]);      \
-    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);          \
-    motion->pmv[1][0] = motion_x;                          \
-                                          \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    motion_y = motion->pmv[1][1] + get_motion_delta (decoder,              \
-                             motion->f_code[1]);      \
-    motion_y = bound_motion_vector (motion_y, motion->f_code[1]);          \
-    motion->pmv[1][1] = motion_y;                          \
-                                          \
-    MOTION (table, ref_field, motion_x, motion_y, 8, 8);              \
-}                                          \
-                                          \
-static void motion_fi_dmv_##FORMAT (mpeg2_decoder_t * const decoder,          \
-                    motion_t * const motion,              \
-                    mpeg2_mc_fct * const * const table)          \
-{                                          \
-    int motion_x, motion_y, other_x, other_y;                      \
-    unsigned int pos_x, pos_y, xy_half, offset;                      \
-                                          \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    motion_x = motion->pmv[0][0] + get_motion_delta (decoder,              \
-                             motion->f_code[0]);      \
-    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);          \
-    motion->pmv[1][0] = motion->pmv[0][0] = motion_x;                  \
-    NEEDBITS (bit_buf, bits, bit_ptr);                          \
-    other_x = ((motion_x + (motion_x > 0)) >> 1) + get_dmv (decoder);          \
-                                          \
-    motion_y = motion->pmv[0][1] + get_motion_delta (decoder,              \
-                             motion->f_code[1]);      \
-    motion_y = bound_motion_vector (motion_y, motion->f_code[1]);          \
-    motion->pmv[1][1] = motion->pmv[0][1] = motion_y;                  \
-    other_y = (((motion_y + (motion_y > 0)) >> 1) + get_dmv (decoder) +          \
-           decoder->dmv_offset);                          \
-                                          \
-    MOTION (mpeg2_mc.put, motion->ref[0], motion_x, motion_y, 16, 0);          \
-    MOTION (mpeg2_mc.avg, motion->ref[1], other_x, other_y, 16, 0);          \
-}                                          \
+									      \
+    MOTION_DMV (mpeg2_mc.avg, motion->ref[0], motion_x, motion_y);	      \
+}									      \
+									      \
+static void motion_reuse_##FORMAT (mpeg2_decoder_t * const decoder,	      \
+				   motion_t * const motion,		      \
+				   mpeg2_mc_fct * const * const table)	      \
+{									      \
+    int motion_x, motion_y;						      \
+    unsigned int pos_x, pos_y, xy_half, offset;				      \
+									      \
+    motion_x = motion->pmv[0][0];					      \
+    motion_y = motion->pmv[0][1];					      \
+									      \
+    MOTION (table, motion->ref[0], motion_x, motion_y, 16, 0);		      \
+}									      \
+									      \
+static void motion_zero_##FORMAT (mpeg2_decoder_t * const decoder,	      \
+				  motion_t * const motion,		      \
+				  mpeg2_mc_fct * const * const table)	      \
+{									      \
+    unsigned int offset;						      \
+									      \
+    motion->pmv[0][0] = motion->pmv[0][1] = 0;				      \
+    motion->pmv[1][0] = motion->pmv[1][1] = 0;				      \
+									      \
+    MOTION_ZERO (table, motion->ref[0]);				      \
+}									      \
+									      \
+static void motion_fi_field_##FORMAT (mpeg2_decoder_t * const decoder,	      \
+				      motion_t * const motion,		      \
+				      mpeg2_mc_fct * const * const table)     \
+{									      \
+    int motion_x, motion_y;						      \
+    uint8_t ** ref_field;						      \
+    unsigned int pos_x, pos_y, xy_half, offset;				      \
+									      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    ref_field = motion->ref2[UBITS (bit_buf, 1)];			      \
+    DUMPBITS (bit_buf, bits, 1);					      \
+									      \
+    motion_x = motion->pmv[0][0] + get_motion_delta (decoder,		      \
+						     motion->f_code[0]);      \
+    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);	      \
+    motion->pmv[1][0] = motion->pmv[0][0] = motion_x;			      \
+									      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    motion_y = motion->pmv[0][1] + get_motion_delta (decoder,		      \
+						     motion->f_code[1]);      \
+    motion_y = bound_motion_vector (motion_y, motion->f_code[1]);	      \
+    motion->pmv[1][1] = motion->pmv[0][1] = motion_y;			      \
+									      \
+    MOTION (table, ref_field, motion_x, motion_y, 16, 0);		      \
+}									      \
+									      \
+static void motion_fi_16x8_##FORMAT (mpeg2_decoder_t * const decoder,	      \
+				     motion_t * const motion,		      \
+				     mpeg2_mc_fct * const * const table)      \
+{									      \
+    int motion_x, motion_y;						      \
+    uint8_t ** ref_field;						      \
+    unsigned int pos_x, pos_y, xy_half, offset;				      \
+									      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    ref_field = motion->ref2[UBITS (bit_buf, 1)];			      \
+    DUMPBITS (bit_buf, bits, 1);					      \
+									      \
+    motion_x = motion->pmv[0][0] + get_motion_delta (decoder,		      \
+						     motion->f_code[0]);      \
+    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);	      \
+    motion->pmv[0][0] = motion_x;					      \
+									      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    motion_y = motion->pmv[0][1] + get_motion_delta (decoder,		      \
+						     motion->f_code[1]);      \
+    motion_y = bound_motion_vector (motion_y, motion->f_code[1]);	      \
+    motion->pmv[0][1] = motion_y;					      \
+									      \
+    MOTION (table, ref_field, motion_x, motion_y, 8, 0);		      \
+									      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    ref_field = motion->ref2[UBITS (bit_buf, 1)];			      \
+    DUMPBITS (bit_buf, bits, 1);					      \
+									      \
+    motion_x = motion->pmv[1][0] + get_motion_delta (decoder,		      \
+						     motion->f_code[0]);      \
+    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);	      \
+    motion->pmv[1][0] = motion_x;					      \
+									      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    motion_y = motion->pmv[1][1] + get_motion_delta (decoder,		      \
+						     motion->f_code[1]);      \
+    motion_y = bound_motion_vector (motion_y, motion->f_code[1]);	      \
+    motion->pmv[1][1] = motion_y;					      \
+									      \
+    MOTION (table, ref_field, motion_x, motion_y, 8, 8);		      \
+}									      \
+									      \
+static void motion_fi_dmv_##FORMAT (mpeg2_decoder_t * const decoder,	      \
+				    motion_t * const motion,		      \
+				    mpeg2_mc_fct * const * const table)	      \
+{									      \
+    int motion_x, motion_y, other_x, other_y;				      \
+    unsigned int pos_x, pos_y, xy_half, offset;				      \
+									      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    motion_x = motion->pmv[0][0] + get_motion_delta (decoder,		      \
+						     motion->f_code[0]);      \
+    motion_x = bound_motion_vector (motion_x, motion->f_code[0]);	      \
+    motion->pmv[1][0] = motion->pmv[0][0] = motion_x;			      \
+    NEEDBITS (bit_buf, bits, bit_ptr);					      \
+    other_x = ((motion_x + (motion_x > 0)) >> 1) + get_dmv (decoder);	      \
+									      \
+    motion_y = motion->pmv[0][1] + get_motion_delta (decoder,		      \
+						     motion->f_code[1]);      \
+    motion_y = bound_motion_vector (motion_y, motion->f_code[1]);	      \
+    motion->pmv[1][1] = motion->pmv[0][1] = motion_y;			      \
+    other_y = (((motion_y + (motion_y > 0)) >> 1) + get_dmv (decoder) +	      \
+	       decoder->dmv_offset);					      \
+									      \
+    MOTION (mpeg2_mc.put, motion->ref[0], motion_x, motion_y, 16, 0);	      \
+    MOTION (mpeg2_mc.avg, motion->ref[1], other_x, other_y, 16, 0);	      \
+}									      \
 
 MOTION_FUNCTIONS (420, MOTION_420, MOTION_FIELD_420, MOTION_DMV_420,
-          MOTION_ZERO_420)
+		  MOTION_ZERO_420)
 MOTION_FUNCTIONS (422, MOTION_422, MOTION_FIELD_422, MOTION_DMV_422,
-          MOTION_ZERO_422)
+		  MOTION_ZERO_422)
 MOTION_FUNCTIONS (444, MOTION_444, MOTION_FIELD_444, MOTION_DMV_444,
-          MOTION_ZERO_444)
+		  MOTION_ZERO_444)
 
 /* like motion_frame, but parsing without actual motion compensation */
 static void motion_fr_conceal (mpeg2_decoder_t * const decoder)
@@ -692,43 +692,43 @@ static void motion_fi_conceal (mpeg2_decoder_t * const decoder)
 #undef bits
 #undef bit_ptr
 
-#define MOTION_CALL(routine,direction)                \
-do {                                \
-    if ((direction) & MACROBLOCK_MOTION_FORWARD)        \
-    routine (decoder, &(decoder->f_motion), mpeg2_mc.put);    \
-    if ((direction) & MACROBLOCK_MOTION_BACKWARD)        \
-    routine (decoder, &(decoder->b_motion),            \
-         ((direction) & MACROBLOCK_MOTION_FORWARD ?    \
-          mpeg2_mc.avg : mpeg2_mc.put));        \
+#define MOTION_CALL(routine,direction)				\
+do {								\
+    if ((direction) & MACROBLOCK_MOTION_FORWARD)		\
+	routine (decoder, &(decoder->f_motion), mpeg2_mc.put);	\
+    if ((direction) & MACROBLOCK_MOTION_BACKWARD)		\
+	routine (decoder, &(decoder->b_motion),			\
+		 ((direction) & MACROBLOCK_MOTION_FORWARD ?	\
+		  mpeg2_mc.avg : mpeg2_mc.put));		\
 } while (0)
 
-#define NEXT_MACROBLOCK                            \
-do {                                    \
-    decoder->offset += 16;                        \
-    if (decoder->offset == decoder->width) {                \
-    do { /* just so we can use the break statement */        \
-        if (decoder->convert) {                    \
-        decoder->convert (decoder->convert_id, decoder->dest,    \
-                  decoder->v_offset);            \
-        if (decoder->coding_type == B_TYPE)            \
-            break;                        \
-        }                                \
-        decoder->dest[0] += decoder->slice_stride;            \
-        decoder->dest[1] += decoder->slice_uv_stride;        \
-        decoder->dest[2] += decoder->slice_uv_stride;        \
-    } while (0);                            \
-    decoder->v_offset += 16;                    \
-    if (decoder->v_offset > decoder->limit_y) {            \
-        if (mpeg2_cpu_state_restore)                \
-        mpeg2_cpu_state_restore (&cpu_state);            \
-        return;                            \
-    }                                \
-    decoder->offset = 0;                        \
-    }                                    \
+#define NEXT_MACROBLOCK							\
+do {									\
+    decoder->offset += 16;						\
+    if (decoder->offset == decoder->width) {				\
+	do { /* just so we can use the break statement */		\
+	    if (decoder->convert) {					\
+		decoder->convert (decoder->convert_id, decoder->dest,	\
+				  decoder->v_offset);			\
+		if (decoder->coding_type == B_TYPE)			\
+		    break;						\
+	    }								\
+	    decoder->dest[0] += decoder->slice_stride;			\
+	    decoder->dest[1] += decoder->slice_uv_stride;		\
+	    decoder->dest[2] += decoder->slice_uv_stride;		\
+	} while (0);							\
+	decoder->v_offset += 16;					\
+	if (decoder->v_offset > decoder->limit_y) {			\
+	    if (mpeg2_cpu_state_restore)				\
+		mpeg2_cpu_state_restore (&cpu_state);			\
+	    return;							\
+	}								\
+	decoder->offset = 0;						\
+    }									\
 } while (0)
 
 void mpeg2_init_fbuf (mpeg2_decoder_t * decoder, uint8_t * current_fbuf[3],
-              uint8_t * forward_fbuf[3], uint8_t * backward_fbuf[3])
+		      uint8_t * forward_fbuf[3], uint8_t * backward_fbuf[3])
 {
     int offset, stride, height, bottom_field;
 

modules/codec/xvmc/slice_xvmc_vld.c

@@ -105,7 +105,7 @@ void mpeg2_xxmc_slice( mpeg2dec_t *mpeg2dec, picture_t *picture,
         /*
          * Check that first field went through OK. Otherwise,
          * indicate bad frame.
-         */
+         */ 
         if (decoder->second_field)
         {
             mpeg2dec->xvmc_last_slice_code = (xxmc->decoded) ? 0 : -1;
@@ -238,7 +238,7 @@ void mpeg2_xxmc_slice( mpeg2dec_t *mpeg2dec, picture_t *picture,
         if (xxmc->result != 0)
         {
             //xxmc->proc_xxmc_flushsync( picture );
-            xxmc->proc_xxmc_flush( picture );    
+            xxmc->proc_xxmc_flush( picture );	
             mpeg2dec->xvmc_last_slice_code=-1;
             return;
         }
@@ -276,7 +276,7 @@ void mpeg2_xxmc_slice( mpeg2dec_t *mpeg2dec, picture_t *picture,
     }
 }
 
-void mpeg2_xxmc_vld_frame_complete(mpeg2dec_t *mpeg2dec, picture_t *picture, int code)
+void mpeg2_xxmc_vld_frame_complete(mpeg2dec_t *mpeg2dec, picture_t *picture, int code) 
 {
     vlc_xxmc_t *xxmc = (vlc_xxmc_t *) picture->p_data;
     vlc_vld_frame_t *vft = &xxmc->vld_frame;

modules/codec/xvmc/vlc.h

@@ -21,35 +21,35 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#define GETWORD(bit_buf,shift,bit_ptr)                \
-do {                                \
-    bit_buf |= ((bit_ptr[0] << 8) | bit_ptr[1]) << (shift);    \
-    bit_ptr += 2;                        \
+#define GETWORD(bit_buf,shift,bit_ptr)				\
+do {								\
+    bit_buf |= ((bit_ptr[0] << 8) | bit_ptr[1]) << (shift);	\
+    bit_ptr += 2;						\
 } while (0)
 
 static inline void bitstream_init (mpeg2_decoder_t * decoder,
-                   const uint8_t * start)
+				   const uint8_t * start)
 {
     decoder->bitstream_buf =
-    (start[0] << 24) | (start[1] << 16) | (start[2] << 8) | start[3];
+	(start[0] << 24) | (start[1] << 16) | (start[2] << 8) | start[3];
     decoder->bitstream_ptr = start + 4;
     decoder->bitstream_bits = -16;
 }
 
 /* make sure that there are at least 16 valid bits in bit_buf */
-#define NEEDBITS(bit_buf,bits,bit_ptr)        \
-do {                        \
-    if (unlikely (bits > 0)) {            \
-    GETWORD (bit_buf, bits, bit_ptr);    \
-    bits -= 16;                \
-    }                        \
+#define NEEDBITS(bit_buf,bits,bit_ptr)		\
+do {						\
+    if (unlikely (bits > 0)) {			\
+	GETWORD (bit_buf, bits, bit_ptr);	\
+	bits -= 16;				\
+    }						\
 } while (0)
 
 /* remove num valid bits from bit_buf */
-#define DUMPBITS(bit_buf,bits,num)    \
-do {                    \
-    bit_buf <<= (num);            \
-    bits += (num);            \
+#define DUMPBITS(bit_buf,bits,num)	\
+do {					\
+    bit_buf <<= (num);			\
+    bits += (num);			\
 } while (0)
 
 /* take num bits from the high part of bit_buf and zero extend them */

modules/codec/xvmc/xxmc-config.h

@@ -2,7 +2,7 @@
 /* include/config.h.in.  Generated from configure.in by autoheader.  */
 
 /* autodetect accelerations */
-#define ACCEL_DETECT
+#define ACCEL_DETECT 
 
 /* alpha architecture */
 /* #undef ARCH_ALPHA */
@@ -14,7 +14,7 @@
 /* #undef ARCH_SPARC */
 
 /* x86 architecture */
-#define ARCH_X86
+#define ARCH_X86 
 
 /* maximum supported data alignment */
 #define ATTRIBUTE_ALIGNED_MAX 64
@@ -26,7 +26,7 @@
 /* #undef HAVE_ALTIVEC_H */
 
 /* Define if you have the `__builtin_expect' function. */
-#define HAVE_BUILTIN_EXPECT
+#define HAVE_BUILTIN_EXPECT 
 
 /* Define to 1 if you have the <dlfcn.h> header file. */
 #define HAVE_DLFCN_H 1
@@ -86,10 +86,10 @@
 /* #undef LIBVO_SDL */
 
 /* libvo X11 support */
-#define LIBVO_X11
+#define LIBVO_X11 
 
 /* libvo Xv support */
-#define LIBVO_XV
+#define LIBVO_XV 
 
 /* mpeg2dec profiling */
 /* #undef MPEG2DEC_GPROF */

modules/codec/xvmc/xxmc.c

@@ -110,7 +110,7 @@ static int OpenDecoder( vlc_object_t *p_this )
     decoder_t *p_dec = (decoder_t*)p_this;
     decoder_sys_t *p_sys = NULL;
     uint32_t i_accel = 0;
-    FILE *f_wd_dec;
+    FILE *f_wd_dec; 
 
     msg_Dbg(p_dec, "OpenDecoder Entering");
     mtrace();
@@ -695,7 +695,7 @@ static picture_t *GetNewPicture( decoder_t *p_dec, uint8_t **pp_buf )
     {
 //         fprintf(p_sys->f_wd_nb, "%d\n", mdate());
         fprintf(p_sys->f_wd_nb, "%s\n", mdate());
-    fflush(p_sys->f_wd_nb);    
+	fflush(p_sys->f_wd_nb);	
     }
 #endif
     p_pic = p_dec->pf_vout_buffer_new( p_dec );