+ ret = fflush(fp);
+ if (ret != 0) {
+ ERROR_WITH_ERRNO("Failed to flush data to output WIM file");
+ return WIMLIB_ERR_WRITE;
+ }
+ ret = ftruncate(fileno(fp), size);
+ if (ret != 0) {
+ ERROR_WITH_ERRNO("Failed to truncate output WIM file to "
+ "%"PRIu64" bytes", size);
+ return WIMLIB_ERR_WRITE;
+ }
+ return 0;
+}
+
+/* Chunk table that's located at the beginning of each compressed resource in
+ * the WIM. (This is not the on-disk format; the on-disk format just has an
+ * array of offsets.) */
+struct chunk_table {
+ off_t file_offset;
+ u64 num_chunks;
+ u64 original_resource_size;
+ u64 bytes_per_chunk_entry;
+ u64 table_disk_size;
+ u64 cur_offset;
+ u64 *cur_offset_p;
+ u64 offsets[0];
+};
+
+/*
+ * Allocates and initializes a chunk table, and reserves space for it in the
+ * output file.
+ */
+static int
+begin_wim_resource_chunk_tab(const struct wim_lookup_table_entry *lte,
+ FILE *out_fp,
+ off_t file_offset,
+ struct chunk_table **chunk_tab_ret)
+{
+ u64 size = wim_resource_size(lte);
+ u64 num_chunks = (size + WIM_CHUNK_SIZE - 1) / WIM_CHUNK_SIZE;
+ size_t alloc_size = sizeof(struct chunk_table) + num_chunks * sizeof(u64);
+ struct chunk_table *chunk_tab = CALLOC(1, alloc_size);
+ int ret;
+
+ if (!chunk_tab) {
+ ERROR("Failed to allocate chunk table for %"PRIu64" byte "
+ "resource", size);
+ ret = WIMLIB_ERR_NOMEM;
+ goto out;
+ }
+ chunk_tab->file_offset = file_offset;
+ chunk_tab->num_chunks = num_chunks;
+ chunk_tab->original_resource_size = size;
+ chunk_tab->bytes_per_chunk_entry = (size >= (1ULL << 32)) ? 8 : 4;
+ chunk_tab->table_disk_size = chunk_tab->bytes_per_chunk_entry *
+ (num_chunks - 1);
+ chunk_tab->cur_offset = 0;
+ chunk_tab->cur_offset_p = chunk_tab->offsets;
+
+ if (fwrite(chunk_tab, 1, chunk_tab->table_disk_size, out_fp) !=
+ chunk_tab->table_disk_size) {
+ ERROR_WITH_ERRNO("Failed to write chunk table in compressed "
+ "file resource");
+ ret = WIMLIB_ERR_WRITE;
+ goto out;
+ }
+
+ ret = 0;
+out:
+ *chunk_tab_ret = chunk_tab;
+ return ret;
+}
+
+/*
+ * compress_func_t- Pointer to a function to compresses a chunk
+ * of a WIM resource. This may be either xpress_compress()
+ * (xpress-compress.c) or lzx_compress() (lzx-compress.c).
+ *
+ * @chunk: Uncompressed data of the chunk.
+ * @chunk_size: Size of the uncompressed chunk, in bytes.
+ * @out: Pointer to output buffer of size at least (@chunk_size - 1) bytes.
+ *
+ * Returns the size of the compressed data written to @out in bytes, or 0 if the
+ * data could not be compressed to (@chunk_size - 1) bytes or fewer.
+ *
+ * As a special requirement, the compression code is optimized for the WIM
+ * format and therefore requires (@chunk_size <= 32768).
+ *
+ * As another special requirement, the compression code will read up to 8 bytes
+ * off the end of the @chunk array for performance reasons. The values of these
+ * bytes will not affect the output of the compression, but the calling code
+ * must make sure that the buffer holding the uncompressed chunk is actually at
+ * least (@chunk_size + 8) bytes, or at least that these extra bytes are in
+ * mapped memory that will not cause a memory access violation if accessed.
+ */
+typedef unsigned (*compress_func_t)(const void *chunk, unsigned chunk_size,
+ void *out);
+
+compress_func_t
+get_compress_func(int out_ctype)
+{
+ if (out_ctype == WIMLIB_COMPRESSION_TYPE_LZX)
+ return lzx_compress;
+ else
+ return xpress_compress;
+}
+
+/*
+ * Writes a chunk of a WIM resource to an output file.
+ *
+ * @chunk: Uncompressed data of the chunk.
+ * @chunk_size: Size of the chunk (<= WIM_CHUNK_SIZE)
+ * @out_fp: FILE * to write tho chunk to.
+ * @out_ctype: Compression type to use when writing the chunk (ignored if no
+ * chunk table provided)
+ * @chunk_tab: Pointer to chunk table being created. It is updated with the
+ * offset of the chunk we write.
+ *
+ * Returns 0 on success; nonzero on failure.
+ */
+static int
+write_wim_resource_chunk(const u8 chunk[], unsigned chunk_size,
+ FILE *out_fp, compress_func_t compress,
+ struct chunk_table *chunk_tab)
+{
+ const u8 *out_chunk;
+ unsigned out_chunk_size;
+ if (chunk_tab) {
+ u8 *compressed_chunk = alloca(chunk_size);
+
+ out_chunk_size = compress(chunk, chunk_size, compressed_chunk);
+ if (out_chunk_size) {
+ /* Write compressed */
+ out_chunk = compressed_chunk;
+ } else {
+ /* Write uncompressed */
+ out_chunk = chunk;
+ out_chunk_size = chunk_size;
+ }
+ *chunk_tab->cur_offset_p++ = chunk_tab->cur_offset;
+ chunk_tab->cur_offset += out_chunk_size;
+ } else {
+ /* Write uncompressed */
+ out_chunk = chunk;
+ out_chunk_size = chunk_size;
+ }
+ if (fwrite(out_chunk, 1, out_chunk_size, out_fp) != out_chunk_size) {
+ ERROR_WITH_ERRNO("Failed to write WIM resource chunk");
+ return WIMLIB_ERR_WRITE;
+ }
+ return 0;
+}
+
+/*
+ * Finishes a WIM chunk table and writes it to the output file at the correct
+ * offset.
+ *
+ * The final size of the full compressed resource is returned in the
+ * @compressed_size_p.
+ */
+static int
+finish_wim_resource_chunk_tab(struct chunk_table *chunk_tab,
+ FILE *out_fp, u64 *compressed_size_p)
+{
+ size_t bytes_written;
+ if (fseeko(out_fp, chunk_tab->file_offset, SEEK_SET) != 0) {
+ ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" of output "
+ "WIM file", chunk_tab->file_offset);
+ return WIMLIB_ERR_WRITE;
+ }
+
+ if (chunk_tab->bytes_per_chunk_entry == 8) {
+ array_cpu_to_le64(chunk_tab->offsets, chunk_tab->num_chunks);
+ } else {
+ for (u64 i = 0; i < chunk_tab->num_chunks; i++)
+ ((u32*)chunk_tab->offsets)[i] =
+ cpu_to_le32(chunk_tab->offsets[i]);
+ }
+ bytes_written = fwrite((u8*)chunk_tab->offsets +
+ chunk_tab->bytes_per_chunk_entry,
+ 1, chunk_tab->table_disk_size, out_fp);
+ if (bytes_written != chunk_tab->table_disk_size) {
+ ERROR_WITH_ERRNO("Failed to write chunk table in compressed "
+ "file resource");
+ return WIMLIB_ERR_WRITE;
+ }
+ if (fseeko(out_fp, 0, SEEK_END) != 0) {
+ ERROR_WITH_ERRNO("Failed to seek to end of output WIM file");
+ return WIMLIB_ERR_WRITE;
+ }
+ *compressed_size_p = chunk_tab->cur_offset + chunk_tab->table_disk_size;
+ return 0;
+}
+
+/* Prepare for multiple reads to a resource by caching a FILE * or NTFS
+ * attribute pointer in the lookup table entry. */
+static int
+prepare_resource_for_read(struct wim_lookup_table_entry *lte
+
+ #ifdef WITH_NTFS_3G
+ , ntfs_inode **ni_ret
+ #endif
+ )
+{
+ switch (lte->resource_location) {
+ case RESOURCE_IN_FILE_ON_DISK:
+ if (!lte->file_on_disk_fp) {
+ lte->file_on_disk_fp = tfopen(lte->file_on_disk, T("rb"));
+ if (!lte->file_on_disk_fp) {
+ ERROR_WITH_ERRNO("Failed to open the file "
+ "`%"TS"'", lte->file_on_disk);
+ return WIMLIB_ERR_OPEN;
+ }
+ }
+ break;
+#ifdef WITH_NTFS_3G
+ case RESOURCE_IN_NTFS_VOLUME:
+ if (!lte->attr) {
+ struct ntfs_location *loc = lte->ntfs_loc;
+ ntfs_inode *ni;
+ wimlib_assert(loc);
+ ni = ntfs_pathname_to_inode(*loc->ntfs_vol_p, NULL, loc->path);
+ if (!ni) {
+ ERROR_WITH_ERRNO("Failed to open inode `%"TS"' in NTFS "
+ "volume", loc->path);
+ return WIMLIB_ERR_NTFS_3G;
+ }
+ lte->attr = ntfs_attr_open(ni,
+ loc->is_reparse_point ? AT_REPARSE_POINT : AT_DATA,
+ loc->stream_name,
+ loc->stream_name_nchars);
+ if (!lte->attr) {
+ ERROR_WITH_ERRNO("Failed to open attribute of `%"TS"' in "
+ "NTFS volume", loc->path);
+ ntfs_inode_close(ni);
+ return WIMLIB_ERR_NTFS_3G;
+ }
+ *ni_ret = ni;
+ }
+ break;
+#endif
+#ifdef __WIN32__
+ case RESOURCE_WIN32:
+ if (lte->win32_file_on_disk_fp == INVALID_HANDLE_VALUE) {
+ lte->win32_file_on_disk_fp =
+ win32_open_file_data_only(lte->file_on_disk);
+ if (lte->win32_file_on_disk_fp == INVALID_HANDLE_VALUE) {
+ ERROR("Win32 API: Can't open %"TS, lte->file_on_disk);
+ win32_error_last();
+ return WIMLIB_ERR_OPEN;
+ }
+ }
+ break;
+#endif
+ default:
+ break;
+ }
+ return 0;
+}
+
+/* Undo prepare_resource_for_read() by closing the cached FILE * or NTFS
+ * attribute. */
+static void
+end_wim_resource_read(struct wim_lookup_table_entry *lte
+ #ifdef WITH_NTFS_3G
+ , ntfs_inode *ni
+ #endif
+ )
+{
+ if (lte->resource_location == RESOURCE_IN_FILE_ON_DISK
+ && lte->file_on_disk_fp)
+ {
+ fclose(lte->file_on_disk_fp);
+ lte->file_on_disk_fp = NULL;
+ }
+#ifdef WITH_NTFS_3G
+ else if (lte->resource_location == RESOURCE_IN_NTFS_VOLUME) {
+ if (lte->attr) {
+ ntfs_attr_close(lte->attr);
+ lte->attr = NULL;
+ }
+ if (ni)
+ ntfs_inode_close(ni);
+ }
+#endif
+#ifdef __WIN32__
+ else if (lte->resource_location == RESOURCE_WIN32
+ && lte->win32_file_on_disk_fp != INVALID_HANDLE_VALUE)
+ {
+ win32_close_file(lte->win32_file_on_disk_fp);
+ lte->win32_file_on_disk_fp = INVALID_HANDLE_VALUE;
+ }
+#endif
+}
+
+static int
+write_uncompressed_resource_and_truncate(struct wim_lookup_table_entry *lte,
+ FILE *out_fp,
+ off_t file_offset,
+ struct resource_entry *out_res_entry)
+{
+ int ret;
+ if (fseeko(out_fp, file_offset, SEEK_SET) != 0) {
+ ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" of "
+ "output WIM file", file_offset);
+ return WIMLIB_ERR_WRITE;
+ }
+ ret = write_wim_resource(lte, out_fp, WIMLIB_COMPRESSION_TYPE_NONE,
+ out_res_entry, 0);
+ if (ret != 0)
+ return ret;
+
+ return fflush_and_ftruncate(out_fp,
+ file_offset + wim_resource_size(lte));
+}
+
+/*
+ * Writes a WIM resource to a FILE * opened for writing. The resource may be
+ * written uncompressed or compressed depending on the @out_ctype parameter.
+ *
+ * If by chance the resource compresses to more than the original size (this may
+ * happen with random data or files than are pre-compressed), the resource is
+ * instead written uncompressed (and this is reflected in the @out_res_entry by
+ * removing the WIM_RESHDR_FLAG_COMPRESSED flag).
+ *
+ * @lte: The lookup table entry for the WIM resource.
+ * @out_fp: The FILE * to write the resource to.
+ * @out_ctype: The compression type of the resource to write. Note: if this is
+ * the same as the compression type of the WIM resource we
+ * need to read, we simply copy the data (i.e. we do not
+ * uncompress it, then compress it again).
+ * @out_res_entry: If non-NULL, a resource entry that is filled in with the
+ * offset, original size, compressed size, and compression flag
+ * of the output resource.
+ *
+ * Returns 0 on success; nonzero on failure.
+ */
+int
+write_wim_resource(struct wim_lookup_table_entry *lte,
+ FILE *out_fp, int out_ctype,
+ struct resource_entry *out_res_entry,
+ int flags)
+{
+ u64 bytes_remaining;
+ u64 original_size;
+ u64 old_compressed_size;
+ u64 new_compressed_size;
+ u64 offset;
+ int ret;
+ struct chunk_table *chunk_tab = NULL;
+ bool raw;
+ off_t file_offset;
+ compress_func_t compress = NULL;
+#ifdef WITH_NTFS_3G
+ ntfs_inode *ni = NULL;
+#endif
+
+ wimlib_assert(lte);
+
+ /* Original size of the resource */
+ original_size = wim_resource_size(lte);
+
+ /* Compressed size of the resource (as it exists now) */
+ old_compressed_size = wim_resource_compressed_size(lte);
+
+ /* Current offset in output file */
+ file_offset = ftello(out_fp);
+ if (file_offset == -1) {
+ ERROR_WITH_ERRNO("Failed to get offset in output "
+ "stream");
+ return WIMLIB_ERR_WRITE;
+ }
+
+ /* 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 != WIMLIB_COMPRESSION_TYPE_NONE
+ && !(flags & WIMLIB_RESOURCE_FLAG_RECOMPRESS));
+
+ if (raw) {
+ flags |= WIMLIB_RESOURCE_FLAG_RAW;
+ bytes_remaining = old_compressed_size;
+ } else {
+ flags &= ~WIMLIB_RESOURCE_FLAG_RAW;
+ bytes_remaining = original_size;
+ }
+
+ /* Empty resource; nothing needs to be done, so just return success. */
+ if (bytes_remaining == 0)
+ return 0;
+
+ /* Buffer for reading chunks for the resource */
+ u8 buf[min(WIM_CHUNK_SIZE, bytes_remaining)];
+
+ /* If we are writing a compressed resource and not doing a raw copy, we
+ * need to initialize the chunk table */
+ if (out_ctype != WIMLIB_COMPRESSION_TYPE_NONE && !raw) {
+ ret = begin_wim_resource_chunk_tab(lte, out_fp, file_offset,
+ &chunk_tab);
+ if (ret != 0)
+ goto out;
+ }
+
+ /* If the WIM resource is in an external file, open a FILE * to it so we
+ * don't have to open a temporary one in read_wim_resource() for each
+ * chunk. */
+#ifdef WITH_NTFS_3G
+ ret = prepare_resource_for_read(lte, &ni);
+#else
+ ret = prepare_resource_for_read(lte);
+#endif
+ if (ret != 0)
+ goto out;
+
+ /* If we aren't doing a raw copy, we will compute the SHA1 message
+ * digest of the resource as we read it, and verify it's the same as the
+ * hash given in the lookup table entry once we've finished reading the
+ * resource. */
+ SHA_CTX ctx;
+ if (!raw) {
+ sha1_init(&ctx);
+ compress = get_compress_func(out_ctype);
+ }
+ offset = 0;
+
+ /* While there are still bytes remaining in the WIM resource, read a
+ * chunk of the resource, update SHA1, then write that chunk using the
+ * desired compression type. */
+ do {
+ u64 to_read = min(bytes_remaining, WIM_CHUNK_SIZE);
+ ret = read_wim_resource(lte, buf, to_read, offset, flags);
+ if (ret != 0)
+ goto out_fclose;
+ if (!raw)
+ sha1_update(&ctx, buf, to_read);
+ ret = write_wim_resource_chunk(buf, to_read, out_fp,
+ compress, chunk_tab);
+ if (ret != 0)
+ goto out_fclose;
+ bytes_remaining -= to_read;
+ offset += to_read;
+ } while (bytes_remaining);
+
+ /* Raw copy: The new compressed size is the same as the old compressed
+ * size
+ *
+ * Using WIMLIB_COMPRESSION_TYPE_NONE: The new compressed size is the
+ * original size
+ *
+ * Using a different compression type: Call
+ * finish_wim_resource_chunk_tab() and it will provide the new
+ * compressed size.
+ */
+ if (raw) {
+ new_compressed_size = old_compressed_size;
+ } else {
+ if (out_ctype == WIMLIB_COMPRESSION_TYPE_NONE)
+ new_compressed_size = original_size;
+ else {
+ ret = finish_wim_resource_chunk_tab(chunk_tab, out_fp,
+ &new_compressed_size);
+ if (ret != 0)
+ goto out_fclose;
+ }
+ }
+
+ /* Verify SHA1 message digest of the resource, unless we are doing a raw
+ * write (in which case we never even saw the uncompressed data). Or,
+ * if the hash we had before is all 0's, just re-set it to be the new
+ * hash. */
+ if (!raw) {
+ u8 md[SHA1_HASH_SIZE];
+ sha1_final(md, &ctx);
+ if (is_zero_hash(lte->hash)) {
+ copy_hash(lte->hash, md);
+ } else if (!hashes_equal(md, lte->hash)) {
+ ERROR("WIM resource has incorrect hash!");
+ if (lte->resource_location == RESOURCE_IN_FILE_ON_DISK) {
+ ERROR("We were reading it from `%"TS"'; maybe "
+ "it changed while we were reading it.",
+ lte->file_on_disk);
+ }
+ ret = WIMLIB_ERR_INVALID_RESOURCE_HASH;
+ goto out_fclose;
+ }
+ }
+
+ if (!raw && new_compressed_size >= original_size &&
+ out_ctype != WIMLIB_COMPRESSION_TYPE_NONE)
+ {
+ /* Oops! We compressed the resource to larger than the original
+ * size. Write the resource uncompressed instead. */
+ ret = write_uncompressed_resource_and_truncate(lte,
+ out_fp,
+ file_offset,
+ out_res_entry);
+ if (ret != 0)
+ goto out_fclose;
+ } else {
+ if (out_res_entry) {
+ out_res_entry->size = new_compressed_size;
+ out_res_entry->original_size = original_size;
+ out_res_entry->offset = file_offset;
+ out_res_entry->flags = lte->resource_entry.flags
+ & ~WIM_RESHDR_FLAG_COMPRESSED;
+ if (out_ctype != WIMLIB_COMPRESSION_TYPE_NONE)
+ out_res_entry->flags |= WIM_RESHDR_FLAG_COMPRESSED;
+ }
+ }
+ ret = 0;
+out_fclose:
+#ifdef WITH_NTFS_3G
+ end_wim_resource_read(lte, ni);
+#else
+ end_wim_resource_read(lte);
+#endif
+out:
+ FREE(chunk_tab);
+ return ret;
+}
+
+#ifdef ENABLE_MULTITHREADED_COMPRESSION
+
+/* Blocking shared queue (solves the producer-consumer problem) */
+struct shared_queue {
+ unsigned size;
+ unsigned front;
+ unsigned back;
+ unsigned filled_slots;
+ void **array;
+ pthread_mutex_t lock;
+ pthread_cond_t msg_avail_cond;
+ pthread_cond_t space_avail_cond;
+};
+
+static int
+shared_queue_init(struct shared_queue *q, unsigned size)
+{
+ wimlib_assert(size != 0);
+ q->array = CALLOC(sizeof(q->array[0]), size);
+ if (!q->array)
+ return WIMLIB_ERR_NOMEM;
+ q->filled_slots = 0;
+ q->front = 0;
+ q->back = size - 1;
+ q->size = size;
+ pthread_mutex_init(&q->lock, NULL);
+ pthread_cond_init(&q->msg_avail_cond, NULL);
+ pthread_cond_init(&q->space_avail_cond, NULL);
+ return 0;
+}
+
+static void
+shared_queue_destroy(struct shared_queue *q)
+{
+ FREE(q->array);
+ pthread_mutex_destroy(&q->lock);
+ pthread_cond_destroy(&q->msg_avail_cond);
+ pthread_cond_destroy(&q->space_avail_cond);
+}
+
+static void
+shared_queue_put(struct shared_queue *q, void *obj)
+{
+ pthread_mutex_lock(&q->lock);
+ while (q->filled_slots == q->size)
+ pthread_cond_wait(&q->space_avail_cond, &q->lock);
+
+ q->back = (q->back + 1) % q->size;
+ q->array[q->back] = obj;
+ q->filled_slots++;
+
+ pthread_cond_broadcast(&q->msg_avail_cond);
+ pthread_mutex_unlock(&q->lock);
+}
+
+static void *
+shared_queue_get(struct shared_queue *q)
+{
+ void *obj;
+
+ pthread_mutex_lock(&q->lock);
+ while (q->filled_slots == 0)
+ pthread_cond_wait(&q->msg_avail_cond, &q->lock);
+
+ obj = q->array[q->front];
+ q->array[q->front] = NULL;
+ q->front = (q->front + 1) % q->size;
+ q->filled_slots--;
+
+ pthread_cond_broadcast(&q->space_avail_cond);
+ pthread_mutex_unlock(&q->lock);
+ return obj;
+}
+
+struct compressor_thread_params {
+ struct shared_queue *res_to_compress_queue;
+ struct shared_queue *compressed_res_queue;
+ compress_func_t compress;
+};
+
+#define MAX_CHUNKS_PER_MSG 2
+
+struct message {
+ struct wim_lookup_table_entry *lte;
+ u8 *uncompressed_chunks[MAX_CHUNKS_PER_MSG];
+ u8 *out_compressed_chunks[MAX_CHUNKS_PER_MSG];
+ u8 *compressed_chunks[MAX_CHUNKS_PER_MSG];
+ unsigned uncompressed_chunk_sizes[MAX_CHUNKS_PER_MSG];
+ unsigned compressed_chunk_sizes[MAX_CHUNKS_PER_MSG];
+ unsigned num_chunks;
+ struct list_head list;
+ bool complete;
+ u64 begin_chunk;
+};
+
+static void
+compress_chunks(struct message *msg, compress_func_t compress)
+{
+ for (unsigned i = 0; i < msg->num_chunks; i++) {
+ DEBUG2("compress chunk %u of %u", i, msg->num_chunks);
+ unsigned len = compress(msg->uncompressed_chunks[i],
+ msg->uncompressed_chunk_sizes[i],
+ msg->compressed_chunks[i]);
+ if (len) {
+ /* To be written compressed */
+ msg->out_compressed_chunks[i] = msg->compressed_chunks[i];
+ msg->compressed_chunk_sizes[i] = len;
+ } else {
+ /* To be written uncompressed */
+ msg->out_compressed_chunks[i] = msg->uncompressed_chunks[i];
+ msg->compressed_chunk_sizes[i] = msg->uncompressed_chunk_sizes[i];
+
+ }
+ }
+}
+
+/* Compressor thread routine. This is a lot simpler than the main thread
+ * routine: just repeatedly get a group of chunks from the
+ * res_to_compress_queue, compress them, and put them in the
+ * compressed_res_queue. A NULL pointer indicates that the thread should stop.
+ * */
+static void *
+compressor_thread_proc(void *arg)
+{
+ struct compressor_thread_params *params = arg;
+ struct shared_queue *res_to_compress_queue = params->res_to_compress_queue;
+ struct shared_queue *compressed_res_queue = params->compressed_res_queue;
+ compress_func_t compress = params->compress;
+ struct message *msg;
+
+ DEBUG("Compressor thread ready");
+ while ((msg = shared_queue_get(res_to_compress_queue)) != NULL) {
+ compress_chunks(msg, compress);
+ shared_queue_put(compressed_res_queue, msg);
+ }
+ DEBUG("Compressor thread terminating");
+ return NULL;
+}
+#endif /* ENABLE_MULTITHREADED_COMPRESSION */
+
+static int
+do_write_stream_list(struct list_head *my_resources,
+ FILE *out_fp,
+ int out_ctype,
+ wimlib_progress_func_t progress_func,
+ union wimlib_progress_info *progress,
+ int write_resource_flags)
+{
+ int ret;
+ struct wim_lookup_table_entry *lte, *tmp;
+
+ list_for_each_entry_safe(lte, tmp, my_resources, staging_list) {
+ ret = write_wim_resource(lte,
+ out_fp,
+ out_ctype,
+ <e->output_resource_entry,
+ write_resource_flags);
+ if (ret != 0)
+ return ret;
+ list_del(<e->staging_list);
+ progress->write_streams.completed_bytes +=
+ wim_resource_size(lte);
+ progress->write_streams.completed_streams++;
+ if (progress_func) {
+ progress_func(WIMLIB_PROGRESS_MSG_WRITE_STREAMS,
+ progress);
+ }
+ }
+ return 0;
+}
+
+static int
+write_stream_list_serial(struct list_head *stream_list,
+ FILE *out_fp,
+ int out_ctype,
+ int write_flags,
+ wimlib_progress_func_t progress_func,
+ union wimlib_progress_info *progress)
+{
+ int write_resource_flags;
+
+ if (write_flags & WIMLIB_WRITE_FLAG_RECOMPRESS)
+ write_resource_flags = WIMLIB_RESOURCE_FLAG_RECOMPRESS;
+ else
+ write_resource_flags = 0;
+ progress->write_streams.num_threads = 1;
+ if (progress_func)
+ progress_func(WIMLIB_PROGRESS_MSG_WRITE_STREAMS, progress);
+ return do_write_stream_list(stream_list, out_fp,
+ out_ctype, progress_func,
+ progress, write_resource_flags);
+}
+
+#ifdef ENABLE_MULTITHREADED_COMPRESSION
+static int
+write_wim_chunks(struct message *msg, FILE *out_fp,
+ struct chunk_table *chunk_tab)
+{
+ for (unsigned i = 0; i < msg->num_chunks; i++) {
+ unsigned chunk_csize = msg->compressed_chunk_sizes[i];
+
+ DEBUG2("Write wim chunk %u of %u (csize = %u)",
+ i, msg->num_chunks, chunk_csize);
+
+ if (fwrite(msg->out_compressed_chunks[i], 1, chunk_csize, out_fp)
+ != chunk_csize)
+ {
+ ERROR_WITH_ERRNO("Failed to write WIM chunk");
+ return WIMLIB_ERR_WRITE;
+ }
+
+ *chunk_tab->cur_offset_p++ = chunk_tab->cur_offset;
+ chunk_tab->cur_offset += chunk_csize;