基于ffmpeg使用c语言实现视频倒放

要实现视频倒放，可以使用ffmpeg库来读取和处理视频文件。下面是一个简单的使用ffmpeg库实现视频倒放的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>

#define INBUF_SIZE 4096

int main(int argc, char *argv[]) {
    AVFormatContext *input_ctx = NULL;
    AVCodecContext *codec_ctx = NULL;
    AVCodec *decoder = NULL;
    AVPacket *packet = NULL;
    AVFrame *frame = NULL;
    AVFrame *out_frame = NULL;
    struct SwsContext *sws_ctx = NULL;
    int video_stream_index = -1;
    int ret = 0;

    if (argc != 3) {
        fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
        exit(1);
    }

    av_register_all();

    if (avformat_open_input(&input_ctx, argv[1], NULL, NULL) != 0) {
        fprintf(stderr, "Cannot open input file\n");
        exit(1);
    }

    if (avformat_find_stream_info(input_ctx, NULL) < 0) {
        fprintf(stderr, "Cannot find stream information\n");
        exit(1);
    }

    for (int i = 0; i < input_ctx->nb_streams; i++) {
        if (input_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
            video_stream_index = i;
            break;
        }
    }

    if (video_stream_index == -1) {
        fprintf(stderr, "Cannot find video stream\n");
        exit(1);
    }

    decoder = avcodec_find_decoder(input_ctx->streams[video_stream_index]->codecpar->codec_id);

    if (!decoder) {
        fprintf(stderr, "Codec not found\n");
        exit(1);
    }

    codec_ctx = avcodec_alloc_context3(decoder);

    if (!codec_ctx) {
        fprintf(stderr, "Could not allocate codec context\n");
        exit(1);
    }

    if (avcodec_parameters_to_context(codec_ctx, input_ctx->streams[video_stream_index]->codecpar) < 0) {
        fprintf(stderr, "Could not copy codec parameters\n");
        exit(1);
    }

    if (avcodec_open2(codec_ctx, decoder, NULL) < 0) {
        fprintf(stderr, "Could not open codec\n");
        exit(1);
    }

    packet = av_packet_alloc();

    if (!packet) {
        fprintf(stderr, "Could not allocate packet\n");
        exit(1);
    }

    frame = av_frame_alloc();

    if (!frame) {
        fprintf(stderr, "Could not allocate frame\n");
        exit(1);
    }

    out_frame = av_frame_alloc();

    if (!out_frame) {
        fprintf(stderr, "Could not allocate output frame\n");
        exit(1);
    }

    int width = codec_ctx->width;
    int height = codec_ctx->height;
    int pix_fmt = codec_ctx->pix_fmt;

    av_image_alloc(out_frame->data, out_frame->linesize, width, height, pix_fmt, 1);

    sws_ctx = sws_getContext(width, height, pix_fmt, width, height, pix_fmt, SWS_BILINEAR, NULL, NULL, NULL);

    if (!sws_ctx) {
        fprintf(stderr, "Could not create SwsContext\n");
        exit(1);
    }

    AVFormatContext *output_ctx = NULL;
    AVCodecContext *out_codec_ctx = NULL;
    AVCodec *encoder = NULL;
    AVStream *out_stream = NULL;

    if (avformat_alloc_output_context2(&output_ctx, NULL, NULL, argv[2]) < 0) {
        fprintf(stderr, "Could not create output context\n");
        exit(1);
    }

    encoder = avcodec_find_encoder(output_ctx->oformat->video_codec);

    if (!encoder) {
        fprintf(stderr, "Codec not found\n");
        exit(1);
    }

    out_stream = avformat_new_stream(output_ctx, encoder);

    if (!out_stream) {
        fprintf(stderr, "Could not create output stream\n");
        exit(1);
    }

    out_codec_ctx = avcodec_alloc_context3(encoder);

    if (!out_codec_ctx) {
        fprintf(stderr, "Could not allocate codec context\n");
        exit(1);
    }

    out_codec_ctx->bit_rate = codec_ctx->bit_rate;
    out_codec_ctx->width = codec_ctx->width;
    out_codec_ctx->height = codec_ctx->height;
    out_codec_ctx->time_base = codec_ctx->time_base;
    out_codec_ctx->pix_fmt = codec_ctx->pix_fmt;

    if (avcodec_parameters_from_context(out_stream->codecpar, out_codec_ctx) < 0) {
        fprintf(stderr, "Could not copy codec parameters\n");
        exit(1);
    }

    if (avcodec_open2(out_codec_ctx, encoder, NULL) < 0) {
        fprintf(stderr, "Could not open codec\n");
        exit(1);
    }

    if (!(output_ctx->oformat->flags & AVFMT_NOFILE)) {
        if (avio_open(&output_ctx->pb, argv[2], AVIO_FLAG_WRITE) < 0) {
            fprintf(stderr, "Could not open output file '%s'\n", argv[2]);
            exit(1);
        }
    }

    if (avformat_write_header(output_ctx, NULL) < 0) {
        fprintf(stderr, "Error occurred when opening output file\n");
        exit(1);
    }

    while (av_read_frame(input_ctx, packet) >= 0) {
        if (packet->stream_index == video_stream_index) {
            ret = avcodec_send_packet(codec_ctx, packet);

            if (ret < 0) {
                fprintf(stderr, "Error sending a packet for decoding\n");
                exit(1);
            }

            while (ret >= 0) {
                ret = avcodec_receive_frame(codec_ctx, frame);

                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                    break;
                } else if (ret < 0) {
                    fprintf(stderr, "Error during decoding\n");
                    exit(1);
                }

                double pts = frame->pts * av_q2d(input_ctx->streams[video_stream_index]->time_base);
                int64_t out_pts = (int64_t)((input_ctx->duration - pts) * av_q2d(input_ctx->streams[video_stream_index]->time_base) * AV_TIME_BASE);

                sws_scale(sws_ctx, frame->data, frame->linesize, 0, height, out_frame->data, out_frame->linesize);

                out_frame->pts = out_pts;
                out_frame->pkt_dts = out_pts;
                out_frame->pkt_duration = frame->pkt_duration;

                AVPacket out_packet = {0};
                av_init_packet(&out_packet);

                ret = avcodec_send_frame(out_codec_ctx, out_frame);

                if (ret < 0) {
                    fprintf(stderr, "Error sending a frame for encoding\n");
                    exit(1);
                }

                while (ret >= 0) {
                    ret = avcodec_receive_packet(out_codec_ctx, &out_packet);

                    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                        break;
                    } else if (ret < 0) {
                        fprintf(stderr, "Error during encoding\n");
                        exit(1);
                    }

                    out_packet.stream_index = out_stream->index;
                    av_packet_rescale_ts(&out_packet, out_codec_ctx->time_base, out_stream->time_base);
                    av_interleaved_write_frame(output_ctx, &out_packet);
                    av_packet_unref(&out_packet);
                }

                av_frame_unref(frame);
                av_frame_unref(out_frame);
            }
        }

        av_packet_unref(packet);
    }

    av_write_trailer(output_ctx);

    avformat_close_input(&input_ctx);
    avformat_free_context(input_ctx);

    avcodec_free_context(&codec_ctx);

    av_packet_free(&packet);
    av_frame_free(&frame);
    av_frame_free(&out_frame);

    sws_freeContext(sws_ctx);

    avio_closep(&output_ctx->pb);
    avcodec_free_context(&out_codec_ctx);
    avformat_free_context(output_ctx);

    return 0;
}

该示例代码使用了ffmpeg库来读取输入视频文件，并使用SWScale库将每一帧图像进行缩放和颜色空间转换。然后，将转换后的帧逆序输出到输出视频文件中。

要编译该代码，需要使用类似以下命令：

gcc -o ffmpeg_reverse_video ffmpeg_reverse_video.c -lavformat -lavcodec -lavutil -lswscale

需要注意的是，在使用ffmpeg库时，需要正确地设置编译选项和链接库，否则会出现各种奇怪的问题。