Libav（ffmpeg）将解码的视频时间戳复制到编码器

我正在编写一个应用程序，用于解码来自输入文件（任何编解码器，任何容器）的单个视频流，执行一堆图像处理，并将结果编码为输出文件（单视频流，Quicktime RLE，MOV）。 我正在使用ffmpeg的libav 3.1.5（Windows现在构建，但应用程序将是跨平台的）。

输入和输出帧之间有1：1的对应关系，我希望输出中的帧定时与输入相同。 我真的很难完成这个任务。 所以我的一般问题是： 我如何可靠地（如在所有输入情况下）将输出帧定时设置为与输入相同？

我花了很长时间来浏览API并达到了我现在的目标。 我把一个最小的测试程序放在一起工作：

#include <cstdio>

extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/avutil.h>
#include <libavutil/imgutils.h>
#include <libswscale/swscale.h>
}

using namespace std;


struct DecoderStuff {
    AVFormatContext *formatx;
    int nstream;
    AVCodec *codec;
    AVStream *stream;
    AVCodecContext *codecx;
    AVFrame *rawframe;
    AVFrame *rgbframe;
    SwsContext *swsx;
};


struct EncoderStuff {
    AVFormatContext *formatx;
    AVCodec *codec;
    AVStream *stream;
    AVCodecContext *codecx;
};


template <typename T>
static void dump_timebase (const char *what, const T *o) {
    if (o)
        printf("%s timebase: %d/%dn", what, o->time_base.num, o->time_base.den);
    else
        printf("%s timebase: null objectn", what);
}


// reads next frame into d.rawframe and d.rgbframe. returns false on error/eof.
static bool read_frame (DecoderStuff &d) {

    AVPacket packet;
    int err = 0, haveframe = 0;

    // read
    while (!haveframe && err >= 0 && ((err = av_read_frame(d.formatx, &packet)) >= 0)) {
       if (packet.stream_index == d.nstream) {
           err = avcodec_decode_video2(d.codecx, d.rawframe, &haveframe, &packet);
       }
       av_packet_unref(&packet);
    }

    // error output
    if (!haveframe && err != AVERROR_EOF) {
        char buf[500];
        av_strerror(err, buf, sizeof(buf) - 1);
        buf[499] = 0;
        printf("read_frame: %sn", buf);
    }

    // convert to rgb
    if (haveframe) {
        sws_scale(d.swsx, d.rawframe->data, d.rawframe->linesize, 0, d.rawframe->height,
                  d.rgbframe->data, d.rgbframe->linesize);
    }

    return haveframe;

}


// writes an output frame, returns false on error.
static bool write_frame (EncoderStuff &e, AVFrame *inframe) {

    // see note in so post about outframe here
    AVFrame *outframe = av_frame_alloc();
    outframe->format = inframe->format;
    outframe->width = inframe->width;
    outframe->height = inframe->height;
    av_image_alloc(outframe->data, outframe->linesize, outframe->width, outframe->height,
                   AV_PIX_FMT_RGB24, 1);
    //av_frame_copy(outframe, inframe);
    static int count = 0;
    for (int n = 0; n < outframe->width * outframe->height; ++ n) {
        outframe->data[0][n*3+0] = ((n+count) % 100) ? 0 : 255;
        outframe->data[0][n*3+1] = ((n+count) % 100) ? 0 : 255;
        outframe->data[0][n*3+2] = ((n+count) % 100) ? 0 : 255;
    }
    ++ count;

    AVPacket packet;
    av_init_packet(&packet);
    packet.size = 0;
    packet.data = NULL;

    int err, havepacket = 0;
    if ((err = avcodec_encode_video2(e.codecx, &packet, outframe, &havepacket)) >= 0 && havepacket) {
        packet.stream_index = e.stream->index;
        err = av_interleaved_write_frame(e.formatx, &packet);
    }

    if (err < 0) {
        char buf[500];
        av_strerror(err, buf, sizeof(buf) - 1);
        buf[499] = 0;
        printf("write_frame: %sn", buf);
    }

    av_packet_unref(&packet);
    av_freep(&outframe->data[0]);
    av_frame_free(&outframe);

    return err >= 0;

}


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

    const char *infile = "wildlife.wmv";
    const char *outfile = "test.mov";
    DecoderStuff d = {};
    EncoderStuff e = {};

    av_register_all();

    // decoder
    avformat_open_input(&d.formatx, infile, NULL, NULL);
    avformat_find_stream_info(d.formatx, NULL);
    d.nstream = av_find_best_stream(d.formatx, AVMEDIA_TYPE_VIDEO, -1, -1, &d.codec, 0);
    d.stream = d.formatx->streams[d.nstream];
    d.codecx = avcodec_alloc_context3(d.codec);
    avcodec_parameters_to_context(d.codecx, d.stream->codecpar);
    avcodec_open2(d.codecx, NULL, NULL);
    d.rawframe = av_frame_alloc();
    d.rgbframe = av_frame_alloc();
    d.rgbframe->format = AV_PIX_FMT_RGB24;
    d.rgbframe->width = d.codecx->width;
    d.rgbframe->height = d.codecx->height;
    av_frame_get_buffer(d.rgbframe, 1);
    d.swsx = sws_getContext(d.codecx->width, d.codecx->height, d.codecx->pix_fmt,
                            d.codecx->width, d.codecx->height, AV_PIX_FMT_RGB24,
                            SWS_POINT, NULL, NULL, NULL);
    //av_dump_format(d.formatx, 0, infile, 0);
    dump_timebase("in stream", d.stream);
    dump_timebase("in stream:codec", d.stream->codec); // note: deprecated
    dump_timebase("in codec", d.codecx);

    // encoder
    avformat_alloc_output_context2(&e.formatx, NULL, NULL, outfile);
    e.codec = avcodec_find_encoder(AV_CODEC_ID_QTRLE);
    e.stream = avformat_new_stream(e.formatx, e.codec);
    e.codecx = avcodec_alloc_context3(e.codec);
    e.codecx->bit_rate = 4000000; // arbitrary for qtrle
    e.codecx->width = d.codecx->width;
    e.codecx->height = d.codecx->height;
    e.codecx->gop_size = 30; // 99% sure this is arbitrary for qtrle
    e.codecx->pix_fmt = AV_PIX_FMT_RGB24;
    e.codecx->time_base = d.stream->time_base; // ???
    e.codecx->flags |= (e.formatx->flags & AVFMT_GLOBALHEADER) ? AV_CODEC_FLAG_GLOBAL_HEADER : 0;
    avcodec_open2(e.codecx, NULL, NULL);
    avcodec_parameters_from_context(e.stream->codecpar, e.codecx); 
    //av_dump_format(e.formatx, 0, outfile, 1);
    dump_timebase("out stream", e.stream);
    dump_timebase("out stream:codec", e.stream->codec); // note: deprecated
    dump_timebase("out codec", e.codecx);

    // open file and write header
    avio_open(&e.formatx->pb, outfile, AVIO_FLAG_WRITE); 
    avformat_write_header(e.formatx, NULL);

    // frames
    while (read_frame(d) && write_frame(e, d.rgbframe))
        ;

    // write trailer and close file
    av_write_trailer(e.formatx);
    avio_closep(&e.formatx->pb); 

}

关于这个的一些注意事项：

现在，我目前的尝试。 上面的代码中提供了以下与时间相关的字段，其中以粗体显示细节/混淆。 其中有很多，因为API令人难以置信地令人费解：

我已经尝试了以下描述的结果。 需要注意的是inframe是d.rgbframe ：

我尝试了上面的各种其他手动变换，没有任何工作。 我想要做的是创建一个输出文件，以与输入相同的时间和帧速率播放（在这种情况下为29.97恒定帧速率）。

那么，我该如何做到这一点？ 在这里的时序相关领域中，我做了什么来使输出与输入相同？ 我该如何处理任意视频输入格式，以便在不同的地方存储时间戳和时间基准？ 我需要这个始终工作。

作为参考，下面是从我的测试输入文件的视频流中读取的所有数据包和帧时间戳的表格，以便了解我的测试文件的外观。 没有输入数据包pts'被设置，与帧pts相同，并且由于某种原因，前108帧的持续时间为0.VLC播放文件并将帧速率报告为29.9700089：

我认为你的问题在于时间基础，最初有点混乱。

所以你需要做以下事情：

现在对于每一帧：

这可能是一种矫枉过正，尤其是编码器在打开时不会改变它们的时基（在这种情况下，您不需要转换原始帧的pts ）。

关于刷新帧，你传递给编码器不一定是编码和输出，所以是的，你应该调用avcodec_encode_video2 NULL作为一个框架，让编码器知道你已经完成，并输出所有剩余的数据（你需要像所有其他数据包一样通过复用器）。 事实上，你应该这样做，直到它停止喷出数据包。 对于某些示例，请参阅ffmpeg中doc/examples文件夹中的编码示例之一。

所以，非常感谢Andrey Turkin的非常清晰和有用的答案，我已经正确地工作了，我想分享我做的确切的事情：

在初始化过程中，了解到这些初始时间基准中的任何一个可能会在某些时候被libav改变：

d.codecx->time_base = { 1, 10000 };

e.stream->time_base = d.stream->time_base;

e.codecx->time_base = d.codecx->time_base;

我错过的其中一件事是我可以设置这些时间戳，并且libav会服从。 没有限制，取决于我，不管我设置的解码时间戳是在我选择的时间基础上。 我没有意识到这一点。

然后在解码时：

d.rawframe->pts = av_frame_get_best_effort_timestamp(d.rawframe);

d.rgbframe->pts = d.rawframe->pts;

然后，编码：

outframe->pts = inframe->pts;

av_packet_rescale_ts(&packet, d.stream->time_base, e.stream->time_base);

它的作用就像一个魅力，主要是：我注意到VLC报告输入为29.97 FPS，但输出为30.03 FPS，这是我无法想象的。 但是，在我测试过的所有媒体播放器中，一切看起来都不错。

上一篇: Libav (ffmpeg) copying decoded video timestamps to encoder

下一篇: C++ h264 ffmpeg/libav encode/decode(lossless) issues