+}
+
+
+
+/*
+ * Copies bytes between two file streams.
+ *
+ * Copies @len bytes from @in_fp to @out_fp, at the current position in @out_fp,
+ * and at an offset of @in_offset in @in_fp.
+ */
+int copy_between_files(FILE *in_fp, off_t in_offset, FILE *out_fp, size_t len)
+{
+ u8 buf[BUFFER_SIZE];
+ size_t n;
+
+ if (fseeko(in_fp, in_offset, SEEK_SET) != 0) {
+ ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" of "
+ "input file", in_offset);
+ return WIMLIB_ERR_READ;
+ }
+ /* To reduce memory usage and improve speed, read and write BUFFER_SIZE
+ * bytes at a time. */
+ while (len != 0) {
+ n = min(len, BUFFER_SIZE);
+ if (fread(buf, 1, n, in_fp) != n) {
+ if (feof(in_fp)) {
+ ERROR("Unexpected EOF when copying data "
+ "between files");
+ } else {
+ ERROR_WITH_ERRNO("Error copying data between "
+ "files");
+ }
+ return WIMLIB_ERR_READ;
+ }
+
+ if (fwrite(buf, 1, n, out_fp) != n) {
+ ERROR_WITH_ERRNO("Error copying data between files");
+ return WIMLIB_ERR_WRITE;
+ }
+ len -= n;
+ }
+ return 0;
+}
+
+
+/*
+ * Uncompresses a WIM file resource and writes it uncompressed to a file stream.
+ *
+ * @in_fp: The file stream that contains the file resource.
+ * @size: The size of the resource in the input file.
+ * @original_size: The original (uncompressed) size of the resource.
+ * @offset: The offset of the start of the resource in @in.
+ * @input_ctype: The compression type of the resource in @in.
+ * @out_fp: The file stream to write the file resource to.
+ */
+static int uncompress_resource(FILE *in_fp, u64 size, u64 original_size,
+ off_t offset, int input_ctype, FILE *out_fp)
+{
+ int ret;
+ u8 buf[WIM_CHUNK_SIZE];
+ /* Determine how many compressed chunks the file is divided into. */
+ u64 num_chunks;
+ u64 i;
+ u64 uncompressed_offset;
+ u64 uncompressed_chunk_size;
+
+ num_chunks = (original_size + WIM_CHUNK_SIZE - 1) / WIM_CHUNK_SIZE;
+
+ for (i = 0; i < num_chunks; i++) {
+
+ uncompressed_offset = i * WIM_CHUNK_SIZE;
+ uncompressed_chunk_size = min(WIM_CHUNK_SIZE, original_size -
+ uncompressed_offset);
+
+ ret = read_resource(in_fp, size, original_size, offset,
+ input_ctype, uncompressed_chunk_size,
+ uncompressed_offset, buf);
+ if (ret != 0)
+ return ret;
+
+ if (fwrite(buf, 1, uncompressed_chunk_size, out_fp) !=
+ uncompressed_chunk_size)
+ {
+ ERROR_WITH_ERRNO("Failed to write file resource");
+ return WIMLIB_ERR_WRITE;
+ }
+ }
+ return 0;
+}
+
+/*
+ * Transfers a file resource between two files, writing it compressed. The file
+ * resource in the input file may be either compressed or uncompressed.
+ * Alternatively, the input resource may be in-memory, but it must be
+ * uncompressed.
+ *
+ * @in_fp: The file stream that contains the file resource. Ignored
+ * if uncompressed_resource != NULL.
+ * @uncompressed_resource: If this pointer is not NULL, it points to an
+ * array of @original_size bytes that are
+ * the uncompressed input resource.
+ * @size: The size of the resource in the input file.
+ * @original_size: The original (uncompressed) size of the resource.
+ * @offset: The offset of the start of the resource in @in. Ignored
+ * if uncompressed_resource != NULL.
+ * @input_ctype: The compression type of the resource in @in. Ignored if
+ * uncompressed_resource != NULL.
+ * @out_fp: The file stream to write the file resource to.
+ * @output_type: The compression type to use when writing the resource to
+ * @out.
+ * @new_size_ret: A location into which the new compressed size of the file
+ * resource in returned.
+ */
+static int recompress_resource(FILE *in_fp, const u8 *uncompressed_resource,
+ u64 size, u64 original_size,
+ off_t offset, int input_ctype, FILE *out_fp,
+ int output_ctype, u64 *new_size_ret)
+{
+ int ret;
+ int (*compress)(const void *, uint, void *, uint *);
+ if (output_ctype == WIM_COMPRESSION_TYPE_LZX)
+ compress = lzx_compress;
+ else
+ compress = xpress_compress;
+
+ u8 uncompressed_buf[WIM_CHUNK_SIZE];
+ u8 compressed_buf[WIM_CHUNK_SIZE - 1];
+
+ /* Determine how many compressed chunks the file needs to be divided
+ * into. */
+ u64 num_chunks = (original_size + WIM_CHUNK_SIZE - 1) / WIM_CHUNK_SIZE;
+
+ u64 num_chunk_entries = num_chunks - 1;
+
+ /* Size of the chunk entries--- 8 bytes for files over 4GB, otherwise 4
+ * bytes */
+ uint chunk_entry_size = (original_size >= (u64)1 << 32) ? 8 : 4;
+
+ /* Array in which to construct the chunk offset table. */
+ u64 chunk_offsets[num_chunk_entries];
+
+ /* Offset of the start of the chunk table in the output file. */
+ off_t chunk_tab_offset = ftello(out_fp);
+
+ if (chunk_tab_offset == -1) {
+ ERROR_WITH_ERRNO("Failed to get offset of output file");
+ return WIMLIB_ERR_WRITE;
+ }
+
+ /* Total size of the chunk table (as written to the file) */
+ u64 chunk_tab_size = chunk_entry_size * num_chunk_entries;
+
+ /* Reserve space for the chunk table. */
+ if (fwrite(chunk_offsets, 1, chunk_tab_size, out_fp) !=
+ chunk_tab_size)
+ {
+ ERROR_WITH_ERRNO("Failed to write chunk offset table");
+ return WIMLIB_ERR_WRITE;
+ }
+
+ /* Read each chunk of the file, compress it, write it to the output
+ * file, and update th chunk offset table. */
+ u64 cur_chunk_offset = 0;
+ for (u64 i = 0; i < num_chunks; i++) {
+
+ u64 uncompressed_offset = i * WIM_CHUNK_SIZE;
+ u64 uncompressed_chunk_size = min(WIM_CHUNK_SIZE,
+ original_size - uncompressed_offset);
+
+ const u8 *uncompressed_p;
+ if (uncompressed_resource != NULL) {
+ uncompressed_p = uncompressed_resource +
+ uncompressed_offset;
+
+ } else {
+ /* Read chunk i of the file into uncompressed_buf. */
+ ret = read_resource(in_fp, size, original_size, offset,
+ input_ctype,
+ uncompressed_chunk_size,
+ uncompressed_offset,
+ uncompressed_buf);
+ if (ret != 0)
+ return ret;
+ uncompressed_p = uncompressed_buf;
+ }
+
+ if (i != 0)
+ chunk_offsets[i - 1] = cur_chunk_offset;
+
+ uint compressed_len;
+
+ ret = compress(uncompressed_p, uncompressed_chunk_size,
+ compressed_buf, &compressed_len);
+
+ /* if compress() returned nonzero, the compressed chunk would
+ * have been at least as large as the uncompressed chunk. In
+ * this situation, the WIM format requires that the uncompressed
+ * chunk be written instead. */
+ const u8 *buf_to_write;
+ uint len_to_write;
+ if (ret == 0) {
+ buf_to_write = compressed_buf;
+ len_to_write = compressed_len;
+ } else {
+ buf_to_write = uncompressed_p;
+ len_to_write = uncompressed_chunk_size;
+ }
+
+ if (fwrite(buf_to_write, 1, len_to_write, out_fp) !=
+ len_to_write)
+ {
+ ERROR_WITH_ERRNO("Failed to write compressed "
+ "file resource");
+ return WIMLIB_ERR_WRITE;
+ }
+ cur_chunk_offset += len_to_write;
+ }
+
+ /* The chunk offset after the last chunk, plus the size of the chunk
+ * table, gives the total compressed size of the resource. */
+ *new_size_ret = cur_chunk_offset + chunk_tab_size;
+
+ /* Now that all entries of the chunk table are determined, rewind the
+ * stream to where the chunk table was, and write it back out. */
+
+ if (fseeko(out_fp, chunk_tab_offset, SEEK_SET) != 0) {
+ ERROR_WITH_ERRNO("Failed to seek to beginning of chunk table");
+ return WIMLIB_ERR_READ;
+ }
+
+ if (chunk_entry_size == 8) {
+ array_to_le64(chunk_offsets, num_chunk_entries);