Fix sequential extraction, and include progress info

[wimlib] / src / write.c

diff --git a/src/write.c b/src/write.c
index 96d6676729aaa307acb4f340326e2ce37de48c2d..61a29962f6916521bc1ca255ccb7b39bc2162cb0 100644 (file)
--- a/src/write.c
+++ b/src/write.c
@@ -382,7 +382,8 @@ int write_wim_resource(struct lookup_table_entry *lte,
        /* Are the compression types the same?  If so, do a raw copy (copy
         * without decompressing and recompressing the data). */
        raw = (wim_resource_compression_type(lte) == out_ctype
-              && out_ctype != WIM_COMPRESSION_TYPE_NONE);
+              && out_ctype != WIM_COMPRESSION_TYPE_NONE
+              && !(flags & WIMLIB_RESOURCE_FLAG_RECOMPRESS));
 
        if (raw) {
                flags |= WIMLIB_RESOURCE_FLAG_RAW;
@@ -649,16 +650,17 @@ static void *compressor_thread_proc(void *arg)
 }
 #endif
 
-static void show_stream_write_progress(u64 *cur_size, u64 *next_size,
-                                      u64 total_size, u64 one_percent,
-                                      unsigned *cur_percent,
-                                      const struct lookup_table_entry *cur_lte)
+void show_stream_op_progress(u64 *cur_size, u64 *next_size,
+                            u64 total_size, u64 one_percent,
+                            unsigned *cur_percent,
+                            const struct lookup_table_entry *cur_lte,
+                            const char *op)
 {
        if (*cur_size >= *next_size) {
                printf("\r%"PRIu64" MiB of %"PRIu64" MiB "
-                      "(uncompressed) written (%u%% done)",
+                      "(uncompressed) %s (%u%% done)",
                       *cur_size >> 20,
-                      total_size >> 20, *cur_percent);
+                      total_size >> 20, op, *cur_percent);
                fflush(stdout);
                *next_size += one_percent;
                (*cur_percent)++;
@@ -666,11 +668,11 @@ static void show_stream_write_progress(u64 *cur_size, u64 *next_size,
        *cur_size += wim_resource_size(cur_lte);
 }
 
-static void finish_stream_write_progress(u64 total_size)
+void finish_stream_op_progress(u64 total_size, const char *op)
 {
        printf("\r%"PRIu64" MiB of %"PRIu64" MiB "
-              "(uncompressed) written (100%% done)\n",
-              total_size >> 20, total_size >> 20);
+              "(uncompressed) %s (100%% done)\n",
+              total_size >> 20, total_size >> 20, op);
        fflush(stdout);
 }
 
@@ -685,20 +687,25 @@ static int write_stream_list_serial(struct list_head *stream_list,
        u64 cur_size = 0;
        u64 next_size = 0;
        unsigned cur_percent = 0;
+       int write_resource_flags = 0;
+
+       if (write_flags & WIMLIB_WRITE_FLAG_RECOMPRESS)
+               write_resource_flags |= WIMLIB_RESOURCE_FLAG_RECOMPRESS;
 
        list_for_each_entry(lte, stream_list, staging_list) {
                if (write_flags & WIMLIB_WRITE_FLAG_SHOW_PROGRESS) {
-                       show_stream_write_progress(&cur_size, &next_size,
-                                                  total_size, one_percent,
-                                                  &cur_percent, lte);
+                       show_stream_op_progress(&cur_size, &next_size,
+                                               total_size, one_percent,
+                                               &cur_percent, lte, "written");
                }
                ret = write_wim_resource(lte, out_fp, out_ctype,
-                                        &lte->output_resource_entry, 0);
+                                        &lte->output_resource_entry,
+                                        write_resource_flags);
                if (ret != 0)
                        return ret;
        }
        if (write_flags & WIMLIB_WRITE_FLAG_SHOW_PROGRESS)
-               finish_stream_write_progress(total_size);
+               finish_stream_op_progress(total_size, "written");
        return 0;
 }
 
@@ -748,7 +755,6 @@ static int main_writer_thread_proc(struct list_head *stream_list,
 {
        int ret;
 
-
        struct message msgs[queue_size];
        ZERO_ARRAY(msgs);
 
@@ -942,8 +948,9 @@ static int main_writer_thread_proc(struct list_head *stream_list,
                                                        struct lookup_table_entry,
                                                        staging_list);
                                next_resource = next_resource->next;
-                               if ((next_lte->resource_location == RESOURCE_IN_WIM
-                                   && wimlib_get_compression_type(next_lte->wim) == out_ctype)
+                               if ((!(write_flags & WIMLIB_WRITE_FLAG_RECOMPRESS)
+                                     && next_lte->resource_location == RESOURCE_IN_WIM
+                                     && wimlib_get_compression_type(next_lte->wim) == out_ctype)
                                    || wim_resource_size(next_lte) == 0)
                                {
                                        list_add_tail(&next_lte->staging_list,
@@ -1004,12 +1011,13 @@ static int main_writer_thread_proc(struct list_head *stream_list,
                        if (msg->begin_chunk == 0) {
                                DEBUG2("Begin chunk tab");
                                if (write_flags & WIMLIB_WRITE_FLAG_SHOW_PROGRESS) {
-                                       show_stream_write_progress(&cur_size,
-                                                                  &next_size,
-                                                                  total_size,
-                                                                  one_percent,
-                                                                  &cur_percent,
-                                                                  cur_lte);
+                                       show_stream_op_progress(&cur_size,
+                                                               &next_size,
+                                                               total_size,
+                                                               one_percent,
+                                                               &cur_percent,
+                                                               cur_lte,
+                                                               "written");
                                }
 
                                // This is the first set of chunks.  Leave space
@@ -1095,12 +1103,13 @@ static int main_writer_thread_proc(struct list_head *stream_list,
                                                         staging_list)
                                {
                                        if (write_flags & WIMLIB_WRITE_FLAG_SHOW_PROGRESS) {
-                                               show_stream_write_progress(&cur_size,
-                                                                          &next_size,
-                                                                          total_size,
-                                                                          one_percent,
-                                                                          &cur_percent,
-                                                                          lte);
+                                               show_stream_op_progress(&cur_size,
+                                                                       &next_size,
+                                                                       total_size,
+                                                                       one_percent,
+                                                                       &cur_percent,
+                                                                       lte,
+                                                                       "written");
                                        }
 
                                        ret = write_wim_resource(lte,
@@ -1125,12 +1134,13 @@ out:
        if (ret == 0) {
                list_for_each_entry(lte, &my_resources, staging_list) {
                        if (write_flags & WIMLIB_WRITE_FLAG_SHOW_PROGRESS) {
-                               show_stream_write_progress(&cur_size,
-                                                          &next_size,
-                                                          total_size,
-                                                          one_percent,
-                                                          &cur_percent,
-                                                          lte);
+                               show_stream_op_progress(&cur_size,
+                                                       &next_size,
+                                                       total_size,
+                                                       one_percent,
+                                                       &cur_percent,
+                                                       lte,
+                                                       "written");
                        }
                        ret = write_wim_resource(lte, out_fp,
                                                 out_ctype,
@@ -1140,7 +1150,7 @@ out:
                                break;
                }
                if (write_flags & WIMLIB_WRITE_FLAG_SHOW_PROGRESS)
-                       finish_stream_write_progress(total_size);
+                       finish_stream_op_progress(total_size, "written");
        } else {
                size_t num_available_msgs = 0;
                struct list_head *cur;
@@ -1238,7 +1248,7 @@ static int write_stream_list_parallel(struct list_head *stream_list,
        }
 
        if (write_flags & WIMLIB_WRITE_FLAG_SHOW_PROGRESS) {
-               printf("Writing %s compressed data using %u threads...\n",
+               printf("Writing %s data using %u threads...\n",
                       get_data_type(out_ctype), num_threads);
        }
 
@@ -1291,9 +1301,11 @@ static int write_stream_list(struct list_head *stream_list, FILE *out_fp,
                num_streams++;
                total_size += wim_resource_size(lte);
                if (!compression_needed
-                   && out_ctype != WIM_COMPRESSION_TYPE_NONE
-                   && (lte->resource_location != RESOURCE_IN_WIM
-                       || wimlib_get_compression_type(lte->wim) != out_ctype)
+                   &&
+                   (out_ctype != WIM_COMPRESSION_TYPE_NONE
+                      && (lte->resource_location != RESOURCE_IN_WIM
+                          || wimlib_get_compression_type(lte->wim) != out_ctype
+                          || (write_flags & WIMLIB_WRITE_FLAG_REBUILD)))
                    && wim_resource_size(lte) != 0)
                        compression_needed = true;
        }
@@ -1740,9 +1752,9 @@ static int overwrite_wim_inplace(WIMStruct *w, int write_flags,
        if (ret != 0)
                return ret;
 
-       if (modified_image_idx == w->hdr.image_count) {
-               /* If no images are modified, a new lookup table does not need
-                * to be written. */
+       if (modified_image_idx == w->hdr.image_count && !w->deletion_occurred) {
+               /* If no images have been modified and no images have been
+                * deleted, a new lookup table does not need to be written. */
                wimlib_assert(list_empty(&stream_list));
                old_wim_end = w->hdr.lookup_table_res_entry.offset +
                              w->hdr.lookup_table_res_entry.size;
@@ -1871,7 +1883,9 @@ WIMLIBAPI int wimlib_overwrite(WIMStruct *w, int write_flags,
                return WIMLIB_ERR_SPLIT_UNSUPPORTED;
        }
 
-       if (!w->deletion_occurred && !(write_flags & WIMLIB_WRITE_FLAG_REBUILD)) {
+       if ((!w->deletion_occurred || (write_flags & WIMLIB_WRITE_FLAG_SOFT_DELETE))
+           && !(write_flags & WIMLIB_WRITE_FLAG_REBUILD))
+       {
                int i, modified_image_idx;
                for (i = 0; i < w->hdr.image_count && !w->image_metadata[i].modified; i++)
                        ;