用Python构建视频编解码器：深入了解压缩算法

            
# 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
              
            
          

            
# 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
              
            
          

            
# 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
              
            
          

            
# 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
              
            
          

            
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