# define INVALID_HANDLE_VALUE ((HANDLE)(-1))
#endif
-#if TCHAR_IS_UTF16LE
-# include <wchar.h>
-#endif
-
static int
fflush_and_ftruncate(FILE *fp, off_t size)
{
}
/*
- * Pointer to function to compresses a chunk of a WIM resource.
+ * 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.
*
- * @chunk: Uncompressed data of the chunk.
- * @chunk_size: Size of the uncompressed chunk in bytes.
- * @compressed_chunk: Pointer to output buffer of size at least
- * (@chunk_size - 1) bytes.
- * @compressed_chunk_len_ret: Pointer to an unsigned int into which the size
- * of the compressed chunk will be
- * returned.
+ * As a special requirement, the compression code is optimized for the WIM
+ * format and therefore requires (@chunk_size <= 32768).
*
- * Returns zero if compressed succeeded, and nonzero if the chunk could not be
- * compressed to any smaller than @chunk_size. This function cannot fail for
- * any other reasons.
+ * 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 int (*compress_func_t)(const void *, unsigned, void *, unsigned *);
+typedef unsigned (*compress_func_t)(const void *chunk, unsigned chunk_size,
+ void *out);
compress_func_t
get_compress_func(int out_ctype)
unsigned out_chunk_size;
if (chunk_tab) {
u8 *compressed_chunk = alloca(chunk_size);
- int ret;
- ret = compress(chunk, chunk_size, compressed_chunk,
- &out_chunk_size);
- if (ret == 0) {
+ 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;
}
} 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 `%s'; maybe it changed "
- "while we were reading it.",
+ 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;
{
for (unsigned i = 0; i < msg->num_chunks; i++) {
DEBUG2("compress chunk %u of %u", i, msg->num_chunks);
- int ret = compress(msg->uncompressed_chunks[i],
- msg->uncompressed_chunk_sizes[i],
- msg->compressed_chunks[i],
- &msg->compressed_chunk_sizes[i]);
- if (ret == 0) {
+ 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];
+
}
}
}
}
#endif /* ENABLE_MULTITHREADED_COMPRESSION */
+static void
+do_write_streams_progress(union wimlib_progress_info *progress,
+ wimlib_progress_func_t progress_func,
+ uint64_t size_added)
+{
+ progress->write_streams.completed_bytes += size_added;
+ progress->write_streams.completed_streams++;
+ if (progress_func &&
+ progress->write_streams.completed_bytes >= progress->write_streams._private)
+ {
+ progress_func(WIMLIB_PROGRESS_MSG_WRITE_STREAMS,
+ progress);
+ if (progress->write_streams._private == progress->write_streams.total_bytes) {
+ progress->write_streams._private = ~0;
+ } else {
+ progress->write_streams._private =
+ min(progress->write_streams.total_bytes,
+ progress->write_streams.completed_bytes +
+ progress->write_streams.total_bytes / 100);
+ }
+ }
+}
+
static int
do_write_stream_list(struct list_head *my_resources,
FILE *out_fp,
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);
- }
+
+ do_write_streams_progress(progress,
+ progress_func,
+ wim_resource_size(lte));
}
return 0;
}
WIM_RESHDR_FLAG_COMPRESSED;
}
- progress->write_streams.completed_bytes +=
- wim_resource_size(cur_lte);
- progress->write_streams.completed_streams++;
-
- if (progress_func) {
- progress_func(WIMLIB_PROGRESS_MSG_WRITE_STREAMS,
- progress);
- }
+ do_write_streams_progress(progress, progress_func,
+ wim_resource_size(cur_lte));
FREE(cur_chunk_tab);
cur_chunk_tab = NULL;
progress.write_streams.completed_streams = 0;
progress.write_streams.num_threads = num_threads;
progress.write_streams.compression_type = out_ctype;
+ progress.write_streams._private = 0;
#ifdef ENABLE_MULTITHREADED_COMPRESSION
if (total_compression_bytes >= 1000000 && num_threads != 1)
lte->out_refcnt = lte->refcnt;
memcpy(<e->output_resource_entry, <e->resource_entry,
sizeof(struct resource_entry));
- if (!(lte->resource_entry.flags & WIM_RESHDR_FLAG_METADATA)) {
- wimlib_assert(lte->resource_location != RESOURCE_NONEXISTENT);
+ if (!(lte->resource_entry.flags & WIM_RESHDR_FLAG_METADATA))
if (lte->resource_location != RESOURCE_IN_WIM || lte->wim != args->wim)
list_add(<e->staging_list, args->stream_list);
- }
return 0;
}
static int
-wim_find_new_streams(WIMStruct *wim, off_t end_offset,
- struct list_head *stream_list)
+wim_prepare_streams(WIMStruct *wim, off_t end_offset,
+ struct list_head *stream_list)
{
struct lte_overwrite_prepare_args args = {
.wim = wim,
.end_offset = end_offset,
.stream_list = stream_list,
};
+ int ret;
+ for (int i = 0; i < wim->hdr.image_count; i++) {
+ ret = lte_overwrite_prepare(wim->image_metadata[i].metadata_lte,
+ &args);
+ if (ret)
+ return ret;
+ }
return for_lookup_table_entry(wim->lookup_table,
lte_overwrite_prepare, &args);
}
memcpy(&hdr, &w->hdr, sizeof(struct wim_header));
if (!(write_flags & WIMLIB_WRITE_FLAG_NO_LOOKUP_TABLE)) {
- ret = write_lookup_table(w->lookup_table, out, &hdr.lookup_table_res_entry);
+ ret = write_lookup_table(w, image, &hdr.lookup_table_res_entry);
if (ret != 0)
goto out;
}
static int
open_wim_writable(WIMStruct *w, const tchar *path,
- bool trunc, bool readable)
+ bool trunc, bool also_readable)
{
const tchar *mode;
if (trunc)
- if (readable)
+ if (also_readable)
mode = T("w+b");
else
mode = T("wb");
WIMLIB_WRITE_FLAG_CHECKPOINT_AFTER_XML;
}
INIT_LIST_HEAD(&stream_list);
- ret = wim_find_new_streams(w, old_wim_end, &stream_list);
+ ret = wim_prepare_streams(w, old_wim_end, &stream_list);
if (ret != 0)
return ret;
found_modified_image = false;
for (int i = 0; i < w->hdr.image_count; i++) {
- if (!found_modified_image)
- found_modified_image = w->image_metadata[i].modified;
- if (found_modified_image) {
+ if (w->image_metadata[i].modified) {
select_wim_image(w, i + 1);
ret = write_metadata_resource(w);
if (ret != 0)
git://wimlib.net / wimlib / blobdiff