Vytváření video kodeku v Pythonu: Hluboký ponor do kompresních algoritmů

V našem hyperpropojeném světě vládne video. Od streamovacích služeb a videokonferencí po kanály sociálních médií, digitální video dominuje internetovému provozu. Jak je ale možné poslat film ve vysokém rozlišení přes standardní internetové připojení? Odpověď spočívá v fascinujícím a komplexním oboru: komprese videa. Srdcem této technologie je video kodek (COder-DECoder), sofistikovaný soubor algoritmů navržených k drastickému snížení velikosti souboru při zachování vizuální kvality.

Zatímco průmyslové standardní kodeky jako H.264, HEVC (H.265) a bezlicenční AV1 jsou neuvěřitelně komplexní inženýrská díla, pochopení jejich základních principů je dostupné každému motivovanému vývojáři. Tento průvodce vás zavede na cestu hluboko do světa komprese videa. Nebudeme jen mluvit o teorii; postavíme zjednodušený, vzdělávací video kodek od základů pomocí Pythonu. Tento praktický přístup je nejlepší způsob, jak pochopit elegantní myšlenky, které umožňují moderní streamování videa.

Proč Python? I když to není jazyk, který byste použili pro komerční kodek s vysokým výkonem v reálném čase (které jsou obvykle psány v C/C++ nebo dokonce v assembleru), čitelnost Pythonu a jeho výkonné knihovny jako NumPy, SciPy a OpenCV z něj dělají perfektní prostředí pro učení, prototypování a výzkum. Můžete se soustředit na algoritmy, aniž byste se zdržovali správou paměti na nízké úrovni.

Pochopení základních konceptů komprese videa

Než napíšeme jediný řádek kódu, musíme pochopit, čeho se snažíme dosáhnout. Cílem komprese videa je eliminovat redundantní data. Syrové, nekomprimované video je kolosální. Jedna minuta 1080p videa při 30 snímcích za sekundu může přesáhnout 7 GB. Abychom zkrotili toto datové monstrum, využíváme dva hlavní typy redundance.

Dva pilíře komprese: Prostorová a časová redundance

• Prostorová (Intra-snímek) Redundance: Jedná se o redundanci v rámci jednoho snímku. Představte si velkou plochu modré oblohy nebo bílou zeď. Místo ukládání hodnoty barvy pro každý jednotlivý pixel v dané oblasti ji můžeme popsat efektivněji. To je stejný princip, na kterém jsou založeny formáty komprese obrazu, jako je JPEG.
• Časová (Mezi-snímková) Redundance: Jedná se o redundanci mezi po sobě jdoucími snímky. Ve většině videí se scéna od jednoho snímku k druhému úplně nemění. Například osoba mluvící na statickém pozadí má obrovské množství časové redundance. Pozadí zůstává stejné; pohybuje se pouze malá část obrazu (obličej a tělo osoby). To je nejvýznamnější zdroj komprese ve videu.

Klíčové typy snímků: I-snímky, P-snímky a B-snímky

Pro využití časové redundance kodeky nezacházejí s každým snímkem stejně. Kategorizují je do různých typů a vytvářejí sekvenci nazvanou Skupina obrázků (GOP).

• I-snímek (Intra-kódovaný snímek): I-snímek je kompletní, samostatný obraz. Je komprimován pouze pomocí prostorové redundance, podobně jako JPEG. I-snímky slouží jako kotevní body ve video proudu, což divákovi umožňuje spustit přehrávání nebo přeskočit na novou pozici. Jsou největším typem snímků, ale jsou nezbytné pro regeneraci videa.
• P-snímek (Předpovězený snímek): P-snímek je kódován tak, že se dívá na předchozí I-snímek nebo P-snímek. Místo ukládání celého obrazu ukládá pouze rozdíly. Například ukládá instrukce jako "vezměte tento blok pixelů z posledního snímku, posuňte ho o 5 pixelů doprava a zde jsou drobné barevné změny." Toho je dosaženo procesem zvaným odhad pohybu.
• B-snímek (Obousměrně předpovězený snímek): B-snímek je nejúčinnější. Může použít jak předchozí, tak následující snímek jako reference pro předpověď. To je užitečné pro scény, kde je objekt dočasně skryt a poté se znovu objeví. Díváním se dopředu i dozadu může kodek vytvořit přesnější a datově efektivnější předpověď. Použití budoucích snímků však zavádí malé zpoždění (latenci), což je činí méně vhodnými pro aplikace v reálném čase, jako jsou videohovory.

Typická GOP může vypadat takto: I B B P B B P B B I .... Kodér rozhoduje o optimálním vzoru snímků pro vyvážení účinnosti komprese a možnosti vyhledávání.

Kompresní pipeline: Podrobný rozbor krok za krokem

Moderní kódování videa je vícestupňová pipeline. Každá fáze transformuje data, aby byla lépe komprimovatelná. Pojďme si projít klíčové kroky pro kódování jednoho snímku.

Krok 1: Konverze barevného prostoru (RGB na YCbCr)

Většina videí začíná v barevném prostoru RGB (červená, zelená, modrá). Lidské oko je však mnohem citlivější na změny jasu (luma) než na změny barev (chroma). Kodeky toho využívají převodem RGB na formát luma/chroma, jako je YCbCr.

• Y: Složka luma (jas).
• Cb: Složka chroma s modrým rozdílem.
• Cr: Složka chroma s červeným rozdílem.

Oddělením jasu od barvy můžeme aplikovat chroma subsampling. Tato technika snižuje rozlišení barevných kanálů (Cb a Cr) a zároveň zachovává plné rozlišení pro jasový kanál (Y), na který jsou naše oči nejcitlivější. Běžné schéma je 4:2:0, které zahazuje 75 % barevných informací téměř bez vnímatelné ztráty kvality, čímž dosahuje okamžité komprese.

Krok 2: Rozdělení snímku (Makrobloky)

Kodér nezpracovává celý snímek najednou. Rozděluje snímek na menší bloky, typicky 16x16 nebo 8x8 pixelů, nazývané makrobloky. Všechny následující kroky zpracování (predikce, transformace atd.) se provádějí blok po bloku.

Krok 3: Predikce (Mezi-snímková a Intra-snímková)

Zde se děje kouzlo. Pro každý makroblok se kodér rozhoduje, zda použije intra-snímkovou nebo mezi-snímkovou predikci.

• Pro I-snímek (Intra-predikce): Kodér předpovídá aktuální blok na základě pixelů svých již zakódovaných sousedů (bloky nahoře a vlevo) v rámci stejného snímku. Poté stačí zakódovat pouze malý rozdíl (reziduum) mezi predikcí a skutečným blokem.
• Pro P-snímek nebo B-snímek (Mezi-predikce): Toto je odhad pohybu. Kodér hledá odpovídající blok v referenčním snímku. Když najde nejlepší shodu, zaznamená vektor pohybu (např. "posunout 10 pixelů doprava, 2 pixely dolů") a vypočítá reziduum. Často je reziduum blízké nule, což vyžaduje velmi málo bitů k zakódování.

Krok 4: Transformace (např. Diskrétní kosinová transformace - DCT)

Po predikci máme zbytkový blok. Tento blok je prohnán matematickou transformací, jako je Diskrétní kosinová transformace (DCT). DCT sama o sobě data nekomprimuje, ale zásadně mění způsob jejich reprezentace. Převádí prostorové hodnoty pixelů na frekvenční koeficienty. Kouzlo DCT spočívá v tom, že u většiny přirozených obrázků koncentruje většinu vizuální energie do pouhých několika koeficientů v levém horním rohu bloku (nízkofrekvenční složky), zatímco zbytek koeficientů (vysokofrekvenční šum) se blíží nule.

Krok 5: Kvantizace

Toto je primární ztrátový krok v pipeline a klíč k řízení kompromisu mezi kvalitou a datovým tokem. Transformovaný blok DCT koeficientů je vydělen kvantizační maticí a výsledky jsou zaokrouhleny na nejbližší celé číslo. Kvantizační matice má větší hodnoty pro vysokofrekvenční koeficienty, čímž mnoho z nich efektivně potlačuje na nulu. Zde se zahazuje obrovské množství dat. Vyšší kvantizační parametr vede k více nulám, vyšší kompresi a nižší vizuální kvalitě (často viditelné jako blokové artefakty).

Krok 6: Entropické kódování

Závěrečnou fází je bezztrátová komprese. Kvantizované koeficienty, vektory pohybu a další metadata jsou skenovány a převedeny na binární proud. Používají se techniky jako kódování délek běhu (RLE) a Huffmanovo kódování nebo pokročilejší metody jako CABAC (Context-Adaptive Binary Arithmetic Coding). Tyto algoritmy přiřazují kratší kódy častějším symbolům (jako je mnoho nul vytvořených kvantizací) a delší kódy méně častým, čímž z datového proudu vytěsňují poslední bity.

Dekodér jednoduše provádí tyto kroky v opačném pořadí: Entropické dekódování -> Inverzní kvantizace -> Inverzní transformace -> Kompenzace pohybu -> Rekonstrukce snímku.

Implementace zjednodušeného video kodeku v Pythonu

Nyní přejděme od teorie k praxi. Vytvoříme vzdělávací kodek, který používá I-snímky a P-snímky. Předvede základní pipeline: Odhad pohybu, DCT, Kvantizace a odpovídající kroky dekódování.

Upozornění: Toto je *cvičný* kodek určený pro učení. Není optimalizován a nebude produkovat výsledky srovnatelné s H.264. Naším cílem je vidět algoritmy v akci.

Předpoklady

Budete potřebovat následující knihovny Pythonu. Můžete je nainstalovat pomocí pip:

pip install numpy opencv-python scipy

Struktura projektu

Pojďme si uspořádat náš kód do několika souborů:

• main.py: Hlavní skript pro spuštění procesu kódování a dekódování.
• encoder.py: Obsahuje logiku pro kodér.
• decoder.py: Obsahuje logiku pro dekodér.
• utils.py: Pomocné funkce pro video I/O a transformace.

Část 1: Základní utility (`utils.py`)

Začneme pomocnými funkcemi pro DCT, kvantizaci a jejich inverzní operace. Budeme také potřebovat funkci pro rozdělení snímku na bloky.

            
# utils.py
import numpy as np
from scipy.fftpack import dct, idct

BLOCK_SIZE = 8

# A standard JPEG quantization matrix (scaled for our purposes)
QUANTIZATION_MATRIX = np.array([
    [16, 11, 10, 16, 24, 40, 51, 61],
    [12, 12, 14, 19, 26, 58, 60, 55],
    [14, 13, 16, 24, 40, 57, 69, 56],
    [14, 17, 22, 29, 51, 87, 80, 62],
    [18, 22, 37, 56, 68, 109, 103, 77],
    [24, 35, 55, 64, 81, 104, 113, 92],
    [49, 64, 78, 87, 103, 121, 120, 101],
    [72, 92, 95, 98, 112, 100, 103, 99]
])

def apply_dct(block):
    """Applies 2D DCT to a block."""
    # Center the pixel values around 0
    block = block - 128
    return dct(dct(block.T, norm='ortho').T, norm='ortho')

def apply_idct(dct_block):
    """Applies 2D Inverse DCT to a block."""
    block = idct(idct(dct_block.T, norm='ortho').T, norm='ortho')
    # De-center and clip to valid pixel range
    return np.round(block + 128).clip(0, 255)

def quantize(dct_block, qp=1):
    """Quantizes a DCT block. qp is a quality parameter."""
    return np.round(dct_block / (QUANTIZATION_MATRIX * qp)).astype(int)

def dequantize(quantized_block, qp=1):
    """Dequantizes a block."""
    return quantized_block * (QUANTIZATION_MATRIX * qp)

def frame_to_blocks(frame):
    """Splits a frame into 8x8 blocks."""
    blocks = []
    h, w = frame.shape
    for i in range(0, h, BLOCK_SIZE):
        for j in range(0, w, BLOCK_SIZE):
            blocks.append(frame[i:i+BLOCK_SIZE, j:j+BLOCK_SIZE])
    return blocks

def blocks_to_frame(blocks, h, w):
    """Reconstructs a frame from 8x8 blocks."""
    frame = np.zeros((h, w), dtype=np.uint8)
    k = 0
    for i in range(0, h, BLOCK_SIZE):
        for j in range(0, w, BLOCK_SIZE):
            frame[i:i+BLOCK_SIZE, j:j+BLOCK_SIZE] = blocks[k]
            k += 1
    return frame

            

              
                Copy
              
            
          

Část 2: Kodér (`encoder.py`)

Kodér je nejsložitější část. Implementujeme jednoduchý algoritmus porovnávání bloků pro odhad pohybu a poté zpracujeme I-snímky a P-snímky.

            
# encoder.py
import numpy as np
from utils import apply_dct, quantize, frame_to_blocks, BLOCK_SIZE

def get_motion_vectors(current_frame, reference_frame, search_range=8):
    """A simple block matching algorithm for motion estimation."""
    h, w = current_frame.shape
    motion_vectors = []

    for i in range(0, h, BLOCK_SIZE):
        for j in range(0, w, BLOCK_SIZE):
            current_block = current_frame[i:i+BLOCK_SIZE, j:j+BLOCK_SIZE]
            best_match_sad = float('inf')
            best_match_vector = (0, 0)

            # Search in the reference frame
            for y in range(-search_range, search_range + 1):
                for x in range(-search_range, search_range + 1):
                    ref_i, ref_j = i + y, j + x
                    if 0 <= ref_i <= h - BLOCK_SIZE and 0 <= ref_j <= w - BLOCK_SIZE:
                        ref_block = reference_frame[ref_i:ref_i+BLOCK_SIZE, ref_j:ref_j+BLOCK_SIZE]
                        sad = np.sum(np.abs(current_block - ref_block))
                        if sad < best_match_sad:
                            best_match_sad = sad
                            best_match_vector = (y, x)
            
            motion_vectors.append(best_match_vector)
    return motion_vectors

def encode_iframe(frame, qp=1):
    """Encodes an I-frame."""
    h, w = frame.shape
    blocks = frame_to_blocks(frame)
    quantized_blocks = []
    for block in blocks:
        dct_block = apply_dct(block.astype(float))
        quantized_block = quantize(dct_block, qp)
        quantized_blocks.append(quantized_block)
    return {'type': 'I', 'h': h, 'w': w, 'data': quantized_blocks, 'qp': qp}

def encode_pframe(current_frame, reference_frame, qp=1):
    """Encodes a P-frame."""
    h, w = current_frame.shape
    motion_vectors = get_motion_vectors(current_frame, reference_frame)
    
    quantized_residuals = []
    k = 0
    for i in range(0, h, BLOCK_SIZE):
        for j in range(0, w, BLOCK_SIZE):
            current_block = current_frame[i:i+BLOCK_SIZE, j:j+BLOCK_SIZE]
            mv_y, mv_x = motion_vectors[k]
            ref_block = reference_frame[i+mv_y : i+mv_y+BLOCK_SIZE, j+mv_x : j+mv_x+BLOCK_SIZE]
            
            residual = current_block.astype(float) - ref_block.astype(float)
            
            dct_residual = apply_dct(residual)
            quantized_residual = quantize(dct_residual, qp)
            quantized_residuals.append(quantized_residual)
            k += 1
            
    return {'type': 'P', 'motion_vectors': motion_vectors, 'data': quantized_residuals, 'qp': qp}

            

              
                Copy
              
            
          

Část 3: Dekodér (`decoder.py`)

Dekodér provádí proces v opačném pořadí. Pro P-snímky provádí kompenzaci pohybu pomocí uložených vektorů pohybu.

            
# decoder.py
import numpy as np
from utils import apply_idct, dequantize, blocks_to_frame, BLOCK_SIZE

def decode_iframe(encoded_frame):
    """Decodes an I-frame."""
    h, w = encoded_frame['h'], encoded_frame['w']
    qp = encoded_frame['qp']
    quantized_blocks = encoded_frame['data']
    
    reconstructed_blocks = []
    for q_block in quantized_blocks:
        dct_block = dequantize(q_block, qp)
        block = apply_idct(dct_block)
        reconstructed_blocks.append(block.astype(np.uint8))
        
    return blocks_to_frame(reconstructed_blocks, h, w)

def decode_pframe(encoded_frame, reference_frame):
    """Decodes a P-frame using its reference frame."""
    h, w = reference_frame.shape
    qp = encoded_frame['qp']
    motion_vectors = encoded_frame['motion_vectors']
    quantized_residuals = encoded_frame['data']

    reconstructed_blocks = []
    k = 0
    for i in range(0, h, BLOCK_SIZE):
        for j in range(0, w, BLOCK_SIZE):
            # Decode the residual
            dct_residual = dequantize(quantized_residuals[k], qp)
            residual = apply_idct(dct_residual)

            # Perform motion compensation
            mv_y, mv_x = motion_vectors[k]
            ref_block = reference_frame[i+mv_y : i+mv_y+BLOCK_SIZE, j+mv_x : j+mv_x+BLOCK_SIZE]

            # Reconstruct the block
            reconstructed_block = (ref_block.astype(float) + residual).clip(0, 255)
            reconstructed_blocks.append(reconstructed_block.astype(np.uint8))
            k += 1
            
    return blocks_to_frame(reconstructed_blocks, h, w)

            

              
                Copy
              
            
          

Část 4: Vše dohromady (`main.py`)

Tento skript orchestrates celý proces: čtení videa, kódování snímek po snímku a následné dekódování pro vytvoření konečného výstupu.

            
# main.py
import cv2
import pickle # For saving/loading our compressed data structure
from encoder import encode_iframe, encode_pframe
from decoder import decode_iframe, decode_pframe

def main(input_path, output_path, compressed_file_path):
    cap = cv2.VideoCapture(input_path)
    frames = []
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        # We'll work with the grayscale (luma) channel for simplicity
        frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY))
    cap.release()

    # --- ENCODING ---
    print("Encoding...")
    compressed_data = []
    reference_frame = None
    gop_size = 12 # I-frame every 12 frames

    for i, frame in enumerate(frames):
        if i % gop_size == 0:
            # Encode as I-frame
            encoded_frame = encode_iframe(frame, qp=2.5)
            compressed_data.append(encoded_frame)
            print(f"Encoded frame {i} as I-frame")
        else:
            # Encode as P-frame
            encoded_frame = encode_pframe(frame, reference_frame, qp=2.5)
            compressed_data.append(encoded_frame)
            print(f"Encoded frame {i} as P-frame")

        # The reference for the next P-frame needs to be the *reconstructed* last frame
        if encoded_frame['type'] == 'I':
            reference_frame = decode_iframe(encoded_frame)
        else:
            reference_frame = decode_pframe(encoded_frame, reference_frame)

    with open(compressed_file_path, 'wb') as f:
        pickle.dump(compressed_data, f)
    print(f"Compressed data saved to {compressed_file_path}")

    # --- DECODING ---
    print("\\nDecoding...")
    with open(compressed_file_path, 'rb') as f:
        loaded_compressed_data = pickle.load(f)
    
    decoded_frames = []
    reference_frame = None
    for i, encoded_frame in enumerate(loaded_compressed_data):
        if encoded_frame['type'] == 'I':
            decoded_frame = decode_iframe(encoded_frame)
            print(f"Decoded frame {i} (I-frame)")
        else:
            decoded_frame = decode_pframe(encoded_frame, reference_frame)
            print(f"Decoded frame {i} (P-frame)")
        
        decoded_frames.append(decoded_frame)
        reference_frame = decoded_frame
    
    # --- WRITING OUTPUT VIDEO ---
    h, w = decoded_frames[0].shape
    fourcc = cv2.VideoWriter_fourcc(*'mp4v') 
    out = cv2.VideoWriter(output_path, fourcc, 30.0, (w, h), isColor=False)

    for frame in decoded_frames:
        out.write(frame)

    out.release()
    print(f"Decoded video saved to {output_path}")

if __name__ == '__main__':
    main('input.mp4', 'output.mp4', 'compressed.bin')


            

              
                Copy
              
            
          

Analýza výsledků a další zkoumání

Po spuštění skriptu `main.py` se souborem `input.mp4` získáte dva soubory: `compressed.bin`, který obsahuje naše vlastní komprimovaná video data, a `output.mp4`, rekonstruované video. Porovnejte velikost `input.mp4` s `compressed.bin`, abyste viděli kompresní poměr. Vizuálně zkontrolujte `output.mp4`, abyste posoudili kvalitu. Pravděpodobně uvidíte blokové artefakty, zejména s vyšší hodnotou `qp`, což je klasický znak kvantizace.

Měření kvality: Poměr signálu k šumu (PSNR)

Běžnou objektivní metrikou pro měření kvality rekonstrukce je PSNR. Porovnává původní snímek s dekódovaným snímkem. Vyšší PSNR obecně naznačuje lepší kvalitu.

            
import numpy as np
import math

def calculate_psnr(original, compressed):
    mse = np.mean((original - compressed) ** 2)
    if mse == 0:
        return float('inf')
    max_pixel = 255.0
    psnr = 20 * math.log10(max_pixel / math.sqrt(mse))
    return psnr

            

              
                Copy
              
            
          

Omezení a další kroky

Náš jednoduchý kodek je skvělý začátek, ale zdaleka není dokonalý. Zde jsou některá omezení a potenciální zlepšení, která odrážejí vývoj reálných kodeků:

• Odhad pohybu: Naše vyčerpávající hledání je pomalé a základní. Skutečné kodeky používají sofistikované, hierarchické vyhledávací algoritmy k mnohem rychlejšímu nalezení vektorů pohybu.
• B-snímky: Implementovali jsme pouze P-snímky. Přidání B-snímků by výrazně zlepšilo efektivitu komprese za cenu zvýšené složitosti a latence.
• Entropické kódování: Neimplementovali jsme správnou fázi entropického kódování. Jednoduše jsme serializovali datové struktury Pythonu. Přidání kodéru délek běhu (Run-Length Encoder) pro kvantizované nuly, následovaného Huffmanovým nebo aritmetickým kodérem, by dále snížilo velikost souboru.
• Deblokovací filtr: Ostré hrany mezi našimi bloky 8x8 způsobují viditelné artefakty. Moderní kodeky aplikují deblokovací filtr po rekonstrukci, aby tyto hrany vyhladily a zlepšily vizuální kvalitu.
• Variabilní velikosti bloků: Moderní kodeky nepoužívají pouze pevné makrobloky 16x16. Mohou adaptivně rozdělovat snímek do různých velikostí a tvarů bloků, aby lépe odpovídaly obsahu (např. pomocí větších bloků pro ploché oblasti a menších bloků pro detailní oblasti).

Závěr

Vytvoření video kodeku, i zjednodušeného, je hluboce obohacující cvičení. Demystifikuje technologii, která pohání významnou část našich digitálních životů. Prošli jsme si základní koncepty prostorové a časové redundance, prošli jsme si základními fázemi kódovací pipeline – predikcí, transformací a kvantizací – a tyto myšlenky jsme implementovali v Pythonu.

Zde poskytnutý kód je výchozím bodem. Doporučuji vám s ním experimentovat. Zkuste změnit velikost bloku, kvantizační parametr (`qp`) nebo délku GOP. Pokuste se implementovat jednoduché schéma kódování délek běhu (Run-Length Encoding) nebo se dokonce vypořádejte s výzvou přidání B-snímků. Tím, že budete věci stavět a "rozbíjet", získáte hluboké uznání pro vynalézavost za plynulými video zážitky, které často bereme jako samozřejmost. Svět komprese videa je obrovský a neustále se vyvíjí, nabízí nekonečné příležitosti k učení a inovacím.