[svn] Merge of fix for bugs 20341 and 20410.

[wget] / src / progress.c

diff --git a/src/progress.c b/src/progress.c
index 81f71040ceb96fe15e646a7b7f40b596f769fbc3..be841590abee1379139f7cd13e69918cbc68876f 100644 (file)
--- a/src/progress.c
+++ b/src/progress.c
@@ -1,11 +1,11 @@
 /* Download progress.
 /* Download progress.

-   Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 2001-2006 Free Software Foundation, Inc.

 
 This file is part of GNU Wget.
 
 GNU Wget is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 
 This file is part of GNU Wget.
 
 GNU Wget is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or
+the Free Software Foundation; either version 3 of the License, or

 (at your option) any later version.
 
 GNU Wget is distributed in the hope that it will be useful,
 (at your option) any later version.
 
 GNU Wget is distributed in the hope that it will be useful,


@@ -14,8 +14,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License

-along with Wget; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+along with Wget.  If not, see <http://www.gnu.org/licenses/>.

 
 In addition, as a special exception, the Free Software Foundation
 gives permission to link the code of its release of Wget with the
 
 In addition, as a special exception, the Free Software Foundation
 gives permission to link the code of its release of Wget with the


@@ -175,7 +174,7 @@ progress_interactive_p (void *progress)
 }
 
 /* Inform the progress gauge of newly received bytes.  DLTIME is the
 }
 
 /* Inform the progress gauge of newly received bytes.  DLTIME is the

-   time in milliseconds since the beginning of the download.  */
+   time since the beginning of the download.  */

 
 void
 progress_update (void *progress, wgint howmuch, double dltime)
 
 void
 progress_update (void *progress, wgint howmuch, double dltime)


@@ -200,10 +199,12 @@ struct dot_progress {
   wgint total_length;          /* expected total byte count when the
                                   download finishes */
 
   wgint total_length;          /* expected total byte count when the
                                   download finishes */
 

-  int accumulated;
+  int accumulated;             /* number of bytes accumulated after
+                                  the last printed dot */

 
   int rows;                    /* number of rows printed so far */
   int dots;                    /* number of dots printed in this row */
 
   int rows;                    /* number of rows printed so far */
   int dots;                    /* number of dots printed in this row */

+

   double last_timer_value;
 };
 
   double last_timer_value;
 };
 


@@ -219,26 +220,28 @@ dot_create (wgint initial, wgint total)
   if (dp->initial_length)
     {
       int dot_bytes = opt.dot_bytes;
   if (dp->initial_length)
     {
       int dot_bytes = opt.dot_bytes;

-      wgint row_bytes = opt.dot_bytes * opt.dots_in_line;
+      const wgint ROW_BYTES = opt.dot_bytes * opt.dots_in_line;

 
 

-      int remainder = (int) (dp->initial_length % row_bytes);
+      int remainder = dp->initial_length % ROW_BYTES;

       wgint skipped = dp->initial_length - remainder;
 
       if (skipped)
        {
       wgint skipped = dp->initial_length - remainder;
 
       if (skipped)
        {

-         int skipped_k = (int) (skipped / 1024); /* skipped amount in K */
+         wgint skipped_k = skipped / 1024; /* skipped amount in K */

          int skipped_k_len = numdigit (skipped_k);
          int skipped_k_len = numdigit (skipped_k);

-         if (skipped_k_len < 5)
-           skipped_k_len = 5;
+         if (skipped_k_len < 6)
+           skipped_k_len = 6;

 
          /* Align the [ skipping ... ] line with the dots.  To do
             that, insert the number of spaces equal to the number of
             digits in the skipped amount in K.  */
 
          /* Align the [ skipping ... ] line with the dots.  To do
             that, insert the number of spaces equal to the number of
             digits in the skipped amount in K.  */

-         logprintf (LOG_VERBOSE, _("\n%*s[ skipping %dK ]"),
-                    2 + skipped_k_len, "", skipped_k);
+         logprintf (LOG_VERBOSE, _("\n%*s[ skipping %sK ]"),
+                    2 + skipped_k_len, "",
+                    number_to_static_string (skipped_k));

        }
 
        }
 

-      logprintf (LOG_VERBOSE, "\n%5ldK", (long) (skipped / 1024));
+      logprintf (LOG_VERBOSE, "\n%6sK",
+                number_to_static_string (skipped / 1024));

       for (; remainder >= dot_bytes; remainder -= dot_bytes)
        {
          if (dp->dots % opt.dot_spacing == 0)
       for (; remainder >= dot_bytes; remainder -= dot_bytes)
        {
          if (dp->dots % opt.dot_spacing == 0)


@@ -249,28 +252,88 @@ dot_create (wgint initial, wgint total)
       assert (dp->dots < opt.dots_in_line);
 
       dp->accumulated = remainder;
       assert (dp->dots < opt.dots_in_line);
 
       dp->accumulated = remainder;

-      dp->rows = skipped / row_bytes;
+      dp->rows = skipped / ROW_BYTES;

     }
 
   return dp;
 }
 
     }
 
   return dp;
 }
 

-static void
-print_percentage (wgint bytes, wgint expected)
-{
-  /* Round to the floor value in order to gauge how much data *has*
-     been retrieved.  12.8% will round to 12% because the 13% mark has
-     not yet been reached.  100% is only shown when done.  */
-  int percentage = 100.0 * bytes / expected;
-  logprintf (LOG_VERBOSE, "%3d%%", percentage);
-}
+static const char *eta_to_human_short (int, bool);
+
+/* Prints the stats (percentage of completion, speed, ETA) for current
+   row.  DLTIME is the time spent downloading the data in current
+   row.
+
+   #### This function is somewhat uglified by the fact that current
+   row and last row have somewhat different stats requirements.  It
+   might be worthwhile to split it to two different functions.  */

 
 static void
 
 static void

-print_download_speed (struct dot_progress *dp, wgint bytes, double dltime)
+print_row_stats (struct dot_progress *dp, double dltime, bool last)

 {
 {

-  logprintf (LOG_VERBOSE, " %7s",
-            retr_rate (bytes, dltime - dp->last_timer_value));
-  dp->last_timer_value = dltime;
+  const wgint ROW_BYTES = opt.dot_bytes * opt.dots_in_line;
+
+  /* bytes_displayed is the number of bytes indicated to the user by
+     dots printed so far, includes the initially "skipped" amount */
+  wgint bytes_displayed = dp->rows * ROW_BYTES + dp->dots * opt.dot_bytes;
+
+  if (last)
+    /* For last row also count bytes accumulated after last dot */
+    bytes_displayed += dp->accumulated;
+
+  if (dp->total_length)
+    {
+      /* Round to floor value to provide gauge how much data *has*
+        been retrieved.  12.8% will round to 12% because the 13% mark
+        has not yet been reached.  100% is only shown when done.  */
+      int percentage = 100.0 * bytes_displayed / dp->total_length;
+      logprintf (LOG_VERBOSE, "%3d%%", percentage);
+    }
+
+  {
+    static char names[] = {' ', 'K', 'M', 'G'};
+    int units;
+    double rate;
+    wgint bytes_this_row;
+    if (!last)
+      bytes_this_row = ROW_BYTES;
+    else
+      /* For last row also include bytes accumulated after last dot.  */
+      bytes_this_row = dp->dots * opt.dot_bytes + dp->accumulated;
+    /* Don't count the portion of the row belonging to initial_length */
+    if (dp->rows == dp->initial_length / ROW_BYTES)
+      bytes_this_row -= dp->initial_length % ROW_BYTES;
+    rate = calc_rate (bytes_this_row, dltime - dp->last_timer_value, &units);
+    logprintf (LOG_VERBOSE, " %4.*f%c",
+              rate >= 99.95 ? 0 : rate >= 9.995 ? 1 : 2,
+              rate, names[units]);
+    dp->last_timer_value = dltime;
+  }
+
+  if (!last)
+    {
+      /* Display ETA based on average speed.  Inspired by Vladi
+        Belperchinov-Shabanski's "wget-new-percentage" patch.  */
+      if (dp->total_length)
+       {
+         wgint bytes_remaining = dp->total_length - bytes_displayed;
+         /* The quantity downloaded in this download run. */
+         wgint bytes_sofar = bytes_displayed - dp->initial_length;
+         double eta = dltime * bytes_remaining / bytes_sofar;
+         if (eta < INT_MAX - 1)
+           logprintf (LOG_VERBOSE, " %s",
+                      eta_to_human_short ((int) (eta + 0.5), true));
+       }
+    }
+  else
+    {
+      /* When done, print the total download time */
+      if (dltime >= 10)
+       logprintf (LOG_VERBOSE, "=%s",
+                  eta_to_human_short ((int) (dltime + 0.5), true));
+      else
+       logprintf (LOG_VERBOSE, "=%ss", print_decimal (dltime));
+    }

 }
 
 /* Dot-progress backend for progress_update. */
 }
 
 /* Dot-progress backend for progress_update. */


@@ -280,7 +343,7 @@ dot_update (void *progress, wgint howmuch, double dltime)
 {
   struct dot_progress *dp = progress;
   int dot_bytes = opt.dot_bytes;
 {
   struct dot_progress *dp = progress;
   int dot_bytes = opt.dot_bytes;

-  wgint row_bytes = opt.dot_bytes * opt.dots_in_line;
+  wgint ROW_BYTES = opt.dot_bytes * opt.dots_in_line;

 
   log_set_flush (false);
 
 
   log_set_flush (false);
 


@@ -288,7 +351,8 @@ dot_update (void *progress, wgint howmuch, double dltime)
   for (; dp->accumulated >= dot_bytes; dp->accumulated -= dot_bytes)
     {
       if (dp->dots == 0)
   for (; dp->accumulated >= dot_bytes; dp->accumulated -= dot_bytes)
     {
       if (dp->dots == 0)

-       logprintf (LOG_VERBOSE, "\n%5ldK", (long) (dp->rows * row_bytes / 1024));
+       logprintf (LOG_VERBOSE, "\n%6sK",
+                  number_to_static_string (dp->rows * ROW_BYTES / 1024));

 
       if (dp->dots % opt.dot_spacing == 0)
        logputs (LOG_VERBOSE, " ");
 
       if (dp->dots % opt.dot_spacing == 0)
        logputs (LOG_VERBOSE, " ");


@@ -297,16 +361,10 @@ dot_update (void *progress, wgint howmuch, double dltime)
       ++dp->dots;
       if (dp->dots >= opt.dots_in_line)
        {
       ++dp->dots;
       if (dp->dots >= opt.dots_in_line)
        {

-         wgint row_qty = row_bytes;
-         if (dp->rows == dp->initial_length / row_bytes)
-           row_qty -= dp->initial_length % row_bytes;
-

          ++dp->rows;
          dp->dots = 0;
 
          ++dp->rows;
          dp->dots = 0;
 

-         if (dp->total_length)
-           print_percentage (dp->rows * row_bytes, dp->total_length);
-         print_download_speed (dp, row_qty, dltime);
+         print_row_stats (dp, dltime, false);

        }
     }
 
        }
     }
 


@@ -319,35 +377,22 @@ static void
 dot_finish (void *progress, double dltime)
 {
   struct dot_progress *dp = progress;
 dot_finish (void *progress, double dltime)
 {
   struct dot_progress *dp = progress;

-  int dot_bytes = opt.dot_bytes;
-  wgint row_bytes = opt.dot_bytes * opt.dots_in_line;
+  wgint ROW_BYTES = opt.dot_bytes * opt.dots_in_line;

   int i;
 
   log_set_flush (false);
 
   if (dp->dots == 0)
   int i;
 
   log_set_flush (false);
 
   if (dp->dots == 0)

-    logprintf (LOG_VERBOSE, "\n%5ldK", (long) (dp->rows * row_bytes / 1024));
+    logprintf (LOG_VERBOSE, "\n%6sK",
+              number_to_static_string (dp->rows * ROW_BYTES / 1024));

   for (i = dp->dots; i < opt.dots_in_line; i++)
     {
       if (i % opt.dot_spacing == 0)
        logputs (LOG_VERBOSE, " ");
       logputs (LOG_VERBOSE, " ");
     }
   for (i = dp->dots; i < opt.dots_in_line; i++)
     {
       if (i % opt.dot_spacing == 0)
        logputs (LOG_VERBOSE, " ");
       logputs (LOG_VERBOSE, " ");
     }

-  if (dp->total_length)
-    {
-      print_percentage (dp->rows * row_bytes
-                       + dp->dots * dot_bytes
-                       + dp->accumulated,
-                       dp->total_length);
-    }
-
-  {
-    wgint row_qty = dp->dots * dot_bytes + dp->accumulated;
-    if (dp->rows == dp->initial_length / row_bytes)
-      row_qty -= dp->initial_length % row_bytes;
-    print_download_speed (dp, row_qty, dltime);
-  }

 
 

+  print_row_stats (dp, dltime, true);

   logputs (LOG_VERBOSE, "\n\n");
   log_set_flush (false);
 
   logputs (LOG_VERBOSE, "\n\n");
   log_set_flush (false);
 


@@ -432,12 +477,20 @@ static volatile sig_atomic_t received_sigwinch;
    sample is at least 150ms long, which means that, over the course of
    20 samples, "current" download speed spans at least 3s into the
    past.  */
    sample is at least 150ms long, which means that, over the course of
    20 samples, "current" download speed spans at least 3s into the
    past.  */

-#define DLSPEED_SAMPLE_MIN 150
+#define DLSPEED_SAMPLE_MIN 0.15

 
 /* The time after which the download starts to be considered
    "stalled", i.e. the current bandwidth is not printed and the recent
    download speeds are scratched.  */
 
 /* The time after which the download starts to be considered
    "stalled", i.e. the current bandwidth is not printed and the recent
    download speeds are scratched.  */

-#define STALL_START_TIME 5000
+#define STALL_START_TIME 5
+
+/* Time between screen refreshes will not be shorter than this, so
+   that Wget doesn't swamp the TTY with output.  */
+#define REFRESH_INTERVAL 0.2
+
+/* Don't refresh the ETA too often to avoid jerkiness in predictions.
+   This allows ETA to change approximately once per second.  */
+#define ETA_REFRESH_INTERVAL 0.99

 
 struct bar_progress {
   wgint initial_length;                /* how many bytes have been downloaded
 
 struct bar_progress {
   wgint initial_length;                /* how many bytes have been downloaded


@@ -467,12 +520,12 @@ struct bar_progress {
      details.  */
   struct bar_progress_hist {
     int pos;
      details.  */
   struct bar_progress_hist {
     int pos;

-    wgint times[DLSPEED_HISTORY_SIZE];
+    double times[DLSPEED_HISTORY_SIZE];

     wgint bytes[DLSPEED_HISTORY_SIZE];
 
     /* The sum of times and bytes respectively, maintained for
        efficiency. */
     wgint bytes[DLSPEED_HISTORY_SIZE];
 
     /* The sum of times and bytes respectively, maintained for
        efficiency. */

-    wgint total_time;
+    double total_time;

     wgint total_bytes;
   } hist;
 
     wgint total_bytes;
   } hist;
 


@@ -572,7 +625,7 @@ bar_update (void *progress, wgint howmuch, double dltime)
       received_sigwinch = 0;
     }
 
       received_sigwinch = 0;
     }
 

-  if (dltime - bp->last_screen_update < 200 && !force_screen_update)
+  if (dltime - bp->last_screen_update < REFRESH_INTERVAL && !force_screen_update)

     /* Don't update more often than five times per second. */
     return;
 
     /* Don't update more often than five times per second. */
     return;
 


@@ -662,7 +715,7 @@ update_speed_ring (struct bar_progress *bp, wgint howmuch, double dltime)
         value because the current bandwidth would start too small.
         Start with an arbitrary (but more reasonable) time value and
         let it level out.  */
         value because the current bandwidth would start too small.
         Start with an arbitrary (but more reasonable) time value and
         let it level out.  */

-      recent_age = 1000;
+      recent_age = 1;

     }
 
   /* Store "recent" bytes and download time to history ring at the
     }
 
   /* Store "recent" bytes and download time to history ring at the


@@ -697,14 +750,18 @@ update_speed_ring (struct bar_progress *bp, wgint howmuch, double dltime)
        sumt += hist->times[i];
        sumb += hist->bytes[i];
       }
        sumt += hist->times[i];
        sumb += hist->bytes[i];
       }

-    assert (sumt == hist->total_time);

     assert (sumb == hist->total_bytes);
     assert (sumb == hist->total_bytes);

+    /* We can't use assert(sumt==hist->total_time) because some
+       precision is lost by adding and subtracting floating-point
+       numbers.  But during a download this precision should not be
+       detectable, i.e. no larger than 1ns.  */
+    double diff = sumt - hist->total_time;
+    if (diff < 0) diff = -diff;
+    assert (diff < 1e-9);

   }
 #endif
 }
 
   }
 #endif
 }
 

-static const char *eta_to_human_short (int);
-

 #define APPEND_LITERAL(s) do {                 \
   memcpy (p, s, sizeof (s) - 1);               \
   p += sizeof (s) - 1;                         \
 #define APPEND_LITERAL(s) do {                 \
   memcpy (p, s, sizeof (s) - 1);               \
   p += sizeof (s) - 1;                         \


@@ -743,13 +800,13 @@ create_image (struct bar_progress *bp, double dl_total_time, bool done)
      "xx% " or "100%"  - percentage               - 4 chars
      "[]"              - progress bar decorations - 2 chars
      " nnn,nnn,nnn"    - downloaded bytes         - 12 chars or very rarely more
      "xx% " or "100%"  - percentage               - 4 chars
      "[]"              - progress bar decorations - 2 chars
      " nnn,nnn,nnn"    - downloaded bytes         - 12 chars or very rarely more

-     " 1012.56K/s"     - dl rate                  - 11 chars
+     " 12.5K/s"        - download rate             - 8 chars

      "  eta 36m 51s"   - ETA                      - 13 chars
 
      "=====>..."       - progress bar             - the rest
   */
   int dlbytes_size = 1 + MAX (size_grouped_len, 11);
      "  eta 36m 51s"   - ETA                      - 13 chars
 
      "=====>..."       - progress bar             - the rest
   */
   int dlbytes_size = 1 + MAX (size_grouped_len, 11);

-  int progress_size = bp->width - (4 + 2 + dlbytes_size + 11 + 13);
+  int progress_size = bp->width - (4 + 2 + dlbytes_size + 8 + 13);

 
   if (progress_size < 5)
     progress_size = 0;
 
   if (progress_size < 5)
     progress_size = 0;


@@ -834,8 +891,8 @@ create_image (struct bar_progress *bp, double dl_total_time, bool done)
   sprintf (p, " %-11s", size_grouped);
   move_to_end (p);
 
   sprintf (p, " %-11s", size_grouped);
   move_to_end (p);
 

-  /* " 1012.45K/s" */
-  if (hist->total_time && hist->total_bytes)
+  /* " 12.52K/s" */
+  if (hist->total_time > 0 && hist->total_bytes)

     {
       static const char *short_units[] = { "B/s", "K/s", "M/s", "G/s" };
       int units = 0;
     {
       static const char *short_units[] = { "B/s", "K/s", "M/s", "G/s" };
       int units = 0;


@@ -844,18 +901,19 @@ create_image (struct bar_progress *bp, double dl_total_time, bool done)
       wgint dlquant = hist->total_bytes + bp->recent_bytes;
       double dltime = hist->total_time + (dl_total_time - bp->recent_start);
       double dlspeed = calc_rate (dlquant, dltime, &units);
       wgint dlquant = hist->total_bytes + bp->recent_bytes;
       double dltime = hist->total_time + (dl_total_time - bp->recent_start);
       double dlspeed = calc_rate (dlquant, dltime, &units);

-      sprintf (p, " %7.2f%s", dlspeed, short_units[units]);
+      sprintf (p, " %4.*f%s", dlspeed >= 99.95 ? 0 : dlspeed >= 9.995 ? 1 : 2,
+              dlspeed, short_units[units]);

       move_to_end (p);
     }
   else
       move_to_end (p);
     }
   else

-    APPEND_LITERAL ("   --.--K/s");
+    APPEND_LITERAL (" --.-K/s");

 
   if (!done)
     {
       /* "  eta ..m ..s"; wait for three seconds before displaying the ETA.
         That's because the ETA value needs a while to become
         reliable.  */
 
   if (!done)
     {
       /* "  eta ..m ..s"; wait for three seconds before displaying the ETA.
         That's because the ETA value needs a while to become
         reliable.  */

-      if (bp->total_length > 0 && bp->count > 0 && dl_total_time > 3000)
+      if (bp->total_length > 0 && bp->count > 0 && dl_total_time > 3)

        {
          int eta;
 
        {
          int eta;
 


@@ -864,7 +922,7 @@ create_image (struct bar_progress *bp, double dl_total_time, bool done)
             any value to the user. */
          if (bp->total_length != size
              && bp->last_eta_value != 0
             any value to the user. */
          if (bp->total_length != size
              && bp->last_eta_value != 0

-             && dl_total_time - bp->last_eta_time < 900)
+             && dl_total_time - bp->last_eta_time < ETA_REFRESH_INTERVAL)

            eta = bp->last_eta_value;
          else
            {
            eta = bp->last_eta_value;
          else
            {


@@ -874,41 +932,38 @@ create_image (struct bar_progress *bp, double dl_total_time, bool done)
                 hist->total_time and bp->count with hist->total_bytes.
                 I found that doing that results in a very jerky and
                 ultimately unreliable ETA.  */
                 hist->total_time and bp->count with hist->total_bytes.
                 I found that doing that results in a very jerky and
                 ultimately unreliable ETA.  */

-             double time_sofar = (double) dl_total_time / 1000;

              wgint bytes_remaining = bp->total_length - size;
              wgint bytes_remaining = bp->total_length - size;

-             eta = (int) (time_sofar * bytes_remaining / bp->count + 0.5);
+             double eta_ = dl_total_time * bytes_remaining / bp->count;
+             if (eta_ >= INT_MAX - 1)
+               goto skip_eta;
+             eta = (int) (eta_ + 0.5);

              bp->last_eta_value = eta;
              bp->last_eta_time = dl_total_time;
            }
 
          /* Translation note: "ETA" is English-centric, but this must
             be short, ideally 3 chars.  Abbreviate if necessary.  */
              bp->last_eta_value = eta;
              bp->last_eta_time = dl_total_time;
            }
 
          /* Translation note: "ETA" is English-centric, but this must
             be short, ideally 3 chars.  Abbreviate if necessary.  */

-         sprintf (p, _("  eta %s"), eta_to_human_short (eta));
+         sprintf (p, _("  eta %s"), eta_to_human_short (eta, false));

          move_to_end (p);
        }
       else if (bp->total_length > 0)
        {
          move_to_end (p);
        }
       else if (bp->total_length > 0)
        {

+       skip_eta:

          APPEND_LITERAL ("             ");
        }
     }
   else
     {
       /* When the download is done, print the elapsed time.  */
          APPEND_LITERAL ("             ");
        }
     }
   else
     {
       /* When the download is done, print the elapsed time.  */

-      double secs = dl_total_time / 1000;
+

       /* Note to translators: this should not take up more room than
         available here.  Abbreviate if necessary.  */
       strcpy (p, _("   in "));
       move_to_end (p);         /* not p+=6, think translations! */
       /* Note to translators: this should not take up more room than
         available here.  Abbreviate if necessary.  */
       strcpy (p, _("   in "));
       move_to_end (p);         /* not p+=6, think translations! */

-      if (secs >= 10)
-       strcpy (p, eta_to_human_short ((int) (secs + 0.5)));
+      if (dl_total_time >= 10)
+       strcpy (p, eta_to_human_short ((int) (dl_total_time + 0.5), false));

       else
       else

-       /* For very quick downloads show more exact timing information. */
-       sprintf (p, "%.*fs",
-                secs < 0.001 ? 0 : /* 0s instead of 0.000s */
-                secs < 0.01 ? 3 :  /* 0.00x */
-                secs < 0.1 ? 2 :   /* 0.0x */
-                1,                 /* 0.x, 1.x, ..., 9.x */
-                secs);
+       sprintf (p, "%ss", print_decimal (dl_total_time));

       move_to_end (p);
     }
 
       move_to_end (p);
     }
 


@@ -983,18 +1038,20 @@ progress_handle_sigwinch (int sig)
    and hours are shown.  This ensures brevity while still displaying
    as much as possible.
 
    and hours are shown.  This ensures brevity while still displaying
    as much as possible.
 

-   If SEP is false, the separator between minutes and seconds (and
-   hours and minutes, etc.) is not included, shortening the display by
-   one additional character.  This is used for dot progress.
+   If CONDENSED is true, the separator between minutes and seconds
+   (and hours and minutes, etc.) is not included, shortening the
+   display by one additional character.  This is used for dot
+   progress.

 
    The display never occupies more than 7 characters of screen
    space.  */
 
 static const char *
 
    The display never occupies more than 7 characters of screen
    space.  */
 
 static const char *

-eta_to_human_short (int secs)
+eta_to_human_short (int secs, bool condensed)

 {
   static char buf[10];         /* 8 should be enough, but just in case */
   static int last = -1;
 {
   static char buf[10];         /* 8 should be enough, but just in case */
   static int last = -1;

+  const char *space = condensed ? "" : " ";

 
   /* Trivial optimization.  create_image can call us every 200 msecs
      (see bar_update) for fast downloads, but ETA will only change
 
   /* Trivial optimization.  create_image can call us every 200 msecs
      (see bar_update) for fast downloads, but ETA will only change


@@ -1006,11 +1063,11 @@ eta_to_human_short (int secs)
   if (secs < 100)
     sprintf (buf, "%ds", secs);
   else if (secs < 100 * 60)
   if (secs < 100)
     sprintf (buf, "%ds", secs);
   else if (secs < 100 * 60)

-    sprintf (buf, "%dm %ds", secs / 60, secs % 60);
-  else if (secs < 100 * 3600)
-    sprintf (buf, "%dh %dm", secs / 3600, (secs / 60) % 60);
+    sprintf (buf, "%dm%s%ds", secs / 60, space, secs % 60);
+  else if (secs < 48 * 3600)
+    sprintf (buf, "%dh%s%dm", secs / 3600, space, (secs / 60) % 60);

   else if (secs < 100 * 86400)
   else if (secs < 100 * 86400)

-    sprintf (buf, "%dd %dh", secs / 86400, (secs / 3600) % 60);
+    sprintf (buf, "%dd%s%dh", secs / 86400, space, (secs / 3600) % 60);

   else
     /* even (2^31-1)/86400 doesn't overflow BUF. */
     sprintf (buf, "%dd", secs / 86400);
   else
     /* even (2^31-1)/86400 doesn't overflow BUF. */
     sprintf (buf, "%dd", secs / 86400);