TV OldSchool

🇪🇸 Versión en español · 🇬🇧 English version

---

🇪🇸 Versión en español

Convierte vídeo moderno para televisores de dos altavoces y reproductores USB de los años 2000, con diálogos nítidos.

Características · Algoritmo Zainder · Instalación · Desarrollo · Arquitectura · Problemas · Licencia · ⬆ Inicio

📺 ¿Qué es TV OldSchool?

Las películas actuales se mezclan en 5.1 y suelen tener diálogos bajos y música o efectos muy altos. En un televisor antiguo de dos altavoces pequeños, el resultado es una voz que se pierde entre explosiones. Además, muchas teles con puerto USB posteriores a los 2000 solo reproducen unos pocos códecs.

TV OldSchool es una aplicación de escritorio que resuelve ambos problemas a la vez:

1. Compatibilidad: recodifica el vídeo a formatos que esos televisores decodifican por hardware (AVI Xvid/DivX + MP3, MPEG-2 para DVD, o MP4 H.264 básico).
2. Claridad de voces: aplica una cadena de procesado de audio (el algoritmo Zainder) que separa la voz del fondo, la realza y deja el resultado a un nivel de sonoridad cómodo para dos altavoces.

Todo el procesamiento se hace en tu equipo. Ningún vídeo, pista de audio ni dato de uso se sube a servidores externos.

✨ Características

• Cola de conversión por lotes: arrastra archivos o carpetas completas; soporta MP4, MKV, AVI, MOV, WMV, WebM, TS, VOB y más.
• Tres perfiles de compatibilidad

Preset	Vídeo	Audio	Cuándo usarlo
avi_xvid_mp3	Xvid / DivX	MP3	El más compatible con teles y reproductores de los 2000
mpeg2_dvd	MPEG-2	MP2 / PCM	Estándar DVD/DVB, funciona casi siempre, ocupa más
mp4_h264	H.264 (Baseline / Main / High)	MP3 / AAC	Teles USB HD más recientes (720p/1080p)

• Límites de resolución: 1080p, 720p o 576p (DVD).
• Selección de pistas de audio: detecta los idiomas y elige español por defecto; admite mono, estéreo, 5.1 y 7.1.
• Módulo «Voces claras»: compresión de rango dinámico, downmix Mid-Side, ecualización vocal y el algoritmo Zainder completo.
• Módulo «Amplificar»: presets de ganancia (+3, +6, +10, +14 dB) o ajuste manual de 0 a 18 dB para vídeos grabados muy bajos.
• Dimensiones siempre válidas: fuerza ancho y alto pares y yuv420p de 8 bits, requisito de los codificadores MPEG-4/Xvid.
• Downmix seguro: detecta el diseño real de canales (mono, estéreo, 5.1) para no romper el filtrado con canales inexistentes.
• Nombres seguros para FAT32: elimina acentos y caracteres especiales para pendrives usados en televisores antiguos.
• Organización de la salida: patrones de nombre, subcarpetas por formato o fecha y gestión de colisiones (numerar, sobrescribir u omitir).
• Previsualización de audio del resultado antes de convertir.
• Diagnóstico integrado: botón «Ver log detallado» en cada vídeo con error, y un <nombre>_log.txt con el comando FFmpeg, el código de salida y el registro completo en la carpeta de destino.
• Pausar, reanudar y cancelar la cola.
• Interfaz en español e inglés, tema claro/oscuro y tres tamaños de fuente.

🔊 Algoritmo Zainder: claridad de voces

Cadena DSP de 8 etapas sobre dos carriles (voz en mono y fondo en estéreo):

#	Etapa	Parámetros por defecto
1	Separación de señal (canal central 5.1, separación neuronal o Mid/Side)	2 carriles
2	Filtro paso alto Butterworth	120 Hz, 12 dB/oct
3	Compresión asimétrica: voz más comprimida que el fondo	3:1 voz / 2:1 fondo
4	Ecualización de inteligibilidad	−3 dB a 350 Hz, +4 dB a 2,5 kHz, +2 dB a 4,5 kHz
5	De-esser dinámico	6,5 – 7,5 kHz
6	Rebalanceo y ducking con sidechain	voz +8 dB, fondo −3,5 dB
7	Normalización de sonoridad (ITU-R BS.1770 / EBU R128)	−16 LUFS
8	Limitador de pico verdadero	−1 dBTP

La intensidad global (0 a 1) interpola el rebalanceo, las relaciones de compresión y la ganancia del ecualizador a la vez. Los parámetros avanzados (frecuencia de corte, ganancias de EQ, ducking, de-esser, exciter, LUFS objetivo) son configurables.

Rutas de entrada disponibles:

• Ruta A: canal central real (FC) en mezclas 5.1.
• Ruta B: separación neuronal (Demucs, 3 stems).
• Ruta C: extracción ligera Mid/Side para material estéreo o mono.

🚀 Instalación y compilación

Requisitos

• Node.js (nodejs.org) (se recomienda una versión LTS reciente)
• Rust y los requisitos previos de Tauri v2
• Windows para generar el .exe (el instalador usa NSIS)
• FFmpeg y FFprobe: se descargan automáticamente al compilar

Opción 1: doble clic (Windows)

Ejecuta Crear_App_Windows.bat. Instala las dependencias, prepara FFmpeg, compila y deja los ejecutables en dist-desktop/.

Opción 2: terminal

git clone https://github.com/<tu-usuario>/tv-old-school.git
cd tv-old-school
npm install
npm run build:exe

Este comando:

1. Comprueba y prepara ffmpeg y ffprobe en src-tauri/bin/.
2. Compila la interfaz con Vite.
3. Compila el motor de escritorio en Rust con Tauri.
4. Copia los resultados a dist-desktop/.

Resultados

Archivo	Descripción
dist-desktop/TV_OldSchool_Portable.exe	Portable, sin instalación. Cópialo a un pendrive si quieres.
dist-desktop/TV_OldSchool_Instalador.exe	Instalador con accesos directos en el menú Inicio y el escritorio.
dist-desktop/bin/	ffmpeg y ffprobe para la versión portable.

La versión portable necesita la carpeta bin/ junto al ejecutable.

Scripts disponibles

Comando	Qué hace
npm run dev	Servidor de desarrollo web (Express + Vite) en http://localhost:3000
npm run build	Compila el frontend con Vite
npm run prepare:ffmpeg	Prepara ffmpeg y ffprobe en src-tauri/bin/
npm run build:exe	Compilación completa para Windows (portable + instalador)
npm run build:portable	Solo ejecutable portable
npm run build:installer	Solo instalador NSIS
npm run tauri	Acceso directo a la CLI de Tauri
npm run lint	Comprobación de tipos con tsc --noEmit
npm run clean	Elimina artefactos de compilación

🧑‍💻 Desarrollo

Hay dos modos de ejecución:

• Modo web (npm run dev): servidor Express con Vite que lanza el ffmpeg del sistema. Necesitas tener FFmpeg disponible en el PATH. Es útil para iterar rápido en la interfaz.
• Modo escritorio (Tauri): la interfaz se comunica con el backend Rust mediante comandos invoke y usa los binarios de src-tauri/bin/. Es el modo de producción.

# Modo escritorio en desarrollo
npx tauri dev

Nota: el archivo .env.example procede de la plantilla de Google AI Studio con la que nació el proyecto. El código actual no utiliza la API de Gemini, así que no necesitas configurar GEMINI_API_KEY.

🏗️ Arquitectura

tv-old-school/
├── src/                      # Frontend React + TypeScript
│   ├── App.tsx
│   ├── components/           # Pestañas (archivos, vídeo, audio, voces claras, amplificar) y modales
│   ├── services/             # tauriBridge.ts (puente con Rust), batchNaming.ts
│   ├── context/              # Ajustes de usuario (tema, idioma, tamaño de fuente)
│   ├── i18n/                 # Traducciones es / en
│   └── types/                # Tipos compartidos
├── src-tauri/                # Backend nativo en Rust
│   ├── src/commands.rs       # Comandos: probe, conversión, cancelación, diálogos, previsualización
│   ├── src/main.rs
│   ├── bin/                  # ffmpeg / ffprobe (no se versionan los .exe)
│   ├── nsis/                 # Hooks del instalador
│   └── tauri.conf.json
├── scripts/                  # prepare-ffmpeg.js, fetch-ffmpeg.ps1, build-windows-exe.js
├── server.ts                 # Servidor de desarrollo web (Express)
├── sample_media/             # Vídeos de ejemplo para pruebas
├── output_media/             # Salidas de ejemplo y logs
└── Crear_App_Windows.bat     # Compilación con doble clic

Stack: React 19 · TypeScript · Vite · Tailwind CSS 4 · Motion · Tauri v2 · Rust · FFmpeg.

Comandos Tauri expuestos

check_system_status, probe_media, run_conversion, cancel_conversion, generate_preview_audio, pick_video_files_dialog, pick_folder_dialog, expand_video_paths, open_output_folder.

🩺 Solución de problemas

Problema	Causa habitual	Solución
La conversión falla en vídeo panorámico (p. ej. 1920×803)	Dimensiones impares tras escalar	Ya corregido: se aplica scale=trunc(iw/2)*2:trunc(ih/2)*2,format=yuv420p
FFmpeg se detiene con audio mono o estéreo	Filtros que leían el canal central 5.1	Ya corregido: se detecta el diseño de canales y se hace downmix seguro
No se encuentra FFmpeg al compilar	Falta src-tauri/bin/ffmpeg(.exe)	Ejecuta npm run prepare:ffmpeg o scripts/fetch-ffmpeg.ps1
La tele no reproduce el archivo	Códec o perfil demasiado moderno	Prueba AVI Xvid/MP3 o MPEG-2, y activa los nombres seguros para FAT32
Un vídeo da error	Cualquier fallo de FFmpeg	Abre «Ver log detallado» o revisa <nombre>_log.txt en la carpeta de destino

🤝 Contribuir

Las contribuciones son bienvenidas:

1. Haz un fork del repositorio.
2. Crea una rama: git checkout -b feature/mi-mejora.
3. Comprueba los tipos con npm run lint.
4. Abre un Pull Request describiendo el cambio.

Si encuentras un error, abre un issue e incluye el _log.txt generado y el modelo de TV o reproductor.

📄 Licencia y créditos

TV OldSchool y el algoritmo Zainder se distribuyen bajo la licencia Creative Commons Attribution 4.0 International (CC BY 4.0). Puedes compartir, copiar, modificar y redistribuir el material, incluso con fines comerciales, citando la autoría y la fuente.

• Autor: @garba
• Web: www.zainder.com
• Privacidad: el procesamiento es 100 % local, sin telemetría ni cookies de seguimiento.
• Sin garantía: el software se ofrece «tal cual». Conserva siempre copias de seguridad de tus archivos originales.

FFmpeg es un proyecto independiente con su propia licencia; consulta ffmpeg.org.

⬆ Volver al inicio · 🇬🇧 English version

---

🇬🇧 English version

Convert modern video for two-speaker TVs and 2000s-era USB players, with crystal-clear dialogue.

Features · Zainder algorithm · Installation · Development · Architecture · Troubleshooting · License · ⬆ Top

📺 What is TV OldSchool?

Modern films are mixed in 5.1, with quiet dialogue and very loud music and effects. On an older TV with two small speakers, voices get lost under explosions. On top of that, many TVs with a USB port from the 2000s only play a handful of codecs.

TV OldSchool is a desktop application that solves both problems at once:

1. Compatibility: it re-encodes video into formats those TVs decode in hardware (AVI Xvid/DivX + MP3, DVD-style MPEG-2, or baseline MP4 H.264).
2. Clear voices: it applies an audio processing chain (the Zainder algorithm) that separates voice from background, boosts the dialogue and leaves the result at a loudness level comfortable for two speakers.

All processing happens on your own machine. No video, audio track or usage data is ever uploaded to external servers.

✨ Features

• Batch conversion queue: drag in files or whole folders; supports MP4, MKV, AVI, MOV, WMV, WebM, TS, VOB and more.
• Three compatibility profiles

Preset	Video	Audio	When to use it
avi_xvid_mp3	Xvid / DivX	MP3	Most compatible with 2000s TVs and players
mpeg2_dvd	MPEG-2	MP2 / PCM	DVD/DVB standard, works almost everywhere, larger files
mp4_h264	H.264 (Baseline / Main / High)	MP3 / AAC	Newer USB HD TVs (720p/1080p)

• Resolution limits: 1080p, 720p or 576p (DVD).
• Audio track selection: detects languages and picks Spanish by default; supports mono, stereo, 5.1 and 7.1.
• "Clear Voices" module: dynamic range compression, Mid-Side downmix, vocal EQ and the full Zainder algorithm.
• "Amplify" module: gain presets (+3, +6, +10, +14 dB) or manual adjustment from 0 to 18 dB for very quiet recordings.
• Always-valid dimensions: forces even width and height and 8-bit yuv420p, a requirement of MPEG-4/Xvid encoders.
• Safe downmix: detects the real channel layout (mono, stereo, 5.1) so filtering never breaks on missing channels.
• FAT32-safe filenames: strips accents and special characters for USB sticks used on older TVs.
• Output organization: naming patterns, subfolders by format or date, and collision handling (auto-number, overwrite or skip).
• Audio preview of the result before converting.
• Built-in diagnostics: a "View detailed log" button on every failed video, plus a <name>_log.txt in the destination folder with the FFmpeg command, exit code and full log.
• Pause, resume and cancel the queue.
• Interface in Spanish and English, light/dark theme and three font sizes.

🔊 Zainder algorithm: clear voices

An 8-stage DSP chain over two lanes (mono voice and stereo background):

#	Stage	Default parameters
1	Signal separation (real 5.1 center channel, neural separation or Mid/Side)	2 lanes
2	High-pass filter (Butterworth)	120 Hz, 12 dB/oct
3	Asymmetric compression: voice compressed harder than background	3:1 voice / 2:1 background
4	Intelligibility EQ	−3 dB at 350 Hz, +4 dB at 2.5 kHz, +2 dB at 4.5 kHz
5	Dynamic de-esser	6.5 – 7.5 kHz
6	Rebalance and ducking with sidechain	voice +8 dB, background −3.5 dB
7	Loudness normalization (ITU-R BS.1770 / EBU R128)	−16 LUFS
8	True-peak limiter	−1 dBTP

The global intensity (0 to 1) interpolates the rebalance, compression ratios and EQ gain at the same time. Advanced parameters (cutoff frequency, EQ gains, ducking, de-esser, exciter, target LUFS) are configurable.

Available input routes:

• Route A: real center channel (FC) in 5.1 mixes.
• Route B: neural separation (Demucs, 3 stems).
• Route C: lightweight Mid/Side extraction for stereo or mono material.

🚀 Installation and build

Requirements

• Node.js (nodejs.org) (a recent LTS version is recommended)
• Rust and the Tauri v2 prerequisites
• Windows to produce the .exe (the installer uses NSIS)
• FFmpeg and FFprobe: downloaded automatically during the build

Option 1: double-click (Windows)

Run Crear_App_Windows.bat. It installs dependencies, prepares FFmpeg, builds the app and places the executables in dist-desktop/.

Option 2: terminal

git clone https://github.com/<your-username>/tv-old-school.git
cd tv-old-school
npm install
npm run build:exe

This command:

1. Checks and prepares ffmpeg and ffprobe in src-tauri/bin/.
2. Builds the interface with Vite.
3. Builds the native desktop engine in Rust with Tauri.
4. Copies the results to dist-desktop/.

Output

File	Description
dist-desktop/TV_OldSchool_Portable.exe	Portable, no installation needed. Copy it to a USB stick if you like.
dist-desktop/TV_OldSchool_Instalador.exe	Installer with Start menu and desktop shortcuts.
dist-desktop/bin/	ffmpeg and ffprobe for the portable version.

The portable version needs the bin/ folder next to the executable.

Available scripts

Command	What it does
npm run dev	Web development server (Express + Vite) at http://localhost:3000
npm run build	Builds the frontend with Vite
npm run prepare:ffmpeg	Prepares ffmpeg and ffprobe in src-tauri/bin/
npm run build:exe	Full Windows build (portable + installer)
npm run build:portable	Portable executable only
npm run build:installer	NSIS installer only
npm run tauri	Shortcut to the Tauri CLI
npm run lint	Type check with tsc --noEmit
npm run clean	Removes build artifacts

🧑‍💻 Development

There are two run modes:

• Web mode (npm run dev): an Express server with Vite that launches the system ffmpeg. FFmpeg must be available in your PATH. Handy for fast UI iteration.
• Desktop mode (Tauri): the UI talks to the Rust backend through invoke commands and uses the binaries in src-tauri/bin/. This is the production mode.

# Desktop mode in development
npx tauri dev

Note: the .env.example file comes from the Google AI Studio template the project started from. The current code does not use the Gemini API, so you do not need to set GEMINI_API_KEY.

🏗️ Architecture

tv-old-school/
├── src/                      # React + TypeScript frontend
│   ├── App.tsx
│   ├── components/           # Tabs (files, video, audio, clear voices, amplify) and modals
│   ├── services/             # tauriBridge.ts (Rust bridge), batchNaming.ts
│   ├── context/              # User settings (theme, language, font size)
│   ├── i18n/                 # es / en translations
│   └── types/                # Shared types
├── src-tauri/                # Native Rust backend
│   ├── src/commands.rs       # Commands: probe, conversion, cancel, dialogs, preview
│   ├── src/main.rs
│   ├── bin/                  # ffmpeg / ffprobe (.exe files are not versioned)
│   ├── nsis/                 # Installer hooks
│   └── tauri.conf.json
├── scripts/                  # prepare-ffmpeg.js, fetch-ffmpeg.ps1, build-windows-exe.js
├── server.ts                 # Web development server (Express)
├── sample_media/             # Sample videos for testing
├── output_media/             # Sample outputs and logs
└── Crear_App_Windows.bat     # Double-click build

Stack: React 19 · TypeScript · Vite · Tailwind CSS 4 · Motion · Tauri v2 · Rust · FFmpeg.

Exposed Tauri commands

check_system_status, probe_media, run_conversion, cancel_conversion, generate_preview_audio, pick_video_files_dialog, pick_folder_dialog, expand_video_paths, open_output_folder.

🩺 Troubleshooting

Problem	Usual cause	Fix
Conversion fails on widescreen video (e.g. 1920×803)	Odd dimensions after scaling	Already fixed: scale=trunc(iw/2)*2:trunc(ih/2)*2,format=yuv420p is applied
FFmpeg stops on mono or stereo audio	Filters that read the 5.1 center channel	Already fixed: the channel layout is detected and a safe downmix is applied
FFmpeg not found when building	Missing src-tauri/bin/ffmpeg(.exe)	Run npm run prepare:ffmpeg or scripts/fetch-ffmpeg.ps1
The TV won't play the file	Codec or profile too modern	Try AVI Xvid/MP3 or MPEG-2, and enable FAT32-safe names
A video fails	Any FFmpeg error	Open "View detailed log" or check <name>_log.txt in the destination folder

🤝 Contributing

Contributions are welcome:

1. Fork the repository.
2. Create a branch: git checkout -b feature/my-improvement.
3. Check types with npm run lint.
4. Open a Pull Request describing the change.

If you find a bug, open an issue and include the generated _log.txt and the TV or player model.

📄 License and credits

TV OldSchool and the Zainder algorithm are distributed under the Creative Commons Attribution 4.0 International (CC BY 4.0) license. You may share, copy, modify and redistribute the material, including for commercial purposes, as long as you give credit to the author and source.

• Author: @garba
• Website: www.zainder.com
• Privacy: processing is 100% local, with no telemetry or tracking cookies.
• No warranty: the software is provided "as is". Always keep backups of your original files.

FFmpeg is an independent project with its own license; see ffmpeg.org.

⬆ Back to top · 🇪🇸 Versión en español