在ffmpeg中编写一个bitstream filter，能对码流数据进行处理，能够产生各种类型的“问题码流”

编写一个bitstream filter，可以使用ffmpeg提供的API，例如AVBitStreamFilterContext结构体和相关的函数。下面是一个简单的示例：

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>

#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/avutil.h>
#include <libavutil/opt.h>
#include <libavutil/pixdesc.h>
#include <libavutil/common.h>
#include <libavutil/imgutils.h>

typedef struct {
    AVBitStreamFilterContext *bsfc;
    bool corrupt;
    int corrupt_type;
} CorruptBitstreamContext;

static void corrupt_bitstream_free(CorruptBitstreamContext *ctx)
{
    if (ctx->bsfc) {
        av_bitstream_filter_close(ctx->bsfc);
        ctx->bsfc = NULL;
    }
    av_free(ctx);
}

static int corrupt_bitstream_init(CorruptBitstreamContext *ctx, const char *filter_name)
{
    ctx->bsfc = av_bitstream_filter_init(filter_name);
    if (!ctx->bsfc) {
        fprintf(stderr, "Failed to create bitstream filter %s\n", filter_name);
        return AVERROR(ENOMEM);
    }
    return 0;
}

static int corrupt_bitstream_filter(CorruptBitstreamContext *ctx, AVPacket *pkt)
{
    AVBitStreamFilterContext *bsfc = ctx->bsfc;
    int ret = av_bitstream_filter_filter(bsfc, NULL, NULL, &pkt->data, &pkt->size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY);
    if (ret < 0) {
        fprintf(stderr, "Failed to filter packet: %d\n", ret);
        return ret;
    }
    if (ret > 0) {
        ctx->corrupt = true;
        ctx->corrupt_type = ret;
    }
    return 0;
}

static bool corrupt_bitstream_random_byte(CorruptBitstreamContext *ctx, AVPacket *pkt)
{
    if (pkt->size == 0)
        return false;
    int pos = av_clip(rand() % pkt->size, 0, pkt->size - 1);
    uint8_t *data = pkt->data;
    data[pos] = rand() & 0xff;
    ctx->corrupt = true;
    ctx->corrupt_type = 1;
    return true;
}

static bool corrupt_bitstream_random_bit(CorruptBitstreamContext *ctx, AVPacket *pkt)
{
    if (pkt->size == 0)
        return false;
    int pos = rand() % (pkt->size * 8);
    uint8_t *data = pkt->data;
    data[pos / 8] ^= 1 << (pos % 8);
    ctx->corrupt = true;
    ctx->corrupt_type = 2;
    return true;
}

static bool corrupt_bitstream_trim(CorruptBitstreamContext *ctx, AVPacket *pkt)
{
    if (pkt->size == 0)
        return false;
    int pos = av_clip(rand() % pkt->size, 0, pkt->size - 1);
    pkt->size = pos;
    ctx->corrupt = true;
    ctx->corrupt_type = 3;
    return true;
}

int main(int argc, char *argv[])
{
    int ret;

    if (argc < 2) {
        fprintf(stderr, "Usage: %s input_file\n", argv[0]);
        return 1;
    }

    const char *filter_name = "h264_mp4toannexb";
    CorruptBitstreamContext *ctx = av_mallocz(sizeof(*ctx));
    if (!ctx) {
        fprintf(stderr, "Failed to allocate context\n");
        return 1;
    }
    ret = corrupt_bitstream_init(ctx, filter_name);
    if (ret < 0) {
        corrupt_bitstream_free(ctx);
        return 1;
    }

    AVFormatContext *fmt_ctx = NULL;
    ret = avformat_open_input(&fmt_ctx, argv[1], NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Failed to open input file: %d\n", ret);
        corrupt_bitstream_free(ctx);
        return 1;
    }

    ret = avformat_find_stream_info(fmt_ctx, NULL);
    if (ret < 0) {
        fprintf(stderr, "Failed to find stream info: %d\n", ret);
        avformat_close_input(&fmt_ctx);
        corrupt_bitstream_free(ctx);
        return 1;
    }

    int video_stream_idx = -1;
    for (int i = 0; i < fmt_ctx->nb_streams; i++) {
        AVStream *stream = fmt_ctx->streams[i];
        if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
            video_stream_idx = i;
            break;
        }
    }

    if (video_stream_idx == -1) {
        fprintf(stderr, "No video stream found!\n");
        avformat_close_input(&fmt_ctx);
        corrupt_bitstream_free(ctx);
        return 1;
    }

    AVCodecParameters *codec_params = fmt_ctx->streams[video_stream_idx]->codecpar;
    AVCodec *codec = avcodec_find_decoder(codec_params->codec_id);
    if (!codec) {
        fprintf(stderr, "Failed to find decoder for codec %s\n", avcodec_get_name(codec_params->codec_id));
        avformat_close_input(&fmt_ctx);
        corrupt_bitstream_free(ctx);
        return 1;
    }

    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
    if (!codec_ctx) {
        fprintf(stderr, "Failed to allocate codec context\n");
        avformat_close_input(&fmt_ctx);
        corrupt_bitstream_free(ctx);
        return 1;
    }

    ret = avcodec_parameters_to_context(codec_ctx, codec_params);
    if (ret < 0) {
        fprintf(stderr, "Failed to copy codec parameters to codec context: %d\n", ret);
        avcodec_free_context(&codec_ctx);
        avformat_close_input(&fmt_ctx);
        corrupt_bitstream_free(ctx);
        return 1;
    }

    ret = avcodec_open2(codec_ctx, codec, NULL);
    if (ret < 0) {
        fprintf(stderr, "Failed to open codec: %d\n", ret);
        avcodec_free_context(&codec_ctx);
        avformat_close_input(&fmt_ctx);
        corrupt_bitstream_free(ctx);
        return 1;
    }

    AVFrame *frame = av_frame_alloc();
    if (!frame) {
        fprintf(stderr, "Failed to allocate frame\n");
        avcodec_free_context(&codec_ctx);
        avformat_close_input(&fmt_ctx);
        corrupt_bitstream_free(ctx);
        return 1;
    }

    AVPacket pkt;
    av_init_packet(&pkt);

    while (true) {
        ret = av_read_frame(fmt_ctx, &pkt);
        if (ret == AVERROR_EOF)
            break;
        if (ret < 0) {
            fprintf(stderr, "Failed to read packet: %d\n", ret);
            av_packet_unref(&pkt);
            break;
        }
        if (pkt.stream_index == video_stream_idx) {
            if (ctx->corrupt) {
                switch (ctx->corrupt_type) {
                case 1:
                    corrupt_bitstream_random_byte(ctx, &pkt);
                    break;
                case 2:
                    corrupt_bitstream_random_bit(ctx, &pkt);
                    break;
                case 3:
                    corrupt_bitstream_trim(ctx, &pkt);
                    break;
                default:
                    break;
                }
            }
            ret = corrupt_bitstream_filter(ctx, &pkt);
            if (ret < 0)
                break;
            ret = avcodec_send_packet(codec_ctx, &pkt);
            if (ret < 0) {
                fprintf(stderr, "Failed to send packet to decoder: %d\n", ret);
                av_packet_unref(&pkt);
                break;
            }
            while (true) {
                ret = avcodec_receive_frame(codec_ctx, frame);
                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
                    break;
                if (ret < 0) {
                    fprintf(stderr, "Failed to decode frame: %d\n", ret);
                    break;
                }
                printf("Decoded frame: %dx%d, format=%s\n", frame->width, frame->height, av_get_pix_fmt_name(frame->format));
                av_frame_unref(frame);
            }
        }
        av_packet_unref(&pkt);
    }

    av_frame_free(&frame);
    avcodec_free_context(&codec_ctx);
    avformat_close_input(&fmt_ctx);
    corrupt_bitstream_free(ctx);

    return 0;
}

该示例使用h264_mp4toannexb filter将MPEG-4 Part 14格式的码流转换为H.264 Annex B格式的码流，并添加了三种类型的“问题码流”处理：

- 随机更改一个字节
- 随机更改一个比特
- 裁剪数据包到随机位置

你可以根据需要更改这些处理，也可以添加其他处理。