Membangun Kodek Video di Python: Selami Lebih Dalam Algoritma Kompresi

Di dunia kita yang terhubung dengan hyper, video adalah rajanya. Dari layanan streaming dan konferensi video hingga umpan media sosial, video digital mendominasi lalu lintas internet. Tapi bagaimana mungkin mengirimkan film definisi tinggi melalui koneksi internet standar? Jawabannya terletak pada bidang yang menarik dan kompleks: kompresi video. Inti dari teknologi ini adalah kodek video (COder-DECoder), serangkaian algoritma canggih yang dirancang untuk secara drastis mengurangi ukuran file sambil mempertahankan kualitas visual.

Meskipun kodek standar industri seperti H.264, HEVC (H.265), dan AV1 bebas royalti adalah bagian teknik yang sangat kompleks, memahami prinsip-prinsip dasarnya dapat diakses oleh pengembang yang termotivasi. Panduan ini akan membawa Anda dalam perjalanan jauh ke dunia kompresi video. Kita tidak hanya akan berbicara tentang teori; kita akan membangun kodek video pendidikan yang disederhanakan dari awal menggunakan Python. Pendekatan langsung ini adalah cara terbaik untuk memahami ide-ide elegan yang memungkinkan streaming video modern.

Mengapa Python? Meskipun bukan bahasa yang akan Anda gunakan untuk kodek komersial berkinerja tinggi secara real-time (yang biasanya ditulis dalam C/C++ atau bahkan perakitan), keterbacaan Python dan pustaka-pustakanya yang kuat seperti NumPy, SciPy, dan OpenCV menjadikannya lingkungan yang sempurna untuk belajar, membuat prototipe, dan penelitian. Anda dapat fokus pada algoritma tanpa terjebak dalam manajemen memori tingkat rendah.

Memahami Konsep Inti Kompresi Video

Sebelum kita menulis satu baris kode pun, kita harus memahami apa yang ingin kita capai. Tujuan dari kompresi video adalah untuk menghilangkan data yang berlebihan. Video mentah yang tidak terkompresi sangat besar. Satu menit video 1080p pada 30 frame per detik dapat melebihi 7 GB. Untuk menjinakkan binatang buas data ini, kita memanfaatkan dua jenis redundansi utama.

Dua Pilar Kompresi: Redundansi Spasial dan Temporal

• Redundansi Spasial (Intra-frame): Ini adalah redundansi dalam satu frame. Pikirkan bidang langit biru yang luas atau dinding putih. Alih-alih menyimpan nilai warna untuk setiap piksel di area itu, kita dapat menggambarkannya dengan lebih efisien. Ini adalah prinsip yang sama di balik format kompresi gambar seperti JPEG.
• Redundansi Temporal (Inter-frame): Ini adalah redundansi antara frame berturut-turut. Di sebagian besar video, pemandangan tidak sepenuhnya berubah dari satu frame ke frame berikutnya. Seseorang berbicara dengan latar belakang statis, misalnya, memiliki redundansi temporal yang sangat besar. Latar belakang tetap sama; hanya sebagian kecil dari gambar (wajah dan tubuh orang tersebut) yang bergerak. Ini adalah sumber kompresi yang paling signifikan dalam video.

Jenis Frame Kunci: I-frame, P-frame, dan B-frame

Untuk memanfaatkan redundansi temporal, codec tidak memperlakukan setiap frame secara merata. Mereka mengkategorikannya menjadi berbagai jenis, membentuk urutan yang disebut Group of Pictures (GOP).

• I-frame (Intra-coded Frame): I-frame adalah gambar lengkap dan berdiri sendiri. Ini dikompresi hanya menggunakan redundansi spasial, seperti JPEG. I-frame berfungsi sebagai titik jangkar dalam aliran video, memungkinkan penampil untuk memulai pemutaran atau mencari ke posisi baru. Mereka adalah jenis frame terbesar tetapi sangat penting untuk meregenerasi video.
• P-frame (Predicted Frame): P-frame dikodekan dengan melihat frame I-frame atau P-frame sebelumnya. Alih-alih menyimpan seluruh gambar, ia hanya menyimpan perbedaannya. Misalnya, ia menyimpan instruksi seperti "ambil blok piksel ini dari frame terakhir, pindahkan 5 piksel ke kanan, dan inilah perubahan warna kecilnya." Ini dicapai melalui proses yang disebut estimasi gerak.
• B-frame (Bi-directionally Predicted Frame): B-frame adalah yang paling efisien. Ini dapat menggunakan frame sebelumnya dan berikutnya sebagai referensi untuk prediksi. Ini berguna untuk adegan di mana suatu objek sementara tersembunyi dan kemudian muncul kembali. Dengan melihat maju dan mundur, kodek dapat membuat prediksi yang lebih akurat dan efisien data. Namun, menggunakan frame di masa depan memperkenalkan sedikit penundaan (latensi), membuatnya kurang cocok untuk aplikasi real-time seperti panggilan video.

GOP tipikal mungkin terlihat seperti ini: I B B P B B P B B I .... Encoder memutuskan pola frame yang optimal untuk menyeimbangkan efisiensi kompresi dan kemampuan pencarian.

Pipeline Kompresi: Rincian Langkah demi Langkah

Pengkodean video modern adalah pipeline multi-tahap. Setiap tahap mengubah data agar lebih mudah dikompresi. Mari kita telusuri langkah-langkah utama untuk mengkodekan satu frame.

Langkah 1: Konversi Ruang Warna (RGB ke YCbCr)

Sebagian besar video dimulai dalam ruang warna RGB (Merah, Hijau, Biru). Namun, mata manusia jauh lebih sensitif terhadap perubahan kecerahan (luma) daripada perubahan warna (chroma). Codec memanfaatkan ini dengan mengonversi RGB ke format luma/chroma seperti YCbCr.

• Y: Komponen luma (kecerahan).
• Cb: Komponen chroma perbedaan biru.
• Cr: Komponen chroma perbedaan merah.

Dengan memisahkan kecerahan dari warna, kita dapat menerapkan subsampling chroma. Teknik ini mengurangi resolusi saluran warna (Cb dan Cr) sambil menjaga resolusi penuh untuk saluran kecerahan (Y), yang paling peka terhadap mata kita. Skema umum adalah 4:2:0, yang membuang 75% informasi warna tanpa hampir tidak ada kehilangan kualitas yang nyata, mencapai kompresi instan.

Langkah 2: Partisi Frame (Macroblock)

Encoder tidak memproses seluruh frame sekaligus. Ini membagi frame menjadi blok yang lebih kecil, biasanya 16x16 atau 8x8 piksel, yang disebut makroblok. Semua langkah pemrosesan selanjutnya (prediksi, transformasi, dll.) dilakukan berdasarkan blok per blok.

Langkah 3: Prediksi (Inter dan Intra)

Di sinilah keajaiban terjadi. Untuk setiap makroblok, encoder memutuskan apakah akan menggunakan prediksi intra-frame atau inter-frame.

• Untuk I-frame (Prediksi Intra): Encoder memprediksi blok saat ini berdasarkan piksel tetangganya yang sudah dikodekan (blok di atas dan kiri) dalam frame yang sama. Kemudian hanya perlu mengkodekan perbedaan kecil (sisa) antara prediksi dan blok sebenarnya.
• Untuk P-frame atau B-frame (Prediksi Inter): Ini adalah estimasi gerak. Encoder mencari blok yang cocok dalam frame referensi. Ketika menemukan kecocokan terbaik, ia merekam vektor gerak (misalnya, "pindahkan 10 piksel ke kanan, 2 piksel ke bawah") dan menghitung sisa. Seringkali, sisa mendekati nol, membutuhkan sedikit bit untuk dikodekan.

Langkah 4: Transformasi (misalnya, Discrete Cosine Transform - DCT)

Setelah prediksi, kita memiliki blok residu. Blok ini dijalankan melalui transformasi matematika seperti Discrete Cosine Transform (DCT). DCT tidak mengkompresi data itu sendiri, tetapi secara fundamental mengubah bagaimana data tersebut direpresentasikan. Ini mengubah nilai piksel spasial menjadi koefisien frekuensi. Keajaiban DCT adalah bahwa untuk sebagian besar gambar alami, ia memusatkan sebagian besar energi visual menjadi hanya beberapa koefisien di sudut kiri atas blok (komponen frekuensi rendah), sementara sisa koefisien (noise frekuensi tinggi) mendekati nol.

Langkah 5: Kuantisasi

Ini adalah langkah lossy utama dalam pipeline dan kunci untuk mengontrol trade-off kualitas-vs-bitrate. Blok koefisien DCT yang diubah dibagi dengan matriks kuantisasi, dan hasilnya dibulatkan ke bilangan bulat terdekat. Matriks kuantisasi memiliki nilai yang lebih besar untuk koefisien frekuensi tinggi, secara efektif menghancurkan banyak di antaranya menjadi nol. Di sinilah sejumlah besar data dibuang. Parameter kuantisasi yang lebih tinggi mengarah pada lebih banyak nol, kompresi yang lebih tinggi, dan kualitas visual yang lebih rendah (sering terlihat sebagai artefak blok).

Langkah 6: Pengkodean Entropi

Tahap terakhir adalah langkah kompresi lossless. Koefisien yang dikuantisasi, vektor gerak, dan metadata lainnya dipindai dan diubah menjadi aliran biner. Teknik seperti Run-Length Encoding (RLE) dan Huffman Coding atau metode yang lebih canggih seperti CABAC (Context-Adaptive Binary Arithmetic Coding) digunakan. Algoritma ini menetapkan kode yang lebih pendek ke simbol yang lebih sering (seperti banyak nol yang dibuat oleh kuantisasi) dan kode yang lebih panjang ke simbol yang kurang sering, meremas bit terakhir dari aliran data.

Decoder cukup menjalankan langkah-langkah ini secara terbalik: Dekoding Entropi -> Kuantisasi Terbalik -> Transformasi Terbalik -> Kompensasi Gerak -> Merekonstruksi frame.

Menerapkan Kodek Video yang Disederhanakan di Python

Sekarang, mari kita terapkan teori ke dalam praktik. Kita akan membangun kodek pendidikan yang menggunakan I-frame dan P-frame. Ini akan mendemonstrasikan pipeline inti: Estimasi Gerak, DCT, Kuantisasi, dan langkah dekoding yang sesuai.

Penafian: Ini adalah kodek *mainan* yang dirancang untuk belajar. Ini tidak dioptimalkan dan tidak akan menghasilkan hasil yang sebanding dengan H.264. Tujuan kami adalah untuk melihat algoritma beraksi.

Prasyarat

Anda memerlukan pustaka Python berikut. Anda dapat menginstalnya menggunakan pip:

pip install numpy opencv-python scipy

Struktur Proyek

Mari kita atur kode kita ke dalam beberapa file:

• main.py: Skrip utama untuk menjalankan proses pengkodean dan dekoding.
• encoder.py: Berisi logika untuk encoder.
• decoder.py: Berisi logika untuk decoder.
• utils.py: Fungsi pembantu untuk I/O video dan transformasi.

Bagian 1: Utilitas Inti (`utils.py`)

Kita akan mulai dengan fungsi pembantu untuk DCT, Kuantisasi, dan inversnya. Kita juga akan membutuhkan fungsi untuk membagi frame menjadi blok.

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

BLOCK_SIZE = 8

# Matriks kuantisasi JPEG standar (diskalakan untuk tujuan kita)
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):
    """Menerapkan 2D DCT ke blok."""
    # Pusatkan nilai piksel di sekitar 0
    block = block - 128
    return dct(dct(block.T, norm='ortho').T, norm='ortho')

def apply_idct(dct_block):
    """Menerapkan 2D Inverse DCT ke blok."""
    block = idct(idct(dct_block.T, norm='ortho').T, norm='ortho')
    # De-center dan klip ke rentang piksel yang valid
    return np.round(block + 128).clip(0, 255)

def quantize(dct_block, qp=1):
    """Mengkuantisasi blok DCT. qp adalah parameter kualitas."""
    return np.round(dct_block / (QUANTIZATION_MATRIX * qp)).astype(int)

def dequantize(quantized_block, qp=1):
    """Dequantisasi blok."""
    return quantized_block * (QUANTIZATION_MATRIX * qp)

def frame_to_blocks(frame):
    """Membagi frame menjadi blok 8x8."""
    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):
    """Merekonstruksi frame dari blok 8x8."""
    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
              
            
          

Bagian 2: Encoder (`encoder.py`)

Encoder adalah bagian yang paling kompleks. Kita akan menerapkan algoritma pencocokan blok sederhana untuk estimasi gerak dan kemudian memproses I-frame dan P-frame.

            
# 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):
    """Algoritma pencocokan blok sederhana untuk estimasi gerak."""
    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)

            # Cari di frame referensi
            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):
    """Mengkodekan 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):
    """Mengkodekan 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
              
            
          

Bagian 3: Decoder (`decoder.py`)

Decoder membalikkan prosesnya. Untuk P-frame, ia melakukan kompensasi gerak menggunakan vektor gerak yang disimpan.

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

def decode_iframe(encoded_frame):
    """Mendekodekan 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):
    """Mendekodekan P-frame menggunakan frame referensinya."""
    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):
            # Dekodekan sisa
            dct_residual = dequantize(quantized_residuals[k], qp)
            residual = apply_idct(dct_residual)

            # Lakukan kompensasi gerak
            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]

            # Rekonstruksi blok
            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
              
            
          

Bagian 4: Menggabungkannya Semua (`main.py`)

Skrip ini mengatur seluruh proses: membaca video, mengkodekannya frame demi frame, dan kemudian mendekodekannya untuk menghasilkan output akhir.

            
# main.py
import cv2
import pickle # Untuk menyimpan/memuat struktur data terkompresi kita
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
        # Kita akan bekerja dengan saluran grayscale (luma) untuk kesederhanaan
        frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY))
    cap.release()

    # --- PENGKODEAN --- #
    print("Pengkodean...")
    compressed_data = []
    reference_frame = None
    gop_size = 12 # I-frame setiap 12 frame

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

        # Referensi untuk P-frame berikutnya haruslah *direkonstruksi* frame terakhir
        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"Data terkompresi disimpan ke {compressed_file_path}")

    # --- DEKODING --- #
    print("\nDekoding...")
    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"Frame {i} didekodekan (I-frame)")
        else:
            decoded_frame = decode_pframe(encoded_frame, reference_frame)
            print(f"Frame {i} didekodekan (P-frame)")
        
        decoded_frames.append(decoded_frame)
        reference_frame = decoded_frame
    
    # --- MENULIS VIDEO OUTPUT --- #
    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"Video yang didekodekan disimpan ke {output_path}")

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

            

              
                Copy
              
            
          

Menganalisis Hasil dan Menjelajahi Lebih Lanjut

Setelah menjalankan skrip `main.py` dengan file `input.mp4`, Anda akan mendapatkan dua file: `compressed.bin`, yang berisi data video terkompresi khusus kami, dan `output.mp4`, video yang direkonstruksi. Bandingkan ukuran `input.mp4` dengan `compressed.bin` untuk melihat rasio kompresi. Periksa secara visual `output.mp4` untuk melihat kualitasnya. Anda mungkin akan melihat artefak blok, terutama dengan nilai `qp` yang lebih tinggi, yang merupakan tanda klasik kuantisasi.

Mengukur Kualitas: Rasio Sinyal-ke-Kebisingan Puncak (PSNR)

Metrik objektif umum untuk mengukur kualitas rekonstruksi adalah PSNR. Ini membandingkan frame asli dengan frame yang didekodekan. PSNR yang lebih tinggi umumnya menunjukkan kualitas yang lebih baik.

            
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
              
            
          

Keterbatasan dan Langkah Selanjutnya

Codec sederhana kita adalah awal yang bagus, tetapi jauh dari sempurna. Berikut adalah beberapa keterbatasan dan potensi peningkatan yang mencerminkan evolusi kodek dunia nyata:

• Estimasi Gerak: Pencarian ekstensif kami lambat dan mendasar. Codec nyata menggunakan algoritma pencarian hierarkis yang canggih untuk menemukan vektor gerak jauh lebih cepat.
• B-frame: Kami hanya menerapkan P-frame. Menambahkan B-frame akan secara signifikan meningkatkan efisiensi kompresi dengan mengorbankan peningkatan kompleksitas dan latensi.
• Pengkodean Entropi: Kami tidak menerapkan tahap pengkodean entropi yang tepat. Kami hanya mengawetkan struktur data Python. Menambahkan Run-Length Encoder untuk nol yang dikuantisasi, diikuti oleh Huffman atau Arithmetic coder, akan lebih mengurangi ukuran file.
• Filter Deblocking: Tepi tajam antara blok 8x8 kami menyebabkan artefak yang terlihat. Codec modern menerapkan filter deblocking setelah rekonstruksi untuk menghaluskan tepi ini dan meningkatkan kualitas visual.
• Ukuran Blok Variabel: Codec modern tidak hanya menggunakan makroblok 16x16 tetap. Mereka dapat secara adaptif mempartisi frame menjadi berbagai ukuran dan bentuk blok agar lebih cocok dengan konten (misalnya, menggunakan blok yang lebih besar untuk area datar dan blok yang lebih kecil untuk area detail).

Kesimpulan

Membangun kodek video, bahkan yang disederhanakan, adalah latihan yang sangat bermanfaat. Itu mengungkap teknologi yang memberi daya pada sebagian besar kehidupan digital kita. Kita telah melakukan perjalanan melalui konsep inti redundansi spasial dan temporal, menelusuri tahapan penting dari pipeline pengkodean—prediksi, transformasi, dan kuantisasi—dan menerapkan ide-ide ini di Python.

Kode yang disediakan di sini adalah titik awal. Saya mendorong Anda untuk bereksperimen dengannya. Coba ubah ukuran blok, parameter kuantisasi (`qp`), atau panjang GOP. Cobalah menerapkan skema Run-Length Encoding sederhana atau bahkan atasi tantangan penambahan B-frame. Dengan membangun dan merusak sesuatu, Anda akan mendapatkan apresiasi yang mendalam atas kecerdikan di balik pengalaman video mulus yang sering kita anggap remeh. Dunia kompresi video sangat luas dan terus berkembang, menawarkan peluang tanpa akhir untuk belajar dan berinovasi.