Tauri Plugin FFmpeg

A cross-platform Tauri plugin for media transcoding using FFmpeg. Supports both desktop (Windows, macOS, Linux) and mobile (Android, iOS) platforms.

Features

• Video Transcoding: Convert videos to MP4 format with hardware acceleration support
• Audio Transcoding: Convert audio files to MP3 format
• Progress Callback: Real-time transcoding progress updates
• Cross-Platform: Works on desktop (exe) and mobile (FFmpegKit)
• Hardware Acceleration: Automatically detects and uses hardware encoders when available

Installation

Install the Plugin

npm install tauri-plugin-ffmpeg-api
# or
yarn add tauri-plugin-ffmpeg-api
# or
pnpm add tauri-plugin-ffmpeg-api

Add the plugin to your Cargo.toml:

[dependencies]
tauri-plugin-ffmpeg = { path = "path/to/tauri-plugin-ffmpeg" }

Register the Plugin

In your Tauri application's main.rs or lib.rs:

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_ffmpeg::init())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

Permissions

Add the plugin permissions to your capabilities configuration:

{
  "permissions": [
    "ffmpeg:default"
  ]
}

Usage

Basic Example

import { transcodeVideo, transcodeAudio, onProgress } from 'tauri-plugin-ffmpeg-api'

// Listen to progress events
const unlisten = await onProgress((payload) => {
  console.log(`Progress: ${payload.progress}%`)
  if (payload.currentTimeMs && payload.totalDurationMs) {
    const elapsed = (payload.currentTimeMs / 1000).toFixed(1)
    const total = (payload.totalDurationMs / 1000).toFixed(1)
    console.log(`Time: ${elapsed}s / ${total}s`)
  }
})

// Transcode video to MP4
const videoResult = await transcodeVideo(
  '/path/to/input.avi',
  '/path/to/output.mp4'
)

if (videoResult.success) {
  console.log('Video transcoded successfully:', videoResult.outputPath)
} else {
  console.error('Video transcode failed:', videoResult.error)
}

// Transcode audio to MP3
const audioResult = await transcodeAudio(
  '/path/to/input.wav',
  '/path/to/output.mp3'
)

if (audioResult.success) {
  console.log('Audio transcoded successfully:', audioResult.outputPath)
} else {
  console.error('Audio transcode failed:', audioResult.error)
}

// Clean up listener when done
unlisten()

Advanced Usage

import { transcode, MediaType, onProgress } from 'tauri-plugin-ffmpeg-api'

// Custom FFmpeg path (desktop only)
const result = await transcode({
  inputPath: '/path/to/input.mkv',
  outputPath: '/path/to/output.mp4',
  mediaType: MediaType.Video,
  ffmpegPath: '/custom/path/to/ffmpeg' // optional
})

API Reference

transcode(options: TranscodeOptions): Promise<TranscodeResult>

Transcode a media file (video or audio).

Parameters:

• options.inputPath (string): Path to the input file
• options.outputPath (string): Path to the output file
• options.mediaType (MediaType): Type of media (MediaType.Video or MediaType.Audio)
• options.ffmpegPath (string, optional): Custom FFmpeg executable path (desktop only)

Returns: Promise<TranscodeResult>

transcodeVideo(inputPath: string, outputPath: string, ffmpegPath?: string): Promise<TranscodeResult>

Convenience method to transcode video to MP4 with hardware acceleration.

transcodeAudio(inputPath: string, outputPath: string, ffmpegPath?: string): Promise<TranscodeResult>

Convenience method to transcode audio to MP3.

onProgress(handler: (payload: ProgressPayload) => void): Promise<UnlistenFn>

Listen to transcoding progress events.

Parameters:

• handler: Callback function that receives progress updates

Returns: Promise<UnlistenFn> - Function to stop listening

Progress Payload:

• progress (number): Progress percentage (0-100), -1 indicates error
• currentTimeMs (number, optional): Current processing time in milliseconds
• totalDurationMs (number, optional): Total duration in milliseconds

Platform-Specific Details

Desktop (Windows, macOS, Linux)

• Uses FFmpeg executable
• Automatically detects hardware encoders:
  • macOS: h264_videotoolbox
  • Windows: h264_nvenc (NVIDIA), h264_qsv (Intel), h264_amf (AMD)
  • Linux: h264_v4l2m2m
  • Fallback: libx264 (software encoding)
• Requires FFmpeg to be installed or provided via ffmpegPath

Mobile (Android)

• Uses FFmpegKit library
• Hardware acceleration via h264_mediacodec
• Automatically manages temporary files
• Progress updates via FFmpegKit statistics callback

Mobile (iOS)

• Uses FFmpegKit library (implementation pending)

Video Encoding

Format: MP4 (H.264 + AAC) Encoder Priority (desktop):

1. h264_videotoolbox (macOS)
2. h264_nvenc (NVIDIA GPU)
3. h264_qsv (Intel Quick Sync)
4. h264_amf (AMD GPU)
5. h264_v4l2m2m (Linux)
6. libx264 (software fallback)

Mobile: h264_mediacodec (Android)

Audio Encoding

Format: MP3 Encoder: libmp3lame Quality: VBR quality 2 (high quality)

License

MIT

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Roadmap

• Windows desktop support
• Android mobile support
• macOS desktop support (implementation complete, testing pending)
• Linux desktop support (implementation complete, testing pending)
• iOS mobile support
• Custom encoding parameters
• Multiple output formats
• Video filters support