std::unique_ptr<CompressedBlobReader> CompressedBlobReader::Create(const std::string& filename) { if (IsGCZBlob(filename)) return std::unique_ptr<CompressedBlobReader>(new CompressedBlobReader(filename)); return nullptr; }
std::unique_ptr<CompressedBlobReader> CompressedBlobReader::Create(File::IOFile file, const std::string& filename) { if (IsGCZBlob(file)) return std::unique_ptr<CompressedBlobReader>( new CompressedBlobReader(std::move(file), filename)); return nullptr; }
std::unique_ptr<IBlobReader> CreateBlobReader(const std::string& filename) { if (cdio_is_cdrom(filename)) return DriveReader::Create(filename); if (!File::Exists(filename)) return nullptr; if (IsWbfsBlob(filename)) return WbfsFileReader::Create(filename); if (IsGCZBlob(filename)) return CompressedBlobReader::Create(filename); if (IsCISOBlob(filename)) return CISOFileReader::Create(filename); // Still here? Assume plain file - since we know it exists due to the File::Exists check above. return PlainFileReader::Create(filename); }
bool DecompressBlobToFile(const std::string& infile_path, const std::string& outfile_path, CompressCB callback, void* arg) { std::unique_ptr<CompressedBlobReader> reader; { File::IOFile infile(infile_path, "rb"); if (!IsGCZBlob(infile)) { PanicAlertT("File not compressed"); return false; } reader = CompressedBlobReader::Create(std::move(infile), infile_path); } if (!reader) { PanicAlertT("Failed to open the input file \"%s\".", infile_path.c_str()); return false; } File::IOFile outfile(outfile_path, "wb"); if (!outfile) { PanicAlertT("Failed to open the output file \"%s\".\n" "Check that you have permissions to write the target folder and that the media can " "be written.", outfile_path.c_str()); return false; } const CompressedBlobHeader& header = reader->GetHeader(); static const size_t BUFFER_BLOCKS = 32; size_t buffer_size = header.block_size * BUFFER_BLOCKS; size_t last_buffer_size = header.block_size * (header.num_blocks % BUFFER_BLOCKS); std::vector<u8> buffer(buffer_size); u32 num_buffers = (header.num_blocks + BUFFER_BLOCKS - 1) / BUFFER_BLOCKS; int progress_monitor = std::max<int>(1, num_buffers / 100); bool success = true; for (u64 i = 0; i < num_buffers; i++) { if (i % progress_monitor == 0) { bool was_cancelled = !callback(GetStringT("Unpacking"), (float)i / (float)num_buffers, arg); if (was_cancelled) { success = false; break; } } const size_t sz = i == num_buffers - 1 ? last_buffer_size : buffer_size; reader->Read(i * buffer_size, sz, buffer.data()); if (!outfile.WriteBytes(buffer.data(), sz)) { PanicAlertT("Failed to write the output file \"%s\".\n" "Check that you have enough space available on the target drive.", outfile_path.c_str()); success = false; break; } } if (!success) { // Remove the incomplete output file. outfile.Close(); File::Delete(outfile_path); } else { outfile.Resize(header.data_size); } return success; }
bool CompressFileToBlob(const std::string& infile_path, const std::string& outfile_path, u32 sub_type, int block_size, CompressCB callback, void* arg) { bool scrubbing = false; File::IOFile infile(infile_path, "rb"); if (IsGCZBlob(infile)) { PanicAlertT("\"%s\" is already compressed! Cannot compress it further.", infile_path.c_str()); return false; } if (!infile) { PanicAlertT("Failed to open the input file \"%s\".", infile_path.c_str()); return false; } File::IOFile outfile(outfile_path, "wb"); if (!outfile) { PanicAlertT("Failed to open the output file \"%s\".\n" "Check that you have permissions to write the target folder and that the media can " "be written.", outfile_path.c_str()); return false; } DiscScrubber disc_scrubber; if (sub_type == 1) { if (!disc_scrubber.SetupScrub(infile_path, block_size)) { PanicAlertT("\"%s\" failed to be scrubbed. Probably the image is corrupt.", infile_path.c_str()); return false; } scrubbing = true; } z_stream z = {}; if (deflateInit(&z, 9) != Z_OK) return false; callback(GetStringT("Files opened, ready to compress."), 0, arg); CompressedBlobHeader header; header.magic_cookie = GCZ_MAGIC; header.sub_type = sub_type; header.block_size = block_size; header.data_size = infile.GetSize(); // round upwards! header.num_blocks = (u32)((header.data_size + (block_size - 1)) / block_size); std::vector<u64> offsets(header.num_blocks); std::vector<u32> hashes(header.num_blocks); std::vector<u8> out_buf(block_size); std::vector<u8> in_buf(block_size); // seek past the header (we will write it at the end) outfile.Seek(sizeof(CompressedBlobHeader), SEEK_CUR); // seek past the offset and hash tables (we will write them at the end) outfile.Seek((sizeof(u64) + sizeof(u32)) * header.num_blocks, SEEK_CUR); // seek to the start of the input file to make sure we get everything infile.Seek(0, SEEK_SET); // Now we are ready to write compressed data! u64 position = 0; int num_compressed = 0; int num_stored = 0; int progress_monitor = std::max<int>(1, header.num_blocks / 1000); bool success = true; for (u32 i = 0; i < header.num_blocks; i++) { if (i % progress_monitor == 0) { const u64 inpos = infile.Tell(); int ratio = 0; if (inpos != 0) ratio = (int)(100 * position / inpos); std::string temp = StringFromFormat(GetStringT("%i of %i blocks. Compression ratio %i%%").c_str(), i, header.num_blocks, ratio); bool was_cancelled = !callback(temp, (float)i / (float)header.num_blocks, arg); if (was_cancelled) { success = false; break; } } offsets[i] = position; size_t read_bytes; if (scrubbing) read_bytes = disc_scrubber.GetNextBlock(infile, in_buf.data()); else infile.ReadArray(in_buf.data(), header.block_size, &read_bytes); if (read_bytes < header.block_size) std::fill(in_buf.begin() + read_bytes, in_buf.begin() + header.block_size, 0); int retval = deflateReset(&z); z.next_in = in_buf.data(); z.avail_in = header.block_size; z.next_out = out_buf.data(); z.avail_out = block_size; if (retval != Z_OK) { ERROR_LOG(DISCIO, "Deflate failed"); success = false; break; } int status = deflate(&z, Z_FINISH); int comp_size = block_size - z.avail_out; u8* write_buf; int write_size; if ((status != Z_STREAM_END) || (z.avail_out < 10)) { // PanicAlert("%i %i Store %i", i*block_size, position, comp_size); // let's store uncompressed write_buf = in_buf.data(); offsets[i] |= 0x8000000000000000ULL; write_size = block_size; num_stored++; } else { // let's store compressed // PanicAlert("Comp %i to %i", block_size, comp_size); write_buf = out_buf.data(); write_size = comp_size; num_compressed++; } if (!outfile.WriteBytes(write_buf, write_size)) { PanicAlertT("Failed to write the output file \"%s\".\n" "Check that you have enough space available on the target drive.", outfile_path.c_str()); success = false; break; } position += write_size; hashes[i] = HashAdler32(write_buf, write_size); } header.compressed_data_size = position; if (!success) { // Remove the incomplete output file. outfile.Close(); File::Delete(outfile_path); } else { // Okay, go back and fill in headers outfile.Seek(0, SEEK_SET); outfile.WriteArray(&header, 1); outfile.WriteArray(offsets.data(), header.num_blocks); outfile.WriteArray(hashes.data(), header.num_blocks); } // Cleanup deflateEnd(&z); if (success) { callback(GetStringT("Done compressing disc image."), 1.0f, arg); } return success; }