How to Download MOV QuickTime Videos

File Type Atom (ftyp)
Media Data Atom (mdat)
Movie Atom (moov)
  ├─ Movie Header Atom (mvhd)
  ├─ Track Atom (trak)
  │   ├─ Track Header Atom (tkhd)
  │   ├─ Media Atom (mdia)
  │   └─ ...
  └─ User Data Atom (udta)

// Check MOV file extension
function isMOV(filename) {
  return /\.(mov|qt)$/i.test(filename);
}

// Check QuickTime MIME type
function isQuickTimeMimeType(mimeType) {
  return /^video\/(quicktime|x-quicktime)$/i.test(mimeType);
}

// Browser support check (limited on non-Safari browsers)
function supportsMOV() {
  const video = document.createElement('video');
  return !!(video.canPlayType && video.canPlayType('video/quicktime').replace(/no/, ''));
}

// Detect MOV by file signature
function detectMOVHeader(arrayBuffer) {
  const view = new DataView(arrayBuffer);
  
  // Check for ftyp box at offset 4
  const ftyp = String.fromCharCode(
    view.getUint8(4), view.getUint8(5), view.getUint8(6), view.getUint8(7)
  );
  
  if (ftyp === 'ftyp') {
    // Check for QuickTime brand
    const brand = String.fromCharCode(
      view.getUint8(8), view.getUint8(9), view.getUint8(10), view.getUint8(11)
    );
    
    // Common MOV brands
    const movBrands = ['qt  ', 'QTIF', 'QTIM', 'MSNV'];
    return movBrands.includes(brand);
  }
  
  return false;
}

// Alternative: Check for moov atom
function detectMOVByMovieAtom(arrayBuffer) {
  const bytes = new Uint8Array(arrayBuffer.slice(0, 1000));
  const str = Array.from(bytes).map(b => String.fromCharCode(b)).join('');
  
  // Look for 'moov' atom which is characteristic of QuickTime
  return str.includes('moov');
}

// Monitor for MOV downloads
const movDetector = {
  detectedFiles: new Set(),
  
  init() {
    // Override fetch
    const originalFetch = window.fetch;
    window.fetch = function(...args) {
      const url = args[0];
      
      if (typeof url === 'string' && isMOV(url)) {
        movDetector.detectedFiles.add(url);
        console.log('MOV detected via fetch:', url);
      }
      
      return originalFetch.apply(this, args).then(response => {
        const contentType = response.headers.get('content-type');
        if (contentType && isQuickTimeMimeType(contentType)) {
          movDetector.detectedFiles.add(url);
          console.log('MOV detected via content-type:', url);
        }
        return response;
      });
    };
    
    // Monitor video elements
    this.observeVideoElements();
  },
  
  observeVideoElements() {
    // Check existing video elements
    document.querySelectorAll('video').forEach(video => {
      if (video.src && isMOV(video.src)) {
        this.detectedFiles.add(video.src);
        console.log('MOV video element detected:', video.src);
      }
      
      // Check source children
      video.querySelectorAll('source').forEach(source => {
        if ((source.src && isMOV(source.src)) || 
            (source.type && isQuickTimeMimeType(source.type))) {
          this.detectedFiles.add(source.src);
          console.log('MOV source element detected:', source.src);
        }
      });
    });
    
    // Monitor for new video elements
    const observer = new MutationObserver((mutations) => {
      mutations.forEach((mutation) => {
        mutation.addedNodes.forEach((node) => {
          if (node.nodeType === 1) {
            if (node.tagName === 'VIDEO' && node.src && isMOV(node.src)) {
              this.detectedFiles.add(node.src);
            }
            
            // Check child video elements
            const videos = node.querySelectorAll ? node.querySelectorAll('video') : [];
            videos.forEach(video => {
              if (video.src && isMOV(video.src)) {
                this.detectedFiles.add(video.src);
              }
            });
          }
        });
      });
    });
    
    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  }
};

// Initialize detector
movDetector.init();

# Simple wget download
wget "https://example.com/video.mov"

# With custom headers (important for some servers)
wget --header="Accept: video/quicktime, video/*, */*" \
     --header="User-Agent: QuickTime/7.79" \
     "https://example.com/video.mov"

# Resume partial download
wget -c "https://example.com/video.mov"

# Basic download with QuickTime-specific headers
curl -H "Accept: video/quicktime" \
     -H "User-Agent: QuickTime/7.79" \
     -o video.mov \
     "https://example.com/video.mov"

# With authentication for protected content
curl -u username:password \
     -H "Accept: video/quicktime" \
     -o video.mov \
     "https://example.com/protected/video.mov"

# Resume interrupted download
curl -C - -o video.mov "https://example.com/video.mov"

# Extract and download MOV from web pages
yt-dlp -f "mov/best" "https://example.com/page-with-video"

# Prefer MOV container
yt-dlp -f "best[ext=mov]" "https://example.com/page-with-video"

# Force MOV output format
yt-dlp --remux-video mov "https://example.com/page-with-video"

// Download MOV with browser compatibility checking
async function downloadMOV(url, filename, onProgress) {
  try {
    // Check if browser supports QuickTime
    const supportsQT = supportsMOV();
    
    if (!supportsQT) {
      console.warn('Browser may not support MOV playback natively');
    }
    
    const response = await fetch(url, {
      headers: {
        'Accept': 'video/quicktime, video/*, */*'
      }
    });
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    
    const contentLength = response.headers.get('content-length');
    const totalBytes = contentLength ? parseInt(contentLength, 10) : 0;
    
    const reader = response.body.getReader();
    const chunks = [];
    let receivedBytes = 0;
    
    while (true) {
      const { done, value } = await reader.read();
      
      if (done) break;
      
      chunks.push(value);
      receivedBytes += value.length;
      
      if (onProgress && totalBytes > 0) {
        const progress = (receivedBytes / totalBytes) * 100;
        onProgress(progress, receivedBytes, totalBytes);
      }
    }
    
    // Create blob and download
    const blob = new Blob(chunks, { type: 'video/quicktime' });
    const downloadUrl = URL.createObjectURL(blob);
    
    const a = document.createElement('a');
    a.href = downloadUrl;
    a.download = filename;
    a.click();
    
    // Cleanup
    URL.revokeObjectURL(downloadUrl);
    
    return blob;
  } catch (error) {
    console.error('MOV download failed:', error);
    throw error;
  }
}

// Usage with progress callback
downloadMOV('https://example.com/video.mov', 'downloaded.mov', 
  (progress, received, total) => {
    console.log(`Download progress: ${progress.toFixed(1)}% (${received}/${total} bytes)`);
  }
);

# Extract MOV metadata using ffprobe
ffprobe -v quiet -print_format json -show_format -show_streams video.mov

# Get QuickTime-specific metadata
ffprobe -v quiet -show_entries format_tags -of json video.mov

# Get track information
ffprobe -v quiet -select_streams v:0 -show_entries stream=codec_name,width,height,r_frame_rate,bit_rate -of csv="p=0" video.mov

# Check for ProRes codec
ffprobe -v quiet -select_streams v:0 -show_entries stream=codec_name -of csv="p=0" video.mov | grep prores

# Convert MOV to MP4 (most compatible)
ffmpeg -i input.mov -c copy output.mp4

# Convert with re-encoding for better compatibility
ffmpeg -i input.mov -c:v libx264 -preset medium -crf 23 -c:a aac -b:a 128k output.mp4

# Convert to WebM
ffmpeg -i input.mov -c:v libvpx-vp9 -crf 30 -c:a libopus -b:a 128k output.webm

# Preserve ProRes quality (if source is ProRes)
ffmpeg -i input.mov -c:v prores -profile:v 3 -c:a pcm_s24le output_prores.mov

# Batch conversion
for file in *.mov; do
  ffmpeg -i "$file" -c:v libx264 -c:a aac "${file%.mov}.mp4"
done

# Extract QuickTime reference movies
ffmpeg -i reference.mov -c copy extracted.mov

# Handle QuickTime chapters
ffmpeg -i input.mov -map_chapters 0 -c copy output.mov

# Extract QuickTime timecode track
ffmpeg -i input.mov -map 0:d:0 -c copy timecode.mov

// Detect ProRes codec in MOV files
function detectProResInMOV(videoElement) {
  videoElement.addEventListener('loadedmetadata', () => {
    // This is a simplified detection - real implementation would need server-side analysis
    const src = videoElement.src || videoElement.currentSrc;
    
    if (isMOV(src)) {
      console.log('MOV file detected, checking for ProRes...');
      
      // In practice, you'd need to analyze the codec info via API or server
      analyzeVideoCodec(src).then(codecInfo => {
        if (codecInfo.video_codec?.includes('prores')) {
          console.log('ProRes detected:', codecInfo.video_codec);
          showProResWarning();
        }
      });
    }
  });
}

function showProResWarning() {
  const warning = document.createElement('div');
  warning.innerHTML = `
    <div style="padding: 10px; background: #fff3cd; border: 1px solid #ffc107; color: #856404; margin: 10px;">
      <strong>ProRes Video Detected</strong><br>
      This high-quality video format may require specialized software for editing.
      Consider converting to H.264 for wider compatibility.
    </div>
  `;
  document.body.insertBefore(warning, document.body.firstChild);
}

async function analyzeVideoCodec(videoUrl) {
  // This would typically be a server-side analysis
  try {
    const response = await fetch(`/api/analyze-video?url=${encodeURIComponent(videoUrl)}`);
    return await response.json();
  } catch (error) {
    console.error('Codec analysis failed:', error);
    return {};
  }
}

// Detect Final Cut Pro markers and metadata
function parseFinalCutProMetadata(movFile) {
  // This would require specialized MOV parsing libraries
  return {
    markers: [],
    colorSpace: 'unknown',
    timecode: 'unknown',
    project: 'unknown'
  };
}

// Detect Apple device capabilities
function detectAppleDeviceSupport() {
  const isMac = /Mac|iP(ad|hone|od)/.test(navigator.userAgent);
  const supportsMOV = supportsMOV();
  
  return {
    isAppleDevice: isMac,
    nativeSupport: supportsMOV,
    recommended: isMac && supportsMOV
  };
}

// Provide platform-specific recommendations
function provideMOVRecommendations() {
  const support = detectAppleDeviceSupport();
  
  if (support.isAppleDevice) {
    console.log('Apple device detected - MOV files should play natively');
    return 'native';
  } else {
    console.log('Non-Apple device - consider MP4 conversion for better compatibility');
    return 'convert';
  }
}

// Detect QuickTime Player plugin (legacy)
function detectQuickTimePlugin() {
  const plugins = Array.from(navigator.plugins);
  
  const qtPlugin = plugins.find(plugin => 
    plugin.name.toLowerCase().includes('quicktime') ||
    plugin.description.toLowerCase().includes('quicktime')
  );
  
  if (qtPlugin) {
    console.log('QuickTime plugin detected:', qtPlugin.name);
    return {
      available: true,
      name: qtPlugin.name,
      version: qtPlugin.version || 'unknown'
    };
  }
  
  return { available: false };
}

// Handle QuickTime reference movies
async function handleReferenceMOV(movUrl) {
  try {
    const response = await fetch(movUrl);
    const arrayBuffer = await response.arrayBuffer();
    
    // Check if it's a reference movie (small file that points to actual media)
    if (arrayBuffer.byteLength < 10000) { // Likely a reference
      console.log('Possible QuickTime reference movie detected');
      
      // Parse reference to find actual media URLs
      const references = parseQuickTimeReferences(arrayBuffer);
      return references;
    }
    
    return [movUrl]; // Regular MOV file
  } catch (error) {
    console.error('Failed to analyze MOV file:', error);
    return [movUrl];
  }
}

function parseQuickTimeReferences(arrayBuffer) {
  // Simplified reference parsing
  const view = new DataView(arrayBuffer);
  const references = [];
  
  // This would need a full QuickTime atom parser
  // For now, return the original URL
  return references;
}

// Simple MOV streaming server in Node.js
const fs = require('fs');
const path = require('path');
const http = require('http');

class MOVStreamingServer {
  constructor(port = 8080) {
    this.port = port;
    this.server = null;
  }
  
  start() {
    this.server = http.createServer((req, res) => {
      const filePath = path.join(__dirname, 'videos', req.url);
      
      if (!fs.existsSync(filePath) || !filePath.endsWith('.mov')) {
        res.writeHead(404);
        res.end('File not found');
        return;
      }
      
      const stat = fs.statSync(filePath);
      const fileSize = stat.size;
      const range = req.headers.range;
      
      // Set QuickTime-specific headers
      const headers = {
        'Content-Type': 'video/quicktime',
        'Accept-Ranges': 'bytes',
        'Cache-Control': 'no-cache'
      };
      
      if (range) {
        // Handle range requests for seeking
        const parts = range.replace(/bytes=/, "").split("-");
        const start = parseInt(parts[0], 10);
        const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
        const chunksize = (end - start) + 1;
        
        const file = fs.createReadStream(filePath, { start, end });
        
        headers['Content-Range'] = `bytes ${start}-${end}/${fileSize}`;
        headers['Content-Length'] = chunksize;
        
        res.writeHead(206, headers);
        file.pipe(res);
      } else {
        // Regular request
        headers['Content-Length'] = fileSize;
        
        res.writeHead(200, headers);
        fs.createReadStream(filePath).pipe(res);
      }
    });
    
    this.server.listen(this.port, () => {
      console.log(`MOV streaming server running on port ${this.port}`);
    });
  }
  
  stop() {
    if (this.server) {
      this.server.close();
    }
  }
}

// Usage
const server = new MOVStreamingServer(8080);
server.start();

// Handle MOV compatibility issues
function handleMOVCompatibility(videoElement) {
  const src = videoElement.src;
  
  if (isMOV(src) && !supportsMOV()) {
    // Suggest alternatives
    const altFormats = [
      src.replace('.mov', '.mp4'),
      src.replace('.mov', '.webm'),
      src.replace('.mov', '.ogg')
    ];
    
    console.log('MOV not supported, trying alternatives:', altFormats);
    
    // Try alternative formats
    tryAlternativeFormats(videoElement, altFormats);
  }
}

function tryAlternativeFormats(videoElement, formats) {
  let currentIndex = 0;
  
  function tryNext() {
    if (currentIndex >= formats.length) {
      console.error('No compatible format found');
      return;
    }
    
    const format = formats[currentIndex];
    currentIndex++;
    
    // Test if format exists
    fetch(format, { method: 'HEAD' })
      .then(response => {
        if (response.ok) {
          videoElement.src = format;
          console.log('Using alternative format:', format);
        } else {
          tryNext();
        }
      })
      .catch(() => tryNext());
  }
  
  tryNext();
}

# Handle large MOV files efficiently
# Split large MOV files
ffmpeg -i large_video.mov -t 00:10:00 -c copy part1.mov
ffmpeg -i large_video.mov -ss 00:10:00 -c copy part2.mov

# Compress MOV while maintaining quality
ffmpeg -i large_video.mov -c:v libx264 -preset slow -crf 18 -c:a copy compressed.mov

# Try to repair corrupted MOV files
ffmpeg -i corrupted.mov -c copy -movflags +faststart repaired.mov

# Extract what's recoverable
ffmpeg -i corrupted.mov -c copy -avoid_negative_ts make_zero recovered.mov