Video Processing Guide
Complete guide to automated video transcoding system producing multiple quality levels and adaptive streaming formats for efficient delivery on any device.
Complete guide to automated video transcoding system producing multiple quality levels and adaptive streaming formats for efficient delivery on any device.
Coming soon: Advanced video processing will include AI-powered thumbnail generation and automated chapter detection, allowing for smarter preview selection and seamless navigation.
Once video upload is complete, RIXL encodes the file into various quality levels and adaptive streaming formats for reliable playback across all devices and network conditions.
Video processing uses a three-phase pipeline converting uploaded content into streaming-ready assets:
Analysis & Planning - Content analysis determines optimal rendition ladder
Multi-Quality Encoding - Parallel transcoding to multiple resolutions and bitrates
Adaptive Stream Packaging - HLS/DASH manifest generation for seamless delivery
Choose a tier matching your content needs at upload initiation:
Standard web viewing with bandwidth efficiency:
Best for: General web content, tutorials, presentations
Recommended for fastest processing: - MP4 - H.264/H.265 video with Opus audio - MOV - QuickTime containers (Apple ecosystem)
Automatic metadata extraction:
Multi-rendition transcoding:
Cross-platform delivery preparation:
.m3u8 playlists.mpd formatRIXL conducts independent audio processing for efficient streaming:
Processing Speed:
File Size Efficiency:
Monitor your video's progress through the processing pipeline:
uploaded - Video successfully uploaded, awaiting processingprocessing - Video is being transcoded and packagedready - Processing complete, available for streamingerror - Processing failed (check error message)Source File Recommendations:
Large File Handling:
Quality Tier Selection:
Processing Efficiency:
Error Handling:
/**
* Video upload with TypeScript and comprehensive error handling
*/
interface VideoUploadOptions {
file_name: string;
video_quality: 'basic' | 'shorts' | 'pro';
image_format: 'jpg' | 'png' | 'webp';
}
interface UploadResponse {
video_id: string;
video_presigned_url: string;
expires_at: string;
}
async function uploadVideo(
videoFile: File,
apiKey: string,
options: VideoUploadOptions
): Promise
<string> {
try {
// Step 1: Initialize upload
const initResponse = await fetch('https://api.rixl.com/videos/upload/init', {
method: 'POST',
headers: {
'X-API-Key': apiKey,
'Content-Type': 'application/json',
'Accept': 'application/json'
},
body: JSON.stringify(options)
});
if (!initResponse.ok) {
const errorData = await initResponse.json().catch(() => ({}));
throw new Error(`Upload initialization failed: ${errorData.message || initResponse.statusText}`);
}
const uploadData: UploadResponse = await initResponse.json();
// Step 2: Upload video file
const videoUpload = await fetch(uploadData.video_presigned_url, {
method: 'PUT',
body: videoFile,
headers: {
'Content-Type': videoFile.type || 'video/mp4'
}
});
if (!videoUpload.ok) {
throw new Error(`Video upload failed: ${videoUpload.statusText}`);
}
// Step 3: Complete upload
const completeResponse = await fetch(
`https://api.rixl.com/videos/${uploadData.video_id}/upload/complete/`,
{
method: 'POST',
headers: {
'X-API-Key': apiKey,
'Content-Type': 'application/json'
}
}
);
if (!completeResponse.ok) {
const errorData = await completeResponse.json().catch(() => ({}));
throw new Error(`Upload completion failed: ${errorData.message || completeResponse.statusText}`);
}
console.log('Video processing started successfully!');
return uploadData.video_id;
} catch (error) {
console.error('Upload failed:', error);
throw error;
}
}
// Usage example
const handleUpload = async (file: File) => {
const videoId = await uploadVideo(file, 'YOUR_PROJECT_API_KEY', {
file_name: file.name,
video_quality: 'pro',
image_format: 'jpg'
});
console.log(`Upload successful! Video ID: ${videoId}`);
};Upload Security:
Delivery Security:
Upload Failures:
Processing Delays:
Playback Issues:
RIXL's video processing automatically prepares your content for all viewing scenarios, from mobile users on slow connections to desktop viewers with high-speed internet. The adaptive streaming ensures the best possible experience for each viewer.