在ffmpeg3.4中代码实现一个bitstream filter，处理h264和hevc码流数据，产生nal header错误的码流

首先，需要了解bitstream filter是什么。bitstream filter是FFmpeg中的一个模块，它可以在解码之前或编码之后操作码流数据。它可以用于对码流数据进行修改、过滤或修复。

下面是一个简单的示例代码，演示如何实现一个bitstream filter以处理H.264和HEVC码流数据，产生NAL header错误的码流。

#include <libavcodec/avcodec.h>
#include <libavutil/opt.h>

typedef struct {
    AVBSFContext *bsf;
} NalHeaderBSFContext;

static int nal_header_filter(AVBSFContext *bsf, AVPacket *pkt)
{
    uint8_t *data = pkt->data;
    int size = pkt->size;
    int i;

    for (i = 0; i < size - 5; i++) {
        if (data[i] == 0 && data[i+1] == 0 && data[i+2] == 0 && data[i+3] == 1) {
            // Found a NAL unit header
            if (data[i+4] != 0x41) {
                // Replace the NAL unit type
                data[i+4] = 0x41;
            }
        }
    }

    return av_bsf_send_packet(bsf, pkt);
}

static int nal_header_init(AVBSFContext *bsf)
{
    NalHeaderBSFContext *ctx = bsf->priv_data;
    AVCodecParameters *par_in = bsf->par_in;

    if (par_in->codec_id != AV_CODEC_ID_H264 && par_in->codec_id != AV_CODEC_ID_HEVC) {
        av_log(bsf, AV_LOG_ERROR, "Only H.264 and HEVC are supported.\n");
        return AVERROR(EINVAL);
    }

    return 0;
}

static int nal_header_close(AVBSFContext *bsf)
{
    NalHeaderBSFContext *ctx = bsf->priv_data;

    av_bsf_free(&ctx->bsf);
    return 0;
}

AVBitStreamFilter ff_nal_header_bsf = {
    .name           = "nal_header",
    .priv_data_size = sizeof(NalHeaderBSFContext),
    .filter         = nal_header_filter,
    .init           = nal_header_init,
    .close          = nal_header_close,
};

这个bitstream filter将遍历每个NAL单元的头，如果不是类型0x41，就将其替换为0x41。然后调用av_bsf_send_packet将包发送到下一个过滤器。

要使用这个bitstream filter，需要将其注册到FFmpeg中，并在编码或解码时使用它。以下是如何使用它的示例代码：

#include <libavformat/avformat.h>

int main(int argc, char *argv[])
{
    AVFormatContext *fmt_ctx = NULL;
    AVStream *stream = NULL;
    AVCodecParameters *codecpar = NULL;
    AVBSFContext *bsf_ctx = NULL;
    AVPacket pkt;
    int ret;

    av_register_all();

    // Open the input file
    ret = avformat_open_input(&fmt_ctx, "input.mp4", NULL, NULL);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
        return ret;
    }

    // Find the first video stream
    ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot find video stream\n");
        return ret;
    }
    stream = fmt_ctx->streams[ret];
    codecpar = stream->codecpar;

    // Create the bitstream filter context
    ret = av_bsf_alloc(&ff_nal_header_bsf, &bsf_ctx);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot allocate bitstream filter\n");
        return ret;
    }

    // Set the input and output codec parameters
    ret = avcodec_parameters_copy(bsf_ctx->par_in, codecpar);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot copy input codec parameters\n");
        return ret;
    }
    ret = avcodec_parameters_copy(bsf_ctx->par_out, codecpar);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot copy output codec parameters\n");
        return ret;
    }

    // Initialize the bitstream filter
    ret = av_bsf_init(bsf_ctx);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot initialize bitstream filter\n");
        return ret;
    }

    // Read packets from the input file, filter them and write them to the output file
    while (av_read_frame(fmt_ctx, &pkt) == 0) {
        if (pkt.stream_index == stream->index) {
            // Filter the packet
            ret = av_bsf_send_packet(bsf_ctx, &pkt);
            if (ret < 0) {
                av_log(NULL, AV_LOG_ERROR, "Cannot send packet to bitstream filter\n");
                break;
            }
            while (av_bsf_receive_packet(bsf_ctx, &pkt) == 0) {
                // Write the packet to the output file
                av_write_frame(out_fmt_ctx, &pkt);
                av_packet_unref(&pkt);
            }
        }
        av_packet_unref(&pkt);
    }

    // Flush the bitstream filter
    ret = av_bsf_send_packet(bsf_ctx, NULL);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Cannot flush bitstream filter\n");
    }
    while (av_bsf_receive_packet(bsf_ctx, &pkt) == 0) {
        // Write the packet to the output file
        av_write_frame(out_fmt_ctx, &pkt);
        av_packet_unref(&pkt);
    }

    // Free the bitstream filter context
    av_bsf_free(&bsf_ctx);

    // Close the input file
    avformat_close_input(&fmt_ctx);

    return 0;
}

这个示例代码从输入文件中读取AVPacket，对视频流的包进行过滤，并将过滤后的包写入输出文件中。在循环中，当收到EOF时，它会调用av_bsf_send_packet发送NULL包来刷新bitstream filter。

以上是一个简单的示例，如果需要更复杂的过滤器，可以参考FFmpeg中其他bitstream filter的实现。