如何用无第三方模块的纯Python提取WEBM(VP9)视频帧？

关键前提说明 #

直接用纯Python解码VP9/WEBM格式是不现实的——VP9的解码逻辑包含复杂的熵编码、变换反演和帧预测，没有Python标准库支持，手动实现等同于重写libvpx解码器，工作量极大。因此最优方案是先将WEBM转换为轻量化、易解析的格式，再用Python标准库处理。

推荐方案1：基于无压缩BMP的AVI格式 #

步骤1：格式转换（用系统工具FFmpeg） #

先将WEBM视频转成无压缩BMP编码的AVI（FFmpeg是系统级工具，不属于Python第三方模块）：

ffmpeg -i input.webm -c:v bmp output.avi

• -c:v bmp：指定视频编码为无压缩BMP，保证解析简单

步骤2：纯Python实现extract_frames函数 #

以下代码仅依赖Python标准库struct、io，完全符合无第三方模块要求：

import struct
import io

def extract_frames(avi_path):
    frames = []
    
    with open(avi_path, 'rb') as f:
        # 解析RIFF文件头
        riff_id = f.read(4)
        if riff_id != b'RIFF':
            raise ValueError("Invalid AVI file: Not a RIFF container")
        f.read(4)  # 跳过RIFF大小
        avi_id = f.read(4)
        if avi_id != b'AVI ':
            raise ValueError("Invalid AVI file: Not an AVI container")
        
        # 遍历所有块
        while True:
            chunk_id = f.read(4)
            if not chunk_id:
                break
            chunk_size = struct.unpack('<I', f.read(4))[0]
            
            if chunk_id == b'LIST':
                list_type = f.read(4)
                remaining = chunk_size - 4
                
                # 解析视频参数块（hdrl）
                if list_type == b'hdrl':
                    while remaining > 0:
                        sub_id = f.read(4)
                        sub_size = struct.unpack('<I', f.read(4))[0]
                        remaining -= 8 + sub_size
                        
                        if sub_id == b'strl':
                            # 定位视频流头
                            while sub_size > 0:
                                strl_sub_id = f.read(4)
                                strl_sub_size = struct.unpack('<I', f.read(4))[0]
                                sub_size -= 8 + strl_sub_size
                                
                                if strl_sub_id == b'vhdr':
                                    # 读取视频宽高
                                    width = struct.unpack('<I', f.read(4))[0]
                                    height = struct.unpack('<I', f.read(4))[0]
                                    f.read(strl_sub_size - 8)  # 跳过其他字段
                                else:
                                    f.read(strl_sub_size)
                        else:
                            f.read(sub_size)
                
                # 解析帧数据块（movi）
                elif list_type == b'movi':
                    while remaining > 0:
                        frame_tag = f.read(4)
                        frame_size = struct.unpack('<I', f.read(4))[0]
                        remaining -= 8 + frame_size
                        
                        # 仅处理视频帧（00dc是AVI视频帧标识）
                        if frame_tag == b'00dc':
                            bmp_data = io.BytesIO(f.read(frame_size))
                            bmp_data.seek(14)  # 跳过BMP文件头（14字节）
                            
                            # 解析BMP信息头
                            info_size = struct.unpack('<I', bmp_data.read(4))[0]
                            if info_size != 40:
                                raise ValueError("Unsupported BMP format")
                            bmp_width = struct.unpack('<I', bmp_data.read(4))[0]
                            bmp_height = struct.unpack('<I', bmp_data.read(4))[0]
                            bit_count = struct.unpack('<H', bmp_data.read(6)[4:6])[0]
                            if bit_count != 24:
                                raise ValueError("Only 24-bit BMP frames are supported")
                            
                            bmp_data.seek(14 + 40)  # 跳到像素数据区
                            pixel_bytes = bmp_data.read()
                            row_stride = (bmp_width * 3 + 3) // 4 * 4  # BMP行对齐
                            
                            # 转换为二维RGB列表（BMP像素是BGR顺序，且从底部开始存储）
                            frame = []
                            for y in range(bmp_height - 1, -1, -1):
                                row_start = y * row_stride
                                row = []
                                for x in range(bmp_width):
                                    pos = row_start + x * 3
                                    b, g, r = pixel_bytes[pos], pixel_bytes[pos+1], pixel_bytes[pos+2]
                                    row.append((r, g, b))
                                frame.append(row)
                            frames.append(frame)
                        else:
                            f.read(frame_size)  # 跳过音频或其他非视频帧
                else:
                    f.read(remaining)  # 跳过其他LIST块
            else:
                f.read(chunk_size)  # 跳过非LIST块
    
    return frames

使用方式 #

# 转换后的AVI路径
frames = extract_frames("output.avi")
# frames是二维列表，每个元素为一行像素，每个像素是(R, G, B)整数元组

推荐方案2：基于PPM帧序列 #

PPM是一种极简的无压缩图像格式，解析逻辑比AVI更简单，适合不需要容器的场景。

步骤1：拆分视频为PPM帧 #

ffmpeg -i input.webm frames/frame_%04d.ppm

该命令会将视频拆分为frame_0001.ppm、frame_0002.ppm等独立文件

步骤2：纯Python解析PPM帧 #

import os

def extract_frames(frame_dir):
    frames = []
    # 按文件名顺序读取帧
    frame_files = sorted(f for f in os.listdir(frame_dir) if f.endswith('.ppm'))
    
    for fname in frame_files:
        with open(os.path.join(frame_dir, fname), 'rb') as f:
            # 解析PPM头
            magic = f.readline().strip()
            if magic != b'P6':
                raise ValueError("Not a binary PPM file")
            width, height = map(int, f.readline().strip().split())
            max_val = int(f.readline().strip())
            if max_val != 255:
                raise ValueError("Only 8-bit PPM files are supported")
            
            # 读取并转换像素数据
            pixel_bytes = f.read()
            frame = []
            for y in range(height):
                row = []
                for x in range(width):
                    idx = (y * width + x) * 3
                    r, g, b = pixel_bytes[idx], pixel_bytes[idx+1], pixel_bytes[idx+2]
                    row.append((r, g, b))
                frame.append(row)
            frames.append(frame)
    
    return frames

总结 #

纯Python无第三方模块的前提下，直接解码VP9/WEBM不具备可行性。上述两种方案通过外部工具转换为易解析的格式，再用Python标准库实现帧提取，完全满足需求。

内容的提问来源于stack exchange，提问作者Kodeur_Kubik