SVT-AV1 Mini-Gop决策算法详解+源码分析.md

【元宝搜索开发者征文大赛】长辈不信你时，我靠元宝搜索拿出 23 条可点开的官方通报

一、SVT-AV1 Mini-Gop决策算法详解

SVT-AV1 支持多种层级预测结构（3L/4L/5L/6L），在 Random Access 模式下，编码器会根据时域复杂度自适应地调整 mini-GoP 的层级结构，这一机制称为动态 Mini-GoP（Dynamic Mini-GoP）。此外，S-Frame 对齐、启动 mini-GoP、场景切换、RA 截断等因素也会影响最终的 mini-GoP 结构。

注：本文根据 **v4.1.0 ** 源码描述

二、概念

Mini-Gop：在SVT-AV1中的概念可以理解为两个只能前向参考 的帧以及之间的所有帧组成一个Mini-Gop，在SVT-AV1中最大的Mini-Gop就是6L，最小为1L(2^0=1)，一个6L的Mini-Gop结构如下，共有32帧(2^5=32)：

三、核心算法

SVT-AV1 默认会将 Mini-Gop 初始化设置为 6L(从0开始) ，即32帧，后续可能会在此基础上分割为2的n次方个帧，但一定小于32帧。

1.S-Frame 对 mini-GoP 大小的调整

S-Frame（Switching Frame）是 AV1 中用于码流切换的特殊帧。当 S-Frame 落在下一个 mini-GoP 内部时，需要降级 mini-GoP 的层级数，使 mini-GoP 边界与 S-Frame 对齐。

Plain 复制代码

if (ctx->sframe_hier_lvls != (int32_t)scs->static_config.hierarchical_levels) {
    next_mg_hierarchical_levels = ctx->sframe_hier_lvls;
}

2.Startup Mini-GoP（启动 mini-GoP）

编码开始时（IDR/CRA 之后），可以使用较小的 mini-GoP 大小来加速编码启动，避免第一个 mini-GoP 过大导致延迟。

含义：

C++ 复制代码

/**
 * @brief startup_mg_size
 *
 * When enabled, a MG with specified size will be inserted after the key frame.
 * The MG size is determined by 2^startup_mg_size.
 *
 * 0: off
 * 2: set hierarchical levels to 2 (MG size 4)
 * 3: set hierarchical levels to 3 (MG size 8)
 * 4: set hierarchical levels to 4 (MG size 16)
 * Default is 0.
 */
 // 启动 MG(mini-gop) 大小，0 表示不启用，2、3、4 表示设置层级为 2、3、4，
 // 在开启此功能后会在关键帧（Key Frame / I帧）之后会强制插入一个指定尺寸的mini-gop
uint8_t startup_mg_size;

启用逻辑：

get_pred_struct_for_all_frames() 函数：

Java 复制代码

// 启动 MG(mini-gop) 大小，0 表示不启用，2、3、4 表示设置层级为 2、3、4，在开启此功能后会在关键帧（Key Frame / I帧）之后会强制插入一个指定尺寸的mini-gop
if (scs->static_config.startup_mg_size != 0) {
    if (pcs->idr_flag || pcs->cra_flag) { // 如果是关键帧或CR帧
        ctx->enable_startup_mg = true; // 启动 MG(mini-gop) 大小功能
    } else if (ctx->enable_startup_mg) { // 否则，关闭 MG(mini-gop) 大小功能
        ctx->enable_startup_mg = false;
    }
}
// 标记当前 mini-GoP 是否为"启动 mini-GoP"（序列开始或关键帧后的第一个 mini-GoP）
if (pcs->idr_flag && pcs->picture_number == 0) {
    ctx->is_startup_gop = true;
} else if (pcs->idr_flag || pcs->cra_flag) {
    ctx->is_startup_gop = false;
}

应用

Plain 复制代码

if (ctx->enable_startup_mg) {
    next_mg_hierarchical_levels = scs->static_config.startup_mg_size;
}

3.动态 Mini-GoP (Dynamic Mini-GoP / enable_dg)

基于早期运动分析决定是否将 6L 拆分为 5L。

含义：默认开启

Plain 复制代码

/* Dynamic gop
*
* 0 = disable Dynamic GoP
* 1 = enable Dynamic GoP
*  Default is 1. */
bool enable_dg;

详细算法参考：SVT-AV1 动态 Mini-GoP (Dynamic Mini-GoP)算法详解

4.不完整 mini-GoP 处理 (Incomplete Mini-GoP)

当预分配缓冲区中的帧数不足以构成一个完整的 mini-GoP 时（例如 GOP 末尾、场景切换、IDR 插入），需要处理不完整的 mini-GoP。

initialize_mini_gop_activity_array() 中的缓冲区帧数判断：根据 pre_assignment_buffer_count 的大小，逐级标记哪些 mini-GoP 是完整的（ activity = false 表示不拆分）

Java 复制代码

// Loop over all mini GOPs to initialize the activity 遍历编码器内所有预定义的 Mini-GOP 模板
// 层级数 > 1 的 mini-GoP 设为 true （活跃/需拆分），层级数 == 1 的设为 false （叶节点，不拆分）
for (uint32_t gopindex = 0; gopindex < MINI_GOP_MAX_COUNT; ++gopindex) {
    ctx->mini_gop_activity_array[gopindex] = svt_aom_get_mini_gop_stats(gopindex)->hierarchical_levels >
        MIN_HIERARCHICAL_LEVEL;
}

// Assign the MGs to be used; if the MG is incomplete, the pre-assignment buffer will hold
// fewer than (1 << scs->static_config.hierarchical_levels) pics
// 分配要使用的Mini-GOP；如果该Mini-GOP不完整，预分配缓冲区中容纳的图像数量将会少于 (1 << scs->static_config.hierarchical_levels) 帧
// 关键规则 ：一个 mini-GoP 被标记为 false （完整/不拆分），当且仅当缓冲区中有 足够的帧 填满该 mini-GoP， 且该 mini-GoP 的最后一帧不是 IDR （IDR 会截断预测结构）
// IDR 特殊处理 ： !(count == N && pcs->idr_flag) 这个条件确保------如果缓冲区恰好有 N 帧且最后一帧是 IDR，则 不 将该 mini-GoP 标记为完整。原因是 IDR 帧会截断预测结构，不能作为 mini-GoP 的正常终止帧。

// count >= 32 且不是"恰好32帧+IDR"
if (enc_ctx->pre_assignment_buffer_count >= 32 && !(enc_ctx->pre_assignment_buffer_count == 32 && pcs->idr_flag)) {
    ctx->mini_gop_activity_array[L6_INDEX] = false;
} else if (enc_ctx->pre_assignment_buffer_count >= 16 &&
           !(enc_ctx->pre_assignment_buffer_count == 16 && pcs->idr_flag)) { // count >= 16 且不是"恰好16帧+IDR"
    ctx->mini_gop_activity_array[L5_0_INDEX] = false; // 前16帧构成完整5L

    // 然后继续检查剩余帧（ count - 16 ）能构成什么：
    if ((enc_ctx->pre_assignment_buffer_count - 16) >= 8 &&
        !((enc_ctx->pre_assignment_buffer_count - 16) == 8 && pcs->idr_flag)) {
        ctx->mini_gop_activity_array[L4_2_INDEX] = false; // 前8帧构成完整4L

        if ((enc_ctx->pre_assignment_buffer_count - 16 - 8) >= 4 &&
            !((enc_ctx->pre_assignment_buffer_count - 16 - 8) == 4 && pcs->idr_flag)) {
            ctx->mini_gop_activity_array[L3_6_INDEX] = false; // 前4帧构成完整3L

            if ((enc_ctx->pre_assignment_buffer_count - 16 - 8 - 4) >= 2 &&
                !((enc_ctx->pre_assignment_buffer_count - 16 - 8 - 4) == 2 && pcs->idr_flag)) {
                ctx->mini_gop_activity_array[L2_14_INDEX] = false; // 前2帧构成完整2L
            }
        } else if ((enc_ctx->pre_assignment_buffer_count - 16 - 8) >= 2 &&
                   !((enc_ctx->pre_assignment_buffer_count - 16 - 8) == 2 && pcs->idr_flag)) {
            ctx->mini_gop_activity_array[L2_12_INDEX] = false; // 前2帧构成完整2L
        }
    } else if ((enc_ctx->pre_assignment_buffer_count - 16) >= 4 &&
               !((enc_ctx->pre_assignment_buffer_count - 16) == 4 && pcs->idr_flag)) {
        ctx->mini_gop_activity_array[L3_4_INDEX] = false; // 前4帧构成完整3L

        if ((enc_ctx->pre_assignment_buffer_count - 16 - 4) >= 2 &&
            !((enc_ctx->pre_assignment_buffer_count - 16 - 4) == 2 && pcs->idr_flag)) {
            ctx->mini_gop_activity_array[L2_10_INDEX] = false; // 前2帧构成完整2L
        }
    } else if ((enc_ctx->pre_assignment_buffer_count - 16) >= 2 &&
               !((enc_ctx->pre_assignment_buffer_count - 16) == 2 && pcs->idr_flag)) {
        ctx->mini_gop_activity_array[L2_8_INDEX] = false; // 前2帧构成完整2L
    }
} else if (enc_ctx->pre_assignment_buffer_count >= 8 &&
           !(enc_ctx->pre_assignment_buffer_count == 8 && pcs->idr_flag)) {
    ctx->mini_gop_activity_array[L4_0_INDEX] = false;

    if ((enc_ctx->pre_assignment_buffer_count - 8) >= 4 &&
        !((enc_ctx->pre_assignment_buffer_count - 8) == 4 && pcs->idr_flag)) {
        ctx->mini_gop_activity_array[L3_2_INDEX] = false;

        if ((enc_ctx->pre_assignment_buffer_count - 8 - 4) >= 2 &&
            !((enc_ctx->pre_assignment_buffer_count - 8 - 4) == 2 && pcs->idr_flag)) {
            ctx->mini_gop_activity_array[L2_6_INDEX] = false;
        }
    } else if ((enc_ctx->pre_assignment_buffer_count - 8) >= 2 &&
               !((enc_ctx->pre_assignment_buffer_count - 8) == 2 && pcs->idr_flag)) {
        ctx->mini_gop_activity_array[L2_4_INDEX] = false;
    }
} else if (enc_ctx->pre_assignment_buffer_count >= 4 &&
           !(enc_ctx->pre_assignment_buffer_count == 4 && pcs->idr_flag)) {
    ctx->mini_gop_activity_array[L3_0_INDEX] = false;

    if ((enc_ctx->pre_assignment_buffer_count - 4) >= 2 &&
        !((enc_ctx->pre_assignment_buffer_count - 4) == 2 && pcs->idr_flag)) {
        ctx->mini_gop_activity_array[L2_2_INDEX] = false;
    }
} else if ((enc_ctx->pre_assignment_buffer_count) >= 2 &&
           !((enc_ctx->pre_assignment_buffer_count) == 2 && pcs->idr_flag)) {
    ctx->mini_gop_activity_array[L2_0_INDEX] = false;
}

handle_incomplete_picture_window_map() ：处理尾部不完整的 mini-GoP，将其层级设为 MIN_HIERARCHICAL_LEVEL （最小值）

Markdown 复制代码

/***************************************************************************************************
* Handles an incomplete picture window map 处理缓冲区末尾"剩余帧"无法构成完整 mini-GoP 的情况。
*
*
***************************************************************************************************/
static EbErrorType handle_incomplete_picture_window_map(uint32_t hierarchical_level, PictureDecisionContext* pd_ctx,
                                                        EncodeContext* enc_ctx) {
    EbErrorType return_error = EB_ErrorNone;
    if (pd_ctx->total_number_of_mini_gops == 0) { // 完全没有完整 mini-GoP
        // 直接将缓冲区所有帧作为mini-gop
        // 为什么要强制层级为 1？剩余帧数量通常少于 2 帧的完整结构所需，为了避免引用缺失/结构不完整，使用最小的层级结构（最保守、最安全）。
        hierarchical_level = MIN(MIN_HIERARCHICAL_LEVEL, hierarchical_level);
        pd_ctx->mini_gop_start_index[pd_ctx->total_number_of_mini_gops] = 0; // 设置当前mini-gop的起始索引为0
        pd_ctx->mini_gop_end_index[pd_ctx->total_number_of_mini_gops]   = enc_ctx->pre_assignment_buffer_count - 1; // 设置当前mini-gop的结束索引为缓冲区帧数量减1
        pd_ctx->mini_gop_length[pd_ctx->total_number_of_mini_gops]      = enc_ctx->pre_assignment_buffer_count -
            pd_ctx->mini_gop_start_index[pd_ctx->total_number_of_mini_gops]; // 设置当前mini-gop区帧数量减区帧数量减起mini-gop的起始索引
        pd_ctx->mini_gop_hierarchical_levels[pd_ctx->total_number_of_mini_gops] = hierarchical_level; // 设置当前mini-gop的层级

        pd_ctx->total_number_of_mini_gops++; // 增加有效mini-gop的数量
    } else if (pd_ctx->mini_gop_end_index[pd_ctx->total_number_of_mini_gops - 1] <
               enc_ctx->pre_assignment_buffer_count - 1) { // 最后一个mini-gop的结束索引小于缓冲区帧数量减1，说明还有一些帧没有分配mini-gop
        // 直接将缓冲区剩余的所有帧作为mini-gop
        pd_ctx->mini_gop_start_index[pd_ctx->total_number_of_mini_gops] =
            pd_ctx->mini_gop_end_index[pd_ctx->total_number_of_mini_gops - 1] + 1; // 设置当前mini-gop的起始索引为上一个mini-gop的结束索引加1
        pd_ctx->mini_gop_end_index[pd_ctx->total_number_of_mini_gops] = enc_ctx->pre_assignment_buffer_count - 1; // 设置当前mini-gop的结束索引为缓冲区帧数量减1
        pd_ctx->mini_gop_length[pd_ctx->total_number_of_mini_gops]    = enc_ctx->pre_assignment_buffer_count -
            pd_ctx->mini_gop_start_index[pd_ctx->total_number_of_mini_gops]; // 设置当前mini-gop区帧数量减区帧数量减起mini-gop的起始索引
        pd_ctx->mini_gop_hierarchical_levels[pd_ctx->total_number_of_mini_gops] = MIN_HIERARCHICAL_LEVEL; // 设置当前mini-gop的层级
        pd_ctx->mini_gop_intra_count[pd_ctx->total_number_of_mini_gops - 1]     = 0; // 设置当前mini-gop的帧内编码帧数为0
        pd_ctx->mini_gop_idr_count[pd_ctx->total_number_of_mini_gops - 1]       = 0;     // 设置当前mini-gop的IDR编码帧数为0

        pd_ctx->total_number_of_mini_gops++; // 增加有效mini-gop的数量
    }

    pd_ctx->mini_gop_intra_count[pd_ctx->total_number_of_mini_gops - 1] = enc_ctx->pre_assignment_buffer_intra_count; // 设置当前mini-gop的帧内编码帧数为缓冲区中统计的 I 帧数量
    pd_ctx->mini_gop_idr_count[pd_ctx->total_number_of_mini_gops - 1]   = enc_ctx->pre_assignment_buffer_idr_count; // 设置当前mini-gop的IDR编码帧数为缓冲区中统计的 IDR 帧数量

    return return_error;
}

4.1 场景切换对 mini-gop的影响

默认情况下此开关被强制关闭，SVT-AV1 不推荐通过插入关键帧处理场景切换。

Plain 复制代码

/* Flag to enable the scene change detection algorithm.
 *
 * Default is 0. */
uint32_t scene_change_detection;

C 复制代码

场景切换检测 → cra_flag=true → intra_count++ → 提前触发 set_mini_gop_structure → mini-GoP 被截断

进行场景切换检测，如果有场景切换将cra_flag=true；

JavaScript 复制代码

// Perform scene change detection and update relevant signals
static void perform_scene_change_detection(SequenceControlSet* scs, PictureParentControlSet* pcs,
                                           PictureDecisionContext* ctx) {
    if (scs->static_config.scene_change_detection) {
        pcs->scene_change_flag = scene_transition_detector(ctx, scs, (PictureParentControlSet**)pcs->pd_window);

    } else {
        pcs->scene_change_flag = false;

        if (scs->vq_ctrls.sharpness_ctrls.scene_transition &&
            (ctx->transition_detected == -1 || ctx->transition_detected == 0)) {
            ctx->transition_detected = scene_transition_detector(ctx, scs, (PictureParentControlSet**)pcs->pd_window);
        }
    }

    pcs->cra_flag = (pcs->scene_change_flag == true) ? true : pcs->cra_flag;

    // Store scene change in context
    ctx->is_scene_change_detected = pcs->scene_change_flag;
}

场景切换帧的 cra_flag=true ，所以 intra_count 递增；

C 复制代码

enc_ctx->pre_assignment_buffer_intra_count += (pcs->idr_flag || pcs->cra_flag);

提前触发 set_mini_gop_structure()函数：

正常情况：缓冲区积攒到 1 << hierarchical_levels 帧（如 6L=32 帧）时才触发 set_mini_gop_structure 。

场景切换时：缓冲区中出现了 I 帧（ intra_count > 0 ），即使帧数不足 32，也会立即触发。

C 复制代码

// Determine if Pictures can be released from the Pre-Assignment Buffer 确定是否可以从预分配缓冲区释放图片
/* 1.预分配缓冲区中出现了需要强制编码为 Intra 帧（I 帧/键帧） 的图像；
 * 2.缓冲区中的图像数量，正好等于当前分层结构所需的满载数量;
 * 3.收到了 EOS（End of Sequence，序列结束） 标志;
 * 4.当前的预测结构被配置为 低延迟（Low Delay，通常只有 P/B 帧向前预测，没有双向重排） 或 全帧内（All Intra，全 I 帧）*/
if ((enc_ctx->pre_assignment_buffer_intra_count > 0) ||
    (enc_ctx->pre_assignment_buffer_count == (uint32_t)(1 << next_mg_hierarchical_levels)) ||
    (enc_ctx->pre_assignment_buffer_eos_flag == true) ||
    (pcs->pred_structure == LOW_DELAY || pcs->pred_structure == ALL_INTRA)) {
    ...
    set_mini_gop_structure(scs, enc_ctx, pcs, ctx);
    ...
}

mini-GoP 被截断：进入 set_mini_gop_structure 后，由于 pre_assignment_buffer_count < 32 ，initialize_mini_gop_activity_array 中的帧数判断会将不完整的 mini-GoP 标记出来，最终由 generate_picture_window_split 和 handle_incomplete_picture_window_map 生成截断的 mini-GoP 。

5 RA Mini-GoP 截断 (Cutting Short RA Mini-GoP)

在 Random Access 模式下，当 mini-GoP 长度小于完整预测结构条目数，或者 mini-GoP 中包含 IDR 帧时，需要截断 RA 预测结构，切换为 Low Delay 预测结构。

is_pic_cutting_short_ra_mg ：判断是否需要截断
update_pred_struct_and_pic_type 中应用截断：将预测结构从 RANDOM_ACCESS 切换为 LOW_DELAY

6 Mini-GoP 层级切换检测

当相邻两个 mini-GoP 的层级数不同时，标记为 mini-GoP 切换，需要重置预测结构位置。

位置：Source/Lib/Codec/pd_process.c/svt_aom_picture_decision_kernel()

C++ 复制代码

// Derive the temporal layer difference between the current mini GOP and the previous mini GOP
pcs->hierarchical_layers_diff = (int32_t)enc_ctx->previous_mini_gop_hierarchical_levels -
    (int32_t)pcs->hierarchical_levels;

// Set init_pred_struct_position_flag to true if mini-GOP switch
pcs->init_pred_struct_position_flag = enc_ctx->is_mini_gop_changed =
    (pcs->hierarchical_layers_diff != 0);