ffmpeg frame.pts

FFmpeg是一个开源的音视频处理工具，frame.pts是用来表示视频帧的展示时间戳（Presentation Timestamp）。每个视频帧都有一个pts值，用来确定它在播放时的展示时间。

在FFmpeg中，可以使用命令行参数或编程接口来处理视频帧的pts。例如，使用命令行参数可以通过指定"-vf"（视频滤镜）选项来修改pts值，如下所示：

ffmpeg -i input.mp4 -vf "setpts=PTS+2/TB" output.mp4

上述命令将输入文件input.mp4中的每个视频帧的pts值增加2秒，并将结果保存为output.mp4。

在编程接口中，可以使用相关的函数来获取和修改视频帧的pts值。具体的操作方式取决于你使用的编程语言和FFmpeg的版本。你可以参考FFmpeg的官方文档和相关示例代码来了解更多细节。

希望以上信息能对你有所帮助！如果你还有其他问题，请随时提问。

相关问题

ffmpeg api pts

FFmpeg的API中，PTS表示Presentation Time Stamp（显示时间戳），用于描述视频帧或音频样本的显示或播放时间。PTS表示帧或样本在媒体时间轴上的位置，它决定了媒体数据的渲染顺序和时间间隔。

PTS的单位是时间基，常见的时间基包括秒、毫秒、微秒等。在FFmpeg中，时间基被表示为一个分数形式，其中numerator表示每秒的时钟滴答数，denominator表示时钟滴答的单位。例如，对于1秒钟有90000个时钟滴答的时钟基准，时间基可以表示为1/90000。

PTS在FFmpeg中的处理通常涉及到时间基的转换、同步和调整等操作。你可以使用相关的API函数来获取和设置PTS值，例如av_frame_get_best_effort_timestamp()函数用于获取帧的PTS，av_packet_rescale_ts()函数用于将PTS从一个时间基转换为另一个时间基。

c++ 使用ffmpeg4.x实现rtsp推流代码

下面是一个简单的使用FFmpeg 4.x实现RTSP推流的C++代码示例：

#include <iostream>
#include <cstdio>
#include <sstream>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <sys/time.h>
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libswscale/swscale.h>

using namespace std;

#define WIDTH 640
#define HEIGHT 480
#define FPS 25
#define BITRATE 400000
#define RTSP_URL "rtsp://localhost:8554/test.sdp"

int main(int argc, char **argv) {
    AVFormatContext *fmt_ctx = NULL;
    AVCodecContext *codec_ctx = NULL;
    AVCodec *codec = NULL;
    AVStream *stream = NULL;
    AVFrame *frame = NULL;
    AVPacket packet;

    int ret = 0;
    int frame_count = 0;
    int64_t start_time = 0;
    struct timeval tv;
    int64_t pts = 0;

    av_register_all();
    avformat_network_init();

    // 打开输出流
    ret = avformat_alloc_output_context2(&fmt_ctx, NULL, "rtsp", RTSP_URL);
    if (ret < 0) {
        cout << "avformat_alloc_output_context2 failed: " << av_err2str(ret) << endl;
        exit(1);
    }

    // 添加视频流
    codec = avcodec_find_encoder(AV_CODEC_ID_H264);
    if (!codec) {
        cout << "avcodec_find_encoder failed" << endl;
        exit(1);
    }

    stream = avformat_new_stream(fmt_ctx, codec);
    if (!stream) {
        cout << "avformat_new_stream failed" << endl;
        exit(1);
    }

    codec_ctx = stream->codec;
    codec_ctx->codec_id = codec->id;
    codec_ctx->bit_rate = BITRATE;
    codec_ctx->width = WIDTH;
    codec_ctx->height = HEIGHT;
    codec_ctx->time_base = (AVRational){1, FPS};
    codec_ctx->gop_size = 10;
    codec_ctx->max_b_frames = 1;
    codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P;

    if (fmt_ctx->oformat->flags & AVFMT_GLOBALHEADER) {
        codec_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
    }

    ret = avcodec_open2(codec_ctx, codec, NULL);
    if (ret < 0) {
        cout << "avcodec_open2 failed: " << av_err2str(ret) << endl;
        exit(1);
    }

    av_dump_format(fmt_ctx, 0, RTSP_URL, 1);

    ret = avio_open(&fmt_ctx->pb, RTSP_URL, AVIO_FLAG_WRITE);
    if (ret < 0) {
        cout << "avio_open failed: " << av_err2str(ret) << endl;
        exit(1);
    }

    ret = avformat_write_header(fmt_ctx, NULL);
    if (ret < 0) {
        cout << "avformat_write_header failed: " << av_err2str(ret) << endl;
        exit(1);
    }

    // 创建帧
    frame = av_frame_alloc();
    frame->width = WIDTH;
    frame->height = HEIGHT;
    frame->format = AV_PIX_FMT_YUV420P;
    ret = av_frame_get_buffer(frame, 32);
    if (ret < 0) {
        cout << "av_frame_get_buffer failed: " << av_err2str(ret) << endl;
        exit(1);
    }

    // 循环推流
    while (true) {
        gettimeofday(&tv, NULL);
        if (start_time == 0) {
            start_time = tv.tv_sec * 1000000 + tv.tv_usec;
        }
        pts = (tv.tv_sec * 1000000 + tv.tv_usec - start_time) * (double)FPS / 1000000;
        frame->pts = pts;

        // 生成测试图像
        for (int y = 0; y < HEIGHT; y++) {
            for (int x = 0; x < WIDTH; x++) {
                frame->data[0][y * frame->linesize[0] + x] = rand() % 256; // Y
            }
        }
        for (int y = 0; y < HEIGHT / 2; y++) {
            for (int x = 0; x < WIDTH / 2; x++) {
                frame->data[1][y * frame->linesize[1] + x] = rand() % 256; // U
                frame->data[2][y * frame->linesize[2] + x] = rand() % 256; // V
            }
        }

        ret = avcodec_send_frame(codec_ctx, frame);
        if (ret < 0) {
            cout << "avcodec_send_frame failed: " << av_err2str(ret) << endl;
            exit(1);
        }

        while (true) {
            ret = avcodec_receive_packet(codec_ctx, &packet);
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                break;
            } else if (ret < 0) {
                cout << "avcodec_receive_packet failed: " << av_err2str(ret) << endl;
                exit(1);
            }

            packet.stream_index = stream->index;
            av_packet_rescale_ts(&packet, codec_ctx->time_base, stream->time_base);
            ret = av_interleaved_write_frame(fmt_ctx, &packet);
            if (ret < 0) {
                cout << "av_interleaved_write_frame failed: " << av_err2str(ret) << endl;
                exit(1);
            }
            av_packet_unref(&packet);
        }

        frame_count++;

        if (frame_count >= FPS * 10) {
            break; // 推送 10 秒
        }

        usleep(1000000 / FPS);
    }

    // 结束推流
    av_write_trailer(fmt_ctx);
    avcodec_close(codec_ctx);
    avformat_free_context(fmt_ctx);
    av_frame_free(&frame);

    return 0;
}

这个程序会生成一些随机图像，并将它们推送到一个名为"test.sdp"的RTSP流中。你可以使用VLC等流媒体播放器来查看这个流。