在ffmpeg中编写一个bitstream filter，针对h264和hevc码流数据进行处理，能够产生各种类型的“问题码流”，比如AVC layer层数据出错、SEI SPS PPS 等数据出错

编写FFmpeg bitstream filter可以在解码前或编码后修改码流数据。以下是一个简单的例子，用于创建一个产生AVC layer层数据出错的问题码流的bitstream filter。

#include <stdio.h>
#include "libavcodec/avcodec.h"
#include "libavutil/opt.h"
#include "libavutil/avassert.h"

typedef struct {
    AVBSFContext *bsf;
    int error_layer;
} AVCErrorContext;

static int avc_error_filter(AVBSFContext *bsf, AVPacket *pkt)
{
    AVCErrorContext *ctx = bsf->priv_data;

    AVPacket new_pkt = { 0 };
    int ret;

    // Parse the AVC NAL unit type
    uint8_t nal_unit_type = pkt->data[4] & 0x1f;

    if (nal_unit_type == 2 || nal_unit_type == 3) {
        // Check if this is a P or B frame in the error layer
        int nal_ref_idc = (pkt->data[4] >> 5) & 0x03;
        int nal_unit_layer_id = (pkt->data[4] >> 3) & 0x03;
        if (nal_ref_idc == 0 && nal_unit_layer_id == ctx->error_layer) {
            // Replace the frame with an error frame
            new_pkt.data = (uint8_t*)"ERROR";
            new_pkt.size = 5;
            new_pkt.pts = pkt->pts;
            new_pkt.dts = pkt->dts;
            new_pkt.stream_index = pkt->stream_index;
            new_pkt.flags = pkt->flags;
            new_pkt.side_data = pkt->side_data;
            new_pkt.side_data_elems = pkt->side_data_elems;
            new_pkt.duration = pkt->duration;

            ret = av_packet_copy_props(&new_pkt, pkt);
            if (ret < 0)
                return ret;

            av_packet_unref(pkt);
            *pkt = new_pkt;
            return 0;
        }
    }

    // Pass through all other packets
    return av_bsf_send_packet(bsf, pkt);
}

static int avc_error_init(AVBSFContext *bsf)
{
    AVCErrorContext *ctx = bsf->priv_data;

    const AVBitStreamFilter *filter = av_bsf_get_by_name("h264_mp4toannexb");
    if (!filter) {
        av_log(bsf, AV_LOG_ERROR, "Failed to find h264_mp4toannexb bitstream filter\n");
        return AVERROR(EINVAL);
    }

    int ret = av_bsf_alloc(filter, &ctx->bsf);
    if (ret < 0) {
        av_log(bsf, AV_LOG_ERROR, "Failed to create h264_mp4toannexb bitstream filter: %d\n", ret);
        return ret;
    }

    ctx->bsf->time_base_in = bsf->time_base_in;
    ctx->bsf->time_base_out = bsf->time_base_out;

    ret = avcodec_parameters_copy(ctx->bsf->par_in, bsf->par_in);
    if (ret < 0) {
        av_log(bsf, AV_LOG_ERROR, "Failed to copy input codec parameters: %d\n", ret);
        return ret;
    }

    ret = av_bsf_init(ctx->bsf);
    if (ret < 0) {
        av_log(bsf, AV_LOG_ERROR, "Failed to initialize h264_mp4toannexb bitstream filter: %d\n", ret);
        return ret;
    }

    return 0;
}

static void avc_error_close(AVBSFContext *bsf)
{
    AVCErrorContext *ctx = bsf->priv_data;
    av_bsf_free(&ctx->bsf);
}

static const AVBitStreamFilter avc_error_bsf = {
    .name           = "avc_error",
    .priv_data_size = sizeof(AVCErrorContext),
    .init           = avc_error_init,
    .filter         = avc_error_filter,
    .close          = avc_error_close,
};

int main(int argc, char **argv)
{
    AVBSFContext *bsf_ctx = NULL;
    int ret;

    ret = av_bsf_alloc(&avc_error_bsf, &bsf_ctx);
    if (ret < 0) {
        fprintf(stderr, "Failed to allocate bitstream filter context: %d\n", ret);
        return 1;
    }

    AVCErrorContext *ctx = bsf_ctx->priv_data;
    ctx->error_layer = 1; // Set the error layer to 1

    ret = av_bsf_init(bsf_ctx);
    if (ret < 0) {
        fprintf(stderr, "Failed to initialize bitstream filter context: %d\n", ret);
        av_bsf_free(&bsf_ctx);
        return 1;
    }

    AVPacket pkt = { 0 };
    pkt.data = (uint8_t*)"\x00\x00\x00\x01\x42\x80\x00\x0a\xef\xbe\xad\xde";
    pkt.size = 12;

    ret = av_bsf_send_packet(bsf_ctx, &pkt);
    if (ret < 0) {
        fprintf(stderr, "Failed to send packet to bitstream filter: %d\n", ret);
        av_bsf_free(&bsf_ctx);
        return 1;
    }

    while (ret >= 0) {
        AVPacket new_pkt = { 0 };
        ret = av_bsf_receive_packet(bsf_ctx, &new_pkt);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
            av_packet_unref(&new_pkt);
            continue;
        } else if (ret < 0) {
            fprintf(stderr, "Failed to receive packet from bitstream filter: %d\n", ret);
            av_packet_unref(&new_pkt);
            break;
        }

        printf("New packet: size=%d data=", new_pkt.size);
        for (int i = 0; i < new_pkt.size; i++) {
            printf("%02x ", new_pkt.data[i]);
        }
        printf("\n");

        av_packet_unref(&new_pkt);
    }

    av_bsf_free(&bsf_ctx);
    return 0;
}

这个示例创建了一个名为“avc_error”的bitstream filter。它使用h264_mp4toannexb过滤器作为前置过滤器，以便正确处理输入的AVC码流。该过滤器检查每个AVC分片的NAL单元类型，并且如果该分片是P或B帧并且位于错误层，则将其替换为一个错误帧。

要使用此过滤器，请将其添加到FFmpeg命令行中：

ffmpeg -i input.mp4 -c:v copy -bsf:v avc_error=error_layer=1 output.mp4

此命令将输入文件“input.mp4”复制到输出文件“output.mp4”，但在处理AVC视频流时会将错误层1中的P和B帧替换为错误帧。