Adding -data to exe2iso, and various small improvements.

Author: nicolasnoble

tools/exe2iso/exe2iso.cc

@@ -32,9 +32,11 @@ static void storeU32(uint32_t value, uint8_t* buffer) {
     buffer[3] = (value >> 24) & 0xff;
 }
 
-// make sure to call this with a sector that's memset to 0
-static void getSector(uint8_t data[2048], uint32_t lba, uint32_t exeSize, uint32_t exeOffset = 19) {
+// make sure to call this with a sector that's memset to 0, as it relies on zeros being
+// in the right place.
+static void getSectorMinimal(uint8_t data[2048], uint32_t lba, uint32_t exeSize, uint32_t exeOffset = 19) {
     switch (lba) {
+        // Minimal PVD
         case 16:
             data[0] = 1;
             data[1] = 'C';
@@ -46,11 +48,13 @@ static void getSector(uint8_t data[2048], uint32_t lba, uint32_t exeSize, uint32
             storeU32(17, data + 140);
             storeU32(18, data + 158);
             break;
+        // Minimal path table
         case 17:
             data[0] = 1;
             data[2] = 18;
             data[6] = 1;
             break;
+        // Minimal root directory
         case 18:
             data[0] = 42;
             storeU32(exeOffset, data + 2);
@@ -69,16 +73,20 @@ static void getSector(uint8_t data[2048], uint32_t lba, uint32_t exeSize, uint32
     }
 }
 
-// make sure to call this with a sector that's memset to 0, as it relies on zeros being
-// in the right place.
-static void makeHeader(uint8_t sector[2352], uint32_t lba) {
-    PCSX::IEC60908b::MSF time(lba + 150);
+// Call this once on a sector that's been memset to 0,
+// in order to set all of the immutable data.
+static void makeHeaderOnce(uint8_t sector[2352]) {
     memset(sector + 1, 0xff, 10);
-    time.toBCD(sector + 12);
     sector[15] = 2;
     sector[18] = sector[22] = 8;
 }
 
+// This function sets the LBA in the header of the sector.
+static void makeHeader(uint8_t sector[2352], uint32_t lba) {
+    PCSX::IEC60908b::MSF time(lba + 150);
+    time.toBCD(sector + 12);
+}
+
 int main(int argc, char** argv) {
     CommandLine::args args(argc, argv);
 
@@ -96,12 +104,14 @@ exe2iso by Nicolas "Pixel" Noble
     const bool pad = args.get<bool>("pad").value_or(false);
     const bool regen = args.get<bool>("regen").value_or(false);
     const auto license = args.get<std::string>("license");
+    const auto data = args.get<std::string>("data");
     if (asksForHelp || !oneInput || !hasOutput) {
         fmt::print(R"(
 Usage: {} input.ps-exe [-offset value] [-pad] [-regen] [-license file] -o output.bin
   input.ps-exe      mandatory: specify the input ps-exe file.
   -o output.bin     mandatory: name of the output file.
   -offset value     optional: move the exe data by value sectors.
+  -data filename    optional: insert this file into the iso after the exe.
   -pad              optional: pads the iso with 150 blank sectors.
   -regen            optional: generates proper ECC/EDC.
   -license file     optional: use this license file.
@@ -114,17 +124,29 @@ Usage: {} input.ps-exe [-offset value] [-pad] [-regen] [-license file] -o output
     auto& input = inputs[0];
     PCSX::IO<PCSX::File> file(new PCSX::PosixFile(input));
     if (file->failed()) {
-        fmt::print("Unable to open file: {}\n", input);
+        fmt::print("Error opening input file {}\n", input);
         return -1;
     }
     PCSX::IO<PCSX::File> licenseFile(new PCSX::FailedFile);
+    PCSX::IO<PCSX::File> dataFile(new PCSX::FailedFile);
     PCSX::IO<PCSX::File> out(new PCSX::PosixFile(output.value(), PCSX::FileOps::TRUNCATE));
     if (out->failed()) {
         fmt::print("Error opening output file {}\n", output.value());
         return -1;
     }
     if (license.has_value()) {
         licenseFile.setFile(new PCSX::PosixFile(license.value()));
+        if (licenseFile->failed()) {
+            fmt::print("Error opening license file {}\n", license.value());
+            return -1;
+        }
+    }
+    if (data.has_value()) {
+        dataFile.setFile(new PCSX::PosixFile(data.value()));
+        if (dataFile->failed()) {
+            fmt::print("Error opening data file {}\n", data.value());
+            return -1;
+        }
     }
 
     uint32_t exeSize = file->size();
@@ -134,77 +156,80 @@ Usage: {} input.ps-exe [-offset value] [-pad] [-regen] [-license file] -o output
     uint32_t exeOffset = 19 + offset;
 
     uint8_t sector[2352];
+    memset(sector, 0, sizeof(sector));
+    makeHeaderOnce(sector);
     bool wroteLicense = false;
+    unsigned LBA = 0;
+    auto writeSector = [&]() {
+        makeHeader(sector, LBA++);
+        if (regen) compute_edcecc(sector);
+        out->write(sector, sizeof(sector));
+    };
     // Sectors 0-15 are the license. We can keep it to zeroes and it'll work most everywhere.
     if (licenseFile && !licenseFile->failed()) {
         uint8_t licenseData[2352 * 16];
         memset(licenseData, 0, sizeof(licenseData));
         licenseFile->read(licenseData, sizeof(licenseData));
-        if (licenseData[0x2492] == 'L') {
+        if ((licenseFile->size() == 2336 * 16) && (licenseData[0x2492] == 'L')) {
             // official license file from the sdk, in 2336 bytes per sector.
             for (unsigned i = 0; i < 16; i++) {
-                memset(sector, 0, sizeof(sector));
                 memcpy(sector + 16, licenseData + 2336 * i, 2336);
-                makeHeader(sector, i);
-                if (regen) compute_edcecc(sector);
-                out->write(sector, sizeof(sector));
+                writeSector();
             }
             wroteLicense = true;
         } else if (licenseData[0x24e2] == 'L') {
             // looks like an iso file itself
             for (unsigned i = 0; i < 16; i++) {
                 memcpy(sector, licenseData + 2352 * i, 2352);
-                makeHeader(sector, i);
-                if (regen) compute_edcecc(sector);
-                out->write(sector, sizeof(sector));
+                makeHeaderOnce(sector);
+                writeSector();
             }
             wroteLicense = true;
         } else {
             fmt::print("Unrecognized LICENSE file format {}\n", output.value());
         }
     }
     if (!wroteLicense) {
+        memset(sector, 0, sizeof(sector));
         for (unsigned i = 0; i < 16; i++) {
-            memset(sector, 0, sizeof(sector));
-            makeHeader(sector, i);
-            if (regen) compute_edcecc(sector);
-            out->write(sector, sizeof(sector));
+            writeSector();
         }
     }
     // The actual structure of the iso. We're only generating 3 sectors,
     // from 16 to 18, as it's the only things necessary for the PS1 bios.
-    for (unsigned i = 16; i < 19; i++) {
+    for (unsigned i = 0; i < 3; i++) {
         memset(sector, 0, sizeof(sector));
-        makeHeader(sector, i);
+        makeHeaderOnce(sector);
         // This function will fill the sector with the right data, as
         // necessary for the PS1 bios.
-        getSector(sector + 24, i, exeSize, exeOffset);
-        if (regen) compute_edcecc(sector);
-        out->write(sector, sizeof(sector));
+        getSectorMinimal(sector + 24, LBA, exeSize, exeOffset);
+        writeSector();
     }
     // Potential padding before the start of the exe.
-    for (unsigned i = 19; i < exeOffset; i++) {
-        memset(sector, 0, sizeof(sector));
-        makeHeader(sector, i);
-        if (regen) compute_edcecc(sector);
-        out->write(sector, sizeof(sector));
+    memset(sector, 0, sizeof(sector));
+    makeHeaderOnce(sector);
+    for (unsigned i = 0; i < offset; i++) {
+        writeSector();
     }
-    unsigned LBA = exeOffset;
     // The actual exe.
     for (unsigned i = 0; i < exeSize; i += 2048) {
-        memset(sector, 0, sizeof(sector));
-        makeHeader(sector, LBA++);
         file->read(sector + 24, 2048);
-        if (regen) compute_edcecc(sector);
-        out->write(sector, sizeof(sector));
+        writeSector();
+    }
+    if (dataFile && !dataFile->failed()) {
+        // The additional data file.
+        unsigned sectors = (dataFile->size() + 2047) / 2048;
+        for (unsigned i = 0; i < sectors; i++) {
+            dataFile->read(sector + 24, 2048);
+            writeSector();
+        }
     }
+    memset(sector, 0, sizeof(sector));
+    makeHeaderOnce(sector);
     if (pad) {
         // 150 sectors padding.
         for (unsigned i = 0; i < 150; i++) {
-            memset(sector, 0, sizeof(sector));
-            makeHeader(sector, LBA++);
-            if (regen) compute_edcecc(sector);
-            out->write(sector, sizeof(sector));
+            writeSector();
         }
     }
     fmt::print("Done.");