# Apollo Save Tool VMC Formats for PS1 and PS2: Complete Format Support Guide

> Discover Apollo Save Tool's VMC formats for PS1 and PS2. Get complete support details for .VMP, .VM2, and more, with automatic ECC detection for seamless game saves.

- Repository: [Damián Parrino/apollo-ps4](https://github.com/bucanero/apollo-ps4)
- Tags: deep-dive
- Published: 2026-02-26

---

**Apollo Save Tool supports 10 PS1 virtual memory card extensions (.VMP, .MCR, .VM1, .BIN, .VMC, .GME, .VGS, .SRM, .MCD) and 7 PS2 VMC extensions (.VM2, .CARD, .PS2, .VMC, .BIN, .MC2, .MCD), handling them through platform-specific import/export functions in [`source/exec_cmd.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/exec_cmd.c) with automatic ECC detection in [`source/mcio.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/mcio.c).**

Apollo Save Tool (bucanero/apollo-ps4) provides comprehensive virtual memory card management for PlayStation 1 and PlayStation 2 saves on PS4 hardware. The tool detects VMC files through extension-based scanning and processes them using dedicated import/export pipelines that handle both raw and ECC-protected formats.

## Supported Apollo Save Tool VMC Formats

### PS1 Virtual Memory Card Extensions

Apollo Save Tool recognizes **10 distinct file extensions** for PS1 virtual memory cards. These formats represent various legacy save types from different emulators and official Sony tools:

- **.VMP** – Official Sony PS1 VMC format with ECC
- **.MCR** – Standard raw memory card dump
- **.VM1** – Raw PS1 VMC format
- **.BIN** – Generic binary memory card image
- **.VMC** – Generic virtual memory card container
- **.GME** – DexDrive memory card format
- **.VGS** – Connectix VGS emulator format
- **.SRM** – RetroArch/libretro save format
- **.MCD** – Common emulator memory card format

### PS2 Virtual Memory Card Extensions

For PlayStation 2 saves, the tool supports **7 extensions** with full awareness of ECC (Error Correction Code) variants:

- **.VM2** – PS2 virtual memory card format
- **.CARD** – Standard PS2 memory card image
- **.PS2** – Generic PS2 memory card dump
- **.VMC** – Cross-platform virtual memory card container
- **.BIN** – Raw binary memory card image
- **.MC2** – PS2 memory card format
- **.MCD** – ECC-aware memory card format

The tool automatically detects whether a PS2 VMC uses ECC protection by examining the `CF_USE_ECC` flag in the card header.

## How Apollo Save Tool Detects VMC Files

When scanning USB or USB-HDD paths, Apollo Save Tool calls `scan_vmc_files()` in [`source/saves.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/saves.c). This function validates filenames against the supported extension list using case-insensitive string matching:

```c
/* source/saves.c – lines 1619-1625 */
if (dir->d_type != DT_REG ||
    !(endsWith(dir->d_name, ".CARD") || endsWith(dir->d_name, ".VM2") ||
      endsWith(dir->d_name, ".BIN")  || endsWith(dir->d_name, ".PS2") ||
      endsWith(dir->d_name, ".VMC")  || endsWith(dir->d_name, ".MC2") ||
      // PS1 VMCs
      endsWith(dir->d_name, ".MCD") || endsWith(dir->d_name, ".MCR") ||
      endsWith(dir->d_name, ".GME") || endsWith(dir->d_name, ".VM1") ||
      endsWith(dir->d_name, ".VMP") || endsWith(dir->d_name, ".VGS") ||
      endsWith(dir->d_name, ".SRM")))
    continue;

```

When a match occurs, the tool creates a save entry with the `SAVE_FLAG_VMC` flag and assigns the generic type `FILE_TYPE_VMC` (defined in [`source/saves.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/saves.c), lines 57-59). These entries appear in the UI under **Memory Card Management** for the corresponding platform.

## PS1 VMC Format Handling

### Exporting PS1 VMCs

The **Export PS1 VMC** command triggers `export_ps1vmc()` in [`source/exec_cmd.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/exec_cmd.c). This function supports two output formats controlled by the `vmp` parameter:

```c
/* source/exec_cmd.c – lines 974-986 */
static void export_ps1vmc(const char* vm1_file, int dst, int vmp) {
    /* ... */
    snprintf(dstfile, sizeof(dstfile), "%s%s.%s",
             dst_path, vm1_file, vmp ? "VMP" : "VM1");
    saveMemoryCard(dstfile, vmp ? PS1CARD_VMP : PS1CARD_RAW, 0);
}

```

Setting `vmp = 1` generates a **.VMP** file with ECC data, while `vmp = 0` produces a raw **.VM1** image.

### Importing Saves into PS1 VMCs

Single PS1 saves (**.MCS**, **.PSV**, **.PSX**) are imported via `openSingleSave()` in [`source/ps1card.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/ps1card.c). This function reconstructs the VMC header when necessary and writes the save data back to the card image, maintaining compatibility with the target format.

## PS2 VMC Format Handling

### Exporting PS2 VMC Saves

Apollo Save Tool provides two export paths for PS2 virtual memory cards:

- **`exportVmcSave()`** (lines 52-71 in [`source/exec_cmd.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/exec_cmd.c)) extracts individual saves from a VMC and writes them as **.MCS**, **.PSV**, or **.PSX** files based on the requested output type.

- **`export_vmc2save()`** (lines 94-124) converts an entire VMC to **.PSU** (raw save) or **.PSV** (virtual save) formats. This function calls `vmc_export_psv()` or `vmc_export_psu()` from [`source/psv_resign.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/psv_resign.c).

```c
/* Export PS2 VMC as PSU */
export_vmc2save(selected_vmc_entry, FILE_TYPE_PSU, dst_usb_id);

```

### Importing Saves into PS2 VMCs

The `import_save2vmc()` function in [`source/exec_cmd.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/exec_cmd.c) (lines 30-62) handles injection of external saves into PS2 VMCs:

```c
/* source/exec_cmd.c – lines 34-58 */
case FILE_TYPE_PSV: ret = vmc_import_psv(src); break;
case FILE_TYPE_PSU: ret = vmc_import_psu(src); break;
case FILE_TYPE_XPS: ret = ps2_xps2psv(src, ...) && vmc_import_psv(...); break;
/* ... */

```

For native formats (**PSV**, **PSU**), the tool imports directly using `vmc_import_psv()` or `vmc_import_psu()` from [`source/psv_resign.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/psv_resign.c). For third-party formats (**XPS**, **CBS**, **MAX**), the tool first converts the file to PSV using conversion functions in [`source/psv_ps2.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/psv_ps2.c) (`ps2_xps2psv()`, `ps2_cbs2psv()`, `ps2_max2psv()`), then injects the resulting PSV into the VMC.

## ECC Handling in PS2 VMC Formats

The low-level card driver in [`source/mcio.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/mcio.c) manages ECC data through the `CF_USE_ECC` header flag. When this flag is set, `Card_ReadPageData()` and `Card_WritePageData()` (lines 3-13) process an extra spare/ECC block with every page read or write operation.

The UI exposes **"Export Memory Card to .VMC format (No ECC)"** to force generation of non-ECC images, useful for compatibility with emulators that do not expect error correction data.

## Summary

- **Apollo Save Tool** supports 10 PS1 VMC extensions and 7 PS2 VMC extensions, documented in [`README.md`](https://github.com/bucanero/apollo-ps4/blob/main/README.md) and hard-coded in `scan_vmc_files()`.
- **File detection** occurs in [`source/saves.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/saves.c) through extension matching, creating generic `FILE_TYPE_VMC` entries for the UI.
- **PS1 operations** use `export_ps1vmc()` for VMP/VM1 output and `openSingleSave()` for single save imports.
- **PS2 operations** rely on `import_save2vmc()` and `export_vmc2save()`, with automatic conversion of XPS/CBS/MAX formats via [`source/psv_ps2.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/psv_ps2.c) functions.
- **ECC handling** is transparent in [`source/mcio.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/mcio.c), with the `CF_USE_ECC` flag determining whether spare blocks are processed during read/write operations.

## Frequently Asked Questions

### What file extensions does Apollo Save Tool recognize for PS1 memory cards?

Apollo Save Tool recognizes **.VMP, .MCR, .VM1, .BIN, .VMC, .GME, .VGS, .SRM, and .MCD** for PS1 virtual memory cards. The scanner in [`source/saves.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/saves.c) checks for these extensions case-insensitively when building the save list from USB storage.

### Can Apollo Save Tool convert between different PS2 save formats when importing to VMCs?

Yes. When importing **.XPS, .CBS, or .MAX** files, the tool first converts them to **.PSV** format using functions like `ps2_max2psv()` in [`source/psv_ps2.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/psv_ps2.c), then injects the converted save into the VMC using `vmc_import_psv()` from [`source/psv_resign.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/psv_resign.c). Native **.PSV** and **.PSU** files import directly without conversion.

### How does Apollo Save Tool handle ECC data in PS2 virtual memory cards?

The tool examines the `CF_USE_ECC` flag in the VMC header. If set, `Card_ReadPageData()` and `Card_WritePageData()` in [`source/mcio.c`](https://github.com/bucanero/apollo-ps4/blob/main/source/mcio.c) include spare/ECC blocks during page operations. Users can export VMCs without ECC using the dedicated menu option for emulator compatibility.

### Where is the VMC scanning logic implemented in the Apollo Save Tool source code?

The scanning logic resides in `scan_vmc_files()` inside **source/saves.c** (lines 1619-1625). This function validates file extensions against the supported PS1 and PS2 VMC formats and creates entries with `SAVE_FLAG_VMC` and `FILE_TYPE_VMC` types for presentation in the Memory Card Management UI.