# VKZip - GPU-Accelerated File Compressor/Decompressor

```
  ██╗   ██╗██╗  ██╗███████╗██╗██████╗ 
  ██║   ██║██║ ██╔╝╚══███╔╝██║██╔══██╗
  ██║   ██║█████╔╝   ███╔╝ ██║██████╔╝
  ╚██╗ ██╔╝██╔═██╗  ███╔╝  ██║██╔═══╝ 
   ╚████╔╝ ██║  ██╗███████╗██║██║     
    ╚═══╝  ╚═╝  ╚═╝╚══════╝╚═╝╚═╝     
```

> **Compressão de arquivos acelerada por GPU usando Vulkan Compute Shaders**

## ✨ Características

- 🚀 **Aceleração GPU** via Vulkan Compute Shaders
- 🖥️ **Cross-platform** - Windows e Linux
- 🎮 **Multi-GPU** - NVIDIA, AMD, Intel (qualquer GPU Vulkan)
- 🔄 **CPU Fallback** - Funciona mesmo sem GPU compatível
- 📊 **Benchmark** - Compare GPU vs CPU no seu hardware
- 🔒 **CRC32** - Verificação de integridade dos dados
- 📦 **Formato .vkz** - Formato próprio otimizado para compressão paralela

## 📋 Requisitos

### Linux
```bash
# Ubuntu/Debian
sudo apt install cmake build-essential vulkan-tools libvulkan-dev glslang-tools

# Arch Linux
sudo pacman -S cmake vulkan-tools vulkan-headers vulkan-icd-loader glslang

# Fedora
sudo dnf install cmake gcc vulkan-tools vulkan-loader-devel glslang
```

### Windows
1. Instale o [Vulkan SDK](https://vulkan.lunarg.com/sdk/home)
2. Instale o [CMake](https://cmake.org/download/)
3. Instale o [Visual Studio Build Tools](https://visualstudio.microsoft.com/downloads/) (ou MinGW)

## 🔨 Compilação

```bash
# Clonar e entrar no diretório
cd winrarcomgpu

# Criar diretório de build
mkdir build && cd build

# Configurar
cmake ..

# Compilar
cmake --build . --config Release

# (Opcional) Instalar
sudo cmake --install .
```

### Windows (MSVC)
```cmd
mkdir build && cd build
cmake .. -G "Visual Studio 17 2022"
cmake --build . --config Release
```

## 🚀 Uso

### Compactar arquivo
```bash
vkzip compress arquivo.dat                    # → arquivo.dat.vkz
vkzip compress arquivo.dat saida.vkz          # Nome personalizado
vkzip compress arquivo.dat --block-size 128   # Blocos de 128KB
vkzip c arquivo.dat                           # Atalho
```

### Descompactar arquivo
```bash
vkzip decompress arquivo.vkz                  # → restaura nome original
vkzip decompress arquivo.vkz saida.dat        # Nome personalizado
vkzip d arquivo.vkz                           # Atalho
vkzip x arquivo.vkz                           # Atalho alternativo
```

### Informações do arquivo
```bash
vkzip info arquivo.vkz                        # Detalhes do arquivo
vkzip i arquivo.vkz                           # Atalho
```

### Benchmark GPU vs CPU
```bash
vkzip benchmark arquivo_grande.dat            # Compara GPU vs CPU
vkzip bench arquivo_grande.dat                # Atalho
```

### Informações da GPU
```bash
vkzip --gpu-info                              # Mostra info da GPU
```

### Opções
```bash
--cpu-only      Forçar modo CPU (sem GPU)
--block-size N  Tamanho do bloco em KB (padrão: 64, min: 4, max: 1024)
```

## ⚙️ Como Funciona

### Algoritmo de Compressão

1. **Divisão em Blocos**: O arquivo é dividido em blocos independentes (64KB por padrão)
2. **Upload GPU**: Todos os blocos são enviados para memória da GPU
3. **Compressão Paralela**: Cada bloco é comprimido em paralelo por um workgroup do GPU
   - Usa LZ77 (match-finding com hash table)
   - Cada match é codificado como `(distância, comprimento)`
   - Bytes sem match são armazenados como literais
4. **Download**: Dados comprimidos são lidos de volta da GPU
5. **Empacotamento**: Blocos comprimidos + header = arquivo `.vkz`

### Formato .vkz

```
┌──────────────────────────────────┐
│ Header (28 bytes)                │
│   Magic: "VKZ\0"                │
│   Version, Size, Block info     │
├──────────────────────────────────┤
│ Block Table                      │
│   Offset, Size, CRC per block   │
├──────────────────────────────────┤
│ Original Filename                │
├──────────────────────────────────┤
│ Compressed Block 0               │
│ Compressed Block 1               │
│ ...                              │
│ Compressed Block N               │
└──────────────────────────────────┘
```

## 📊 Performance

A vantagem da GPU aparece principalmente em:
- **Arquivos grandes** (>10MB) com muitos blocos paralelos
- **GPUs potentes** com muitos compute units
- **Dados com boa compressibilidade** (texto, logs, dados estruturados)

Para arquivos pequenos, o overhead de transferência CPU↔GPU pode tornar o CPU mais rápido.

## 🏗️ Estrutura do Projeto

```
winrarcomgpu/
├── CMakeLists.txt          # Build system
├── README.md               # Este arquivo
├── src/
│   ├── main.c              # CLI entry point
│   ├── utils.h             # Utilitários e constantes
│   ├── vkz_format.h/c      # Formato do arquivo .vkz
│   ├── gpu_context.h/c     # Inicialização Vulkan
│   ├── gpu_compress.h/c    # Pipeline de compressão GPU
│   ├── gpu_decompress.h/c  # Pipeline de descompressão GPU
│   └── cpu_fallback.h/c    # Fallback CPU
└── shaders/
    ├── compress.comp        # Compute shader de compressão
    ├── decompress.comp      # Compute shader de descompressão
    └── compile_shaders.sh   # Script de compilação
```

## 📄 Licença

MIT License - Use livremente!
