Hochladen & Optimieren

Video Processing Guide

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.

Processing Architecture

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

Quality Tiers Explained

Choose a tier matching your content needs at upload initiation:

Standard web viewing with bandwidth efficiency:

  • 720p HD (1280×720) at 2.5 Mbps
  • 480p SD (854×480) at 1.0 Mbps
  • 240p Mobile (426×240) at 500 Kbps

Best for: General web content, tutorials, presentations

Supported Input Formats

Recommended for fastest processing: - MP4 - H.264/H.265 video with Opus audio - MOV - QuickTime containers (Apple ecosystem)

  • WebM - VP8/VP9 with Vorbis/Opus audio

Processing Pipeline Details

Content Analysis

Automatic metadata extraction:

  • Resolution, frame rate, and codec detection
  • Audio track analysis and separation
  • Content complexity assessment for bitrate selection
  • Aspect ratio preservation planning

Intelligent Encoding

Multi-rendition transcoding:

  • Primary codec: H.265 (HEVC) for efficiency
  • Other codec: H.264 for universal compatibility
  • Frame rate handling: 24fps to 60fps with NTSC support
  • Adaptive bitrates: Content-aware quality selection

Adaptive Streaming

Cross-platform delivery preparation:

  • HLS packaging: Apple-compatible .m3u8 playlists
  • DASH manifests: Universal .mpd format
  • 6-second segments: Efficient for low-latency streaming
  • CDN distribution: Global edge deployment

Audio Processing

RIXL conducts independent audio processing for efficient streaming:

Codec: Opus

128kbps, 48kHz for superior quality and compression

Segmentation

6-second audio segments for low-latency delivery

Independent Streaming

Audio served separately for efficient bandwidth usage

Other Support

Opus encoding for superior audio quality and compression

Advanced Processing Features

Smart Resolution Scaling

Preserves aspect ratios while targeting industry-standard resolutions

Frame Rate Intelligence

Maintains native frame rates and adapts for target platforms

HDR Processing

Supports HDR with BT.2020 color space and 10-bit encoding

Adaptive Quality Ladders

Generates multiple renditions even from low-resolution sources

Performance Characteristics

Processing Speed:

  • Basic tier: ~1x real-time processing
  • Shorts tier: ~1.5x real-time processing
  • Pro tier: ~2-3x real-time processing (4K content)

File Size Efficiency:

  • H.265 encoding: 30-50% smaller than H.264
  • Adaptive bitrates: Content-aware compression
  • Multiple renditions: Users receive the best quality for their connection

Processing Status Monitoring

Monitor your video's progress through the processing pipeline:

  • uploaded - Video successfully uploaded, awaiting processing
  • processing - Video is being transcoded and packaged
  • ready - Processing complete, available for streaming
  • error - Processing failed (check error message)

Upload Preparation Guidelines

Source File Recommendations:

Format: MP4 + H.264

Fastest processing with universal compatibility

Resolution: Upload Highest Available

Up to 4K for Pro tier, system scales down appropriately

Frame Rate: 30fps or 60fps

Standard rates for efficient processing and compatibility

Audio: Opus Codec

Best compatibility and quality for source material

Large File Handling:

  • Multipart uploads automatically enabled for files >100MB
  • Resume capability for interrupted uploads
  • Parallel processing of multiple quality renditions

Implementation Best Practices

Quality Tier Selection:

  • Basic: Standard web content, bandwidth-conscious delivery
  • Shorts: Mobile-first content, social media delivery
  • Pro: Professional broadcasts, premium content experiences

Processing Efficiency:

  • Upload during off-peak hours for faster processing
  • Use recommended formats (MP4/H.264) to minimize processing time
  • Monitor processing status rather than polling continuously
  • Implement retry logic for failed uploads

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}`);
  };

Security and Access Control

Upload Security:

  • Time-limited signed URLs (valid for 1 hour)
  • MIME type and content validation

Delivery Security:

  • Project-scoped access controls

Troubleshooting Common Issues

Upload Failures:

  • Verify file size under 2GB limit
  • Check network stability for large files
  • Ensure the signed URL hasn't expired

Processing Delays:

  • Check current queue status via API
  • Contact support for processing over 2 hours
  • Consider using the Basic tier for faster turnaround

Playback Issues:

  • Verify all renditions have completed processing
  • Check CDN propagation status
  • Test with different quality levels

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.