How to Download MKV Matroska Videos

EBML Header
Segment
  ├─ Seek Head (navigation)
  ├─ Segment Information
  ├─ Tracks (video/audio/subtitle definitions)
  ├─ Chapters (chapter information)
  ├─ Tags (metadata)
  ├─ Cues (indexing for seeking)
  └─ Cluster (actual media data)
      ├─ Timecode
      └─ Block/SimpleBlock (compressed frames)

// Check MKV file extensions
function isMKV(filename) {
  return /\.(mkv|mka|mks)$/i.test(filename);
}

// Check Matroska MIME type
function isMatroskaMimeType(mimeType) {
  return /^(video|audio)\/x-matroska$/i.test(mimeType);
}

// Browser support check (limited native support)
function supportsMKV() {
  const video = document.createElement('video');
  return !!(video.canPlayType && video.canPlayType('video/x-matroska').replace(/no/, ''));
}

// Detect MKV by EBML signature
function detectMKVHeader(arrayBuffer) {
  const view = new DataView(arrayBuffer);
  
  // Check for EBML header: 0x1A45DFA3
  const ebmlSignature = view.getUint32(0, false);
  
  if (ebmlSignature === 0x1A45DFA3) {
    // Look deeper for Matroska doctype
    const bytes = new Uint8Array(arrayBuffer.slice(0, 200));
    const str = Array.from(bytes).map(b => String.fromCharCode(b)).join('');
    
    return str.includes('matroska') || str.includes('webm');
  }
  
  return false;
}

// Detailed EBML header parsing
function parseEBMLHeader(arrayBuffer) {
  const view = new DataView(arrayBuffer);
  let offset = 0;
  
  // Parse EBML header
  const header = {
    signature: view.getUint32(offset, false), // 0x1A45DFA3
    docType: null,
    docTypeVersion: null,
    docTypeReadVersion: null
  };
  
  offset += 4;
  
  // Parse header size (variable length)
  const headerSize = parseVarInt(view, offset);
  offset += headerSize.length;
  
  const headerEnd = offset + headerSize.value;
  
  // Parse header elements
  while (offset < headerEnd && offset < arrayBuffer.byteLength - 8) {
    const elementId = parseVarInt(view, offset);
    offset += elementId.length;
    
    const elementSize = parseVarInt(view, offset);
    offset += elementSize.length;
    
    // DocType element (0x4282)
    if (elementId.value === 0x4282) {
      const docTypeBytes = new Uint8Array(arrayBuffer.slice(offset, offset + elementSize.value));
      header.docType = String.fromCharCode(...docTypeBytes);
    }
    
    offset += elementSize.value;
  }
  
  return header;
}

function parseVarInt(view, offset) {
  let firstByte = view.getUint8(offset);
  let length = 1;
  let value = firstByte;
  
  // Find the length by checking leading zeros
  while (!(firstByte & (0x80 >> (length - 1))) && length < 8) {
    length++;
  }
  
  // Remove length marker
  value &= (0xFF >> length);
  
  // Read remaining bytes
  for (let i = 1; i < length; i++) {
    value = (value << 8) | view.getUint8(offset + i);
  }
  
  return { value, length };
}

// Monitor for MKV downloads
const mkvDetector = {
  detectedFiles: new Set(),
  
  init() {
    // Override fetch
    const originalFetch = window.fetch;
    window.fetch = function(...args) {
      const url = args[0];
      
      if (typeof url === 'string' && isMKV(url)) {
        mkvDetector.detectedFiles.add(url);
        console.log('MKV detected via fetch:', url);
      }
      
      return originalFetch.apply(this, args).then(response => {
        const contentType = response.headers.get('content-type');
        if (contentType && isMatroskaMimeType(contentType)) {
          mkvDetector.detectedFiles.add(url);
          console.log('MKV detected via content-type:', url);
        }
        return response;
      });
    };
    
    // Monitor page content for MKV links
    this.scanForMKVLinks();
    this.observeDynamicContent();
  },
  
  scanForMKVLinks() {
    // Check existing links
    document.querySelectorAll('a[href$=".mkv" i], a[href$=".mka" i], a[href$=".mks" i]').forEach(link => {
      this.detectedFiles.add(link.href);
      console.log('MKV download link detected:', link.href);
    });
    
    // Check for Matroska references in text content
    const textContent = document.body.textContent || document.body.innerText;
    const mkvRegex = /https?:\/\/[^\s"'<>]+\.mkv/gi;
    const matches = textContent.match(mkvRegex);
    
    if (matches) {
      matches.forEach(url => {
        this.detectedFiles.add(url);
        console.log('MKV URL found in text:', url);
      });
    }
  },
  
  observeDynamicContent() {
    const observer = new MutationObserver((mutations) => {
      mutations.forEach((mutation) => {
        mutation.addedNodes.forEach((node) => {
          if (node.nodeType === 1) {
            // Check for new MKV links
            if (node.tagName === 'A' && isMKV(node.href)) {
              this.detectedFiles.add(node.href);
              console.log('Dynamic MKV link detected:', node.href);
            }
            
            // Check child elements
            const links = node.querySelectorAll ? node.querySelectorAll('a[href$=".mkv" i]') : [];
            links.forEach(link => {
              this.detectedFiles.add(link.href);
              console.log('Dynamic MKV link detected:', link.href);
            });
          }
        });
      });
    });
    
    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  }
};

// Initialize detector
mkvDetector.init();

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

# With progress bar
wget --progress=bar:force "https://example.com/video.mkv"

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

# Download with rate limit
wget --limit-rate=1m "https://example.com/video.mkv"

# Basic download with progress
curl --progress-bar -o video.mkv "https://example.com/video.mkv"

# Parallel downloading (if server supports ranges)
curl -r 0-499999999 "https://example.com/video.mkv" -o part1 &
curl -r 500000000- "https://example.com/video.mkv" -o part2 &
wait
cat part1 part2 > video.mkv

# With custom headers for protected content
curl -H "Referer: https://example.com/" \
     -H "User-Agent: Mozilla/5.0..." \
     -o video.mkv \
     "https://example.com/video.mkv"

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

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

# Force MKV output format (remux if needed)
yt-dlp --merge-output-format mkv "https://example.com/page-with-video"

# Download with subtitle tracks
yt-dlp --write-subs --embed-subs --sub-format best "https://example.com/page-with-video"

// Download MKV with chunk verification
class MKVDownloader {
  constructor(url, filename) {
    this.url = url;
    this.filename = filename;
    this.chunks = [];
    this.totalSize = 0;
    this.downloadedSize = 0;
  }
  
  async download(onProgress) {
    try {
      // Get total file size
      const headResponse = await fetch(this.url, { method: 'HEAD' });
      this.totalSize = parseInt(headResponse.headers.get('content-length') || '0');
      
      if (this.totalSize === 0) {
        throw new Error('Cannot determine file size');
      }
      
      // Check if server supports range requests
      const supportsRanges = headResponse.headers.get('accept-ranges') === 'bytes';
      
      if (supportsRanges && this.totalSize > 10 * 1024 * 1024) { // 10MB+
        return this.downloadInChunks(onProgress);
      } else {
        return this.downloadDirect(onProgress);
      }
    } catch (error) {
      console.error('MKV download failed:', error);
      throw error;
    }
  }
  
  async downloadInChunks(onProgress) {
    const chunkSize = 2 * 1024 * 1024; // 2MB chunks
    const numChunks = Math.ceil(this.totalSize / chunkSize);
    
    console.log(`Downloading ${this.filename} in ${numChunks} chunks`);
    
    const chunkPromises = [];
    
    for (let i = 0; i < numChunks; i++) {
      const start = i * chunkSize;
      const end = Math.min(start + chunkSize - 1, this.totalSize - 1);
      
      chunkPromises.push(this.downloadChunk(start, end, i));
    }
    
    // Download all chunks
    const chunks = await Promise.all(chunkPromises);
    
    // Verify and combine
    return this.combineChunks(chunks);
  }
  
  async downloadChunk(start, end, index) {
    const response = await fetch(this.url, {
      headers: { 'Range': `bytes=${start}-${end}` }
    });
    
    if (response.status !== 206) {
      throw new Error(`Failed to download chunk ${index}`);
    }
    
    const chunk = await response.arrayBuffer();
    return { index, start, end, data: chunk };
  }
  
  async downloadDirect(onProgress) {
    const response = await fetch(this.url);
    const reader = response.body.getReader();
    const chunks = [];
    
    while (true) {
      const { done, value } = await reader.read();
      
      if (done) break;
      
      chunks.push(value);
      this.downloadedSize += value.length;
      
      if (onProgress) {
        const progress = (this.downloadedSize / this.totalSize) * 100;
        onProgress(progress, this.downloadedSize, this.totalSize);
      }
    }
    
    return new Blob(chunks, { type: 'video/x-matroska' });
  }
  
  combineChunks(chunks) {
    // Sort chunks by index
    chunks.sort((a, b) => a.index - b.index);
    
    // Verify chunk integrity
    let expectedStart = 0;
    for (const chunk of chunks) {
      if (chunk.start !== expectedStart) {
        throw new Error(`Chunk integrity error at ${expectedStart}`);
      }
      expectedStart = chunk.end + 1;
    }
    
    // Combine all chunk data
    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.data.byteLength, 0);
    const combined = new Uint8Array(totalLength);
    
    let offset = 0;
    for (const chunk of chunks) {
      combined.set(new Uint8Array(chunk.data), offset);
      offset += chunk.data.byteLength;
    }
    
    return new Blob([combined], { type: 'video/x-matroska' });
  }
  
  async saveBlob(blob) {
    const url = URL.createObjectURL(blob);
    
    const a = document.createElement('a');
    a.href = url;
    a.download = this.filename;
    a.click();
    
    URL.revokeObjectURL(url);
    return blob;
  }
}

// Usage
const downloader = new MKVDownloader('https://example.com/video.mkv', 'video.mkv');
downloader.download((progress, downloaded, total) => {
  console.log(`Progress: ${progress.toFixed(1)}% (${downloaded}/${total} bytes)`);
}).then(blob => {
  return downloader.saveBlob(blob);
}).then(() => {
  console.log('Download completed successfully');
});

# Extract comprehensive MKV metadata
ffprobe -v quiet -print_format json -show_format -show_streams -show_chapters video.mkv

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

# List all tracks (video/audio/subtitle)
ffprobe -v quiet -show_entries stream=index,codec_type,codec_name,language -of csv="p=0" video.mkv

# Extract chapters
ffprobe -v quiet -show_chapters -of json video.mkv

# Get tags and metadata
ffprobe -v quiet -show_entries format_tags -of json video.mkv

# Detailed Matroska structure analysis
mkvinfo video.mkv

# Extract specific information
mkvinfo --ui-language en video.mkv | grep -E "(Track|Duration|Codec)"

# Check for corruption
mkvinfo video.mkv 2>&1 | grep -i "error\|warning"

# Extract specific tracks
mkvextract video.mkv tracks 0:video.h264 1:audio.aac 2:subtitles.srt

# Merge multiple files
mkvmerge -o output.mkv video1.mkv +video2.mkv

# Add subtitle track
mkvmerge -o output.mkv input.mkv subtitles.srt

# Remove unwanted tracks
mkvmerge -o output.mkv --video-tracks 0 --audio-tracks 1 --no-subtitles input.mkv

# Change track order
mkvmerge -o output.mkv --track-order 0:1,0:0,0:2 input.mkv

# Set default track flags
mkvmerge -o output.mkv --default-track 1:yes --default-track 2:no input.mkv

# Convert MKV to MP4 (copy streams if compatible)
ffmpeg -i input.mkv -c copy -movflags +faststart output.mp4

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

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

# Extract only video track
ffmpeg -i input.mkv -vn -c:a copy audio.m4a

# Extract only audio track  
ffmpeg -i input.mkv -an -c:v copy video.mkv

# Batch conversion with quality settings
for file in *.mkv; do
  ffmpeg -i "$file" -c:v libx264 -preset fast -crf 20 -c:a aac "${file%.mkv}.mp4"
done

// Analyze MKV tracks in browser
async function analyzeMKVTracks(file) {
  // This would require a WebAssembly Matroska parser
  // Simplified example showing the concept
  
  const arrayBuffer = await file.arrayBuffer();
  const header = parseEBMLHeader(arrayBuffer);
  
  console.log('Document Type:', header.docType);
  console.log('Version:', header.docTypeVersion);
  
  // In practice, you'd need a full EBML/Matroska parser
  // Libraries like matroska-js or ebml-js can help
  
  return {
    container: 'Matroska',
    docType: header.docType,
    size: file.size,
    // Additional track information would be parsed here
  };
}

// Usage with file input
document.getElementById('fileInput').addEventListener('change', async (event) => {
  const file = event.target.files[0];
  if (file && isMKV(file.name)) {
    const analysis = await analyzeMKVTracks(file);
    console.log('MKV Analysis:', analysis);
  }
});

# List subtitle tracks
mkvinfo video.mkv | grep -A 5 -B 5 "Track type: subtitles"

# Extract all subtitle tracks
for i in $(mkvmerge -i video.mkv | grep "subtitles" | cut -d':' -f1 | cut -d' ' -f3); do
  mkvextract video.mkv tracks $i:subtitle_$i.srt
done

# Extract specific subtitle language
mkvextract video.mkv tracks 2:english.srt

# Convert subtitle formats
ffmpeg -i video.mkv -c:s webvtt subtitles.vtt

# Extract chapter information
mkvextract video.mkv chapters chapters.xml

# Add chapters to MKV
mkvmerge -o output.mkv --chapters chapters.xml input.mkv

# Create simple chapters
cat > chapters.xml << EOF
<?xml version="1.0" encoding="UTF-8"?>
<Chapters>
  <EditionEntry>
    <ChapterAtom>
      <ChapterTimeStart>00:00:00.000</ChapterTimeStart>
      <ChapterDisplay>
        <ChapterString>Opening</ChapterString>
      </ChapterDisplay>
    </ChapterAtom>
    <ChapterAtom>
      <ChapterTimeStart>00:05:30.000</ChapterTimeStart>
      <ChapterDisplay>
        <ChapterString>Main Content</ChapterString>
      </ChapterDisplay>
    </ChapterAtom>
  </EditionEntry>
</Chapters>
EOF

// Check MKV playbook support and provide alternatives
function setupMKVPlayback(videoElement, mkvUrl) {
  const canPlay = videoElement.canPlayType('video/x-matroska');
  
  if (canPlay === 'probably' || canPlay === 'maybe') {
    // Native support available
    videoElement.src = mkvUrl;
    return 'native';
  } else {
    // Need alternative solution
    console.warn('Native MKV playback not supported, suggesting alternatives');
    
    // Option 1: Suggest conversion
    showConversionSuggestion(mkvUrl);
    
    // Option 2: Use Media Source Extensions with transmuxing
    if (MediaSource.isTypeSupported('video/mp4; codecs="avc1.42E01E"')) {
      return setupMSEPlayback(videoElement, mkvUrl);
    }
    
    return 'unsupported';
  }
}

function showConversionSuggestion(mkvUrl) {
  const suggestion = document.createElement('div');
  suggestion.innerHTML = `
    <p>This MKV file may not play natively in your browser.</p>
    <p>Try converting it to MP4 format:</p>
    <code>ffmpeg -i "${mkvUrl}" -c copy output.mp4</code>
  `;
  suggestion.style.cssText = 'padding: 10px; background: #f0f0f0; border: 1px solid #ccc;';
  
  document.body.appendChild(suggestion);
}

// Stream MKV with Media Source Extensions
class MKVStreamer {
  constructor(videoElement) {
    this.video = videoElement;
    this.mediaSource = null;
    this.sourceBuffer = null;
  }
  
  async stream(url) {
    if (!MediaSource.isTypeSupported('video/mp4; codecs="avc1.42E01E"')) {
      throw new Error('Browser does not support required codecs');
    }
    
    this.mediaSource = new MediaSource();
    this.video.src = URL.createObjectURL(this.mediaSource);
    
    return new Promise((resolve, reject) => {
      this.mediaSource.addEventListener('sourceopen', async () => {
        try {
          await this.setupSourceBuffer();
          await this.fetchAndAppendData(url);
          resolve();
        } catch (error) {
          reject(error);
        }
      });
    });
  }
  
  async setupSourceBuffer() {
    // This is simplified - real implementation would need proper codec detection
    this.sourceBuffer = this.mediaSource.addSourceBuffer('video/mp4; codecs="avc1.42E01E"');
    
    this.sourceBuffer.addEventListener('updateend', () => {
      if (this.mediaSource.readyState === 'open') {
        this.mediaSource.endOfStream();
      }
    });
  }
  
  async fetchAndAppendData(url) {
    // In practice, you'd need to:
    // 1. Parse MKV container
    // 2. Extract codec data
    // 3. Transmux to MP4 fragments
    // 4. Append to source buffer
    
    const response = await fetch(url);
    const data = await response.arrayBuffer();
    
    // This would need proper MKV -> MP4 transmuxing
    // Libraries like mux.js or similar would be needed
    console.log('Would transmux MKV data here:', data.byteLength, 'bytes');
  }
}

// MKV torrenting detection and download
function detectMKVTorrents() {
  const torrentLinks = [];
  
  // Check for .torrent files
  document.querySelectorAll('a[href$=".torrent" i]').forEach(link => {
    if (link.textContent.toLowerCase().includes('mkv') || 
        link.href.toLowerCase().includes('mkv')) {
      torrentLinks.push({
        type: 'torrent',
        url: link.href,
        title: link.textContent.trim()
      });
    }
  });
  
  // Check for magnet links
  document.querySelectorAll('a[href^="magnet:" i]').forEach(link => {
    if (link.href.toLowerCase().includes('mkv')) {
      torrentLinks.push({
        type: 'magnet',
        url: link.href,
        title: link.textContent.trim()
      });
    }
  });
  
  return torrentLinks;
}

// Generate download commands for MKV torrents
function generateTorrentCommands(torrents) {
  console.group('MKV Torrent Download Commands:');
  
  torrents.forEach((torrent, index) => {
    console.group(`Torrent ${index + 1}: ${torrent.title}`);
    
    if (torrent.type === 'magnet') {
      console.log('Transmission CLI:');
      console.log(`transmission-cli "${torrent.url}"`);
      
      console.log('qBittorrent CLI:');
      console.log(`qbittorrent "${torrent.url}"`);
    } else {
      console.log('wget + transmission:');
      console.log(`wget "${torrent.url}" -O movie.torrent`);
      console.log(`transmission-cli movie.torrent`);
    }
    
    console.groupEnd();
  });
  
  console.groupEnd();
}

# Check if codecs in MKV are supported
ffprobe -v error -select_streams v:0 -show_entries stream=codec_name -of csv="p=0" video.mkv

# Convert problematic codecs
ffmpeg -i input.mkv -c:v libx264 -c:a aac -c:s copy output.mkv

# Handle HDR content
ffmpeg -i hdr_video.mkv -c:v libx264 -vf "colorspace=bt709:iall=bt2020" output.mkv

# Split large MKV files
mkvmerge -o "output_%03d.mkv" --split size:4000M input.mkv

# Compress MKV without quality loss
ffmpeg -i large_video.mkv -c:v libx265 -preset medium -crf 20 -c:a copy compressed.mkv

# Try to repair corrupted MKV
ffmpeg -i corrupted.mkv -c copy -avoid_negative_ts make_zero repaired.mkv

# Extract what's recoverable
ffmpeg -i corrupted.mkv -c copy -fflags +genpts recovered.mkv

# Use mkvtoolnix for repair
mkvmerge -o repaired.mkv corrupted.mkv