如何实现ffmpeg 推ts流 帧率20fps

要使用FFmpeg推送TS流并设置帧率为20fps，可以按照以下步骤进行操作：

1. 安装FFmpeg：首先，确保你已经安装了FFmpeg。你可以从FFmpeg官方网站（https://ffmpeg.org/）下载并安装适合你操作系统的版本。

2. 准备视频文件：将要推送的视频文件准备好。确保视频文件的编码格式和分辨率与你的需求相匹配。

3. 使用FFmpeg推送TS流：打开终端或命令提示符，输入以下命令来推送TS流：

   ffmpeg -re -i input.mp4 -c copy -f mpegts udp://localhost:1234

其中，`input.mp4`是你要推送的视频文件名，`udp://localhost:1234`是目标地址和端口，你可以根据需要修改。

4. 设置帧率为20fps：默认情况下，FFmpeg会以源视频的帧率进行推送。如果你想设置帧率为20fps，可以使用`-r`参数来指定：

   ffmpeg -re -i input.mp4 -r 20 -c copy -f mpegts udp://localhost:1234

这样，FFmpeg就会将指定的视频文件以TS流的形式推送到指定的地址，并且设置帧率为20fps。

相关问题

c++ 使用ffmpeg实现rtsp推流代码

以下是使用FFmpeg实现RTSP推流的C++代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <pthread.h>
#include <errno.h>

#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>

const char* RTSP_URL = "rtsp://192.168.1.1:8554/test"; // 要推流的RTSP地址
const int FRAME_RATE = 25; // 视频帧率
const int VIDEO_WIDTH = 640; // 视频宽度
const int VIDEO_HEIGHT = 480; // 视频高度

int64_t start_time = 0;

int interrupt_cb(void* ctx) {
    int timeout = 10;
    if (av_gettime_relative() - start_time > timeout * 1000 * 1000) {
        return 1;
    }
    return 0;
}

void* push_thread(void* arg) {
    AVFormatContext* fmt_ctx = NULL;
    AVStream* video_stream = NULL;
    AVCodecContext* codec_ctx = NULL;
    AVCodec* codec = NULL;
    AVFrame* frame = NULL;
    AVPacket pkt;
    int ret = 0;

    avformat_network_init();

    // 打开输出RTSP流的上下文
    avformat_alloc_output_context2(&fmt_ctx, NULL, "rtsp", RTSP_URL);
    if (!fmt_ctx) {
        printf("avformat_alloc_output_context2 failed\n");
        goto end;
    }

    // 找到h.264编码器
    codec = avcodec_find_encoder_by_name("libx264");
    if (!codec) {
        printf("avcodec_find_encoder_by_name failed\n");
        goto end;
    }

    // 创建视频流
    video_stream = avformat_new_stream(fmt_ctx, codec);
    if (!video_stream) {
        printf("avformat_new_stream failed\n");
        goto end;
    }
    video_stream->codecpar->codec_id = codec->id;
    video_stream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
    video_stream->codecpar->width = VIDEO_WIDTH;
    video_stream->codecpar->height = VIDEO_HEIGHT;
    video_stream->codecpar->format = AV_PIX_FMT_YUV420P;
    video_stream->codecpar->bit_rate = 500000;
    video_stream->codecpar->fps_num = FRAME_RATE;
    video_stream->codecpar->fps_den = 1;

    // 打开编码器
    codec_ctx = avcodec_alloc_context3(codec);
    if (!codec_ctx) {
        printf("avcodec_alloc_context3 failed\n");
        goto end;
    }
    avcodec_parameters_to_context(codec_ctx, video_stream->codecpar);
    if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
        printf("avcodec_open2 failed\n");
        goto end;
    }

    // 创建帧
    frame = av_frame_alloc();
    if (!frame) {
        printf("av_frame_alloc failed\n");
        goto end;
    }
    frame->format = codec_ctx->pix_fmt;
    frame->width = VIDEO_WIDTH;
    frame->height = VIDEO_HEIGHT;
    if (av_frame_get_buffer(frame, 32) < 0) {
        printf("av_frame_get_buffer failed\n");
        goto end;
    }

    // 打开输出流
    if (avio_open(&fmt_ctx->pb, RTSP_URL, AVIO_FLAG_WRITE) < 0) {
        printf("avio_open failed\n");
        goto end;
    }

    // 写输出流头部
    avformat_write_header(fmt_ctx, NULL);

    // 推流
    while (1) {
        // 生成测试图像
        uint8_t* data[1];
        int linesize[1];
        int y_size = VIDEO_WIDTH * VIDEO_HEIGHT;
        data[0] = (uint8_t*)malloc(y_size * 3 / 2);
        memset(data[0], 0, y_size * 3 / 2);
        for (int i = 0; i < VIDEO_HEIGHT; i++) {
            memset(data[0] + i * VIDEO_WIDTH, i * 255 / (VIDEO_HEIGHT - 1), VIDEO_WIDTH);
        }
        for (int i = 0; i < VIDEO_HEIGHT / 2; i++) {
            memset(data[0] + y_size + i * VIDEO_WIDTH / 2, 128 + i * 127 / (VIDEO_HEIGHT / 2 - 1), VIDEO_WIDTH / 2);
        }

        // 将测试图像转换为AVFrame
        av_image_fill_arrays(frame->data, frame->linesize, data[0], codec_ctx->pix_fmt, VIDEO_WIDTH, VIDEO_HEIGHT, 32);
        frame->pts = av_rescale_q(av_gettime_relative() - start_time, (AVRational){1, AV_TIME_BASE}, video_stream->time_base);
        ret = avcodec_send_frame(codec_ctx, frame);
        if (ret < 0) {
            printf("avcodec_send_frame failed\n");
            goto end;
        }
        while (ret >= 0) {
            ret = avcodec_receive_packet(codec_ctx, &pkt);
            if (ret < 0) {
                break;
            }
            av_packet_rescale_ts(&pkt, codec_ctx->time_base, video_stream->time_base);
            pkt.stream_index = video_stream->index;
            av_interleaved_write_frame(fmt_ctx, &pkt);
            av_packet_unref(&pkt);
        }

        free(data[0]);

        if (av_gettime_relative() - start_time > 30 * 1000 * 1000) { // 推流30秒后退出
            break;
        }
    }

    // 写输出流尾部
    av_write_trailer(fmt_ctx);

end:
    if (frame) {
        av_frame_free(&frame);
    }
    if (codec_ctx) {
        avcodec_free_context(&codec_ctx);
    }
    if (fmt_ctx) {
        avio_close(fmt_ctx->pb);
        avformat_free_context(fmt_ctx);
    }

    return NULL;
}

int main(int argc, char* argv[]) {
    pthread_t pid;
    int ret = 0;

    // 初始化FFmpeg库
    av_register_all();
    avformat_network_init();
    avcodec_register_all();

    start_time = av_gettime_relative();

    // 创建推流线程
    ret = pthread_create(&pid, NULL, push_thread, NULL);
    if (ret != 0) {
        printf("pthread_create failed\n");
        return -1;
    }

    // 等待推流线程退出
    pthread_join(pid, NULL);

    return 0;
}

上述代码中使用libx264编码器，生成测试图像并将其推流到RTSP服务器。可以根据实际需要修改RTSP_URL、FRAME_RATE、VIDEO_WIDTH和VIDEO_HEIGHT等参数。

使用rtsp推流和拉流帧率怎样调节 cpp代码

要调节RTSP推流和拉流的帧率，你需要修改代码中的相关参数。在C++中，推流和拉流通常使用FFmpeg库来实现。以下是一个简单的示例代码，它使用FFmpeg库来推送RTSP流：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>

#define STREAM_URL "rtsp://127.0.0.1:8554/test"

int main(int argc, char **argv)
{
    AVFormatContext *pFormatCtx;
    AVOutputFormat *pOutputFmt;
    AVStream *pStream;
    AVCodecContext *pCodecCtx;
    AVCodec *pCodec;
    AVFrame *pFrame;
    AVPacket pkt;
    int ret, i, frame_count = 0;
    struct timeval start_time, end_time;
    int64_t start_time_ms, end_time_ms;
    int video_width = 1920, video_height = 1080;
    int video_fps = 30; // 设置帧率为30fps
    char errbuf[1024];

    // 初始化FFmpeg库
    av_register_all();
    avformat_network_init();

    // 打开输出流
    ret = avformat_alloc_output_context2(&pFormatCtx, NULL, "rtsp", STREAM_URL);
    if (ret < 0) {
        av_strerror(ret, errbuf, sizeof(errbuf));
        fprintf(stderr, "Failed to allocate output context: %s\n", errbuf);
        return -1;
    }

    // 创建视频流
    pOutputFmt = pFormatCtx->oformat;
    pStream = avformat_new_stream(pFormatCtx, NULL);
    if (!pStream) {
        fprintf(stderr, "Failed to allocate stream\n");
        return -1;
    }

    // 设置视频编码器参数
    pCodec = avcodec_find_encoder(pOutputFmt->video_codec);
    if (!pCodec) {
        fprintf(stderr, "Failed to find video encoder\n");
        return -1;
    }

    pCodecCtx = avcodec_alloc_context3(pCodec);
    pCodecCtx->codec_id = pOutputFmt->video_codec;
    pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
    pCodecCtx->width = video_width;
    pCodecCtx->height = video_height;
    pCodecCtx->time_base.num = 1;
    pCodecCtx->time_base.den = video_fps;
    pCodecCtx->pix_fmt = AV_PIX_FMT_YUV420P;

    // 打开编码器
    ret = avcodec_open2(pCodecCtx, pCodec, NULL);
    if (ret < 0) {
        av_strerror(ret, errbuf, sizeof(errbuf));
        fprintf(stderr, "Failed to open video encoder: %s\n", errbuf);
        return -1;
    }

    // 分配帧缓存
    pFrame = av_frame_alloc();
    pFrame->format = pCodecCtx->pix_fmt;
    pFrame->width = pCodecCtx->width;
    pFrame->height = pCodecCtx->height;
    ret = av_frame_get_buffer(pFrame, 0);
    if (ret < 0) {
        av_strerror(ret, errbuf, sizeof(errbuf));
        fprintf(stderr, "Failed to allocate frame buffer: %s\n", errbuf);
        return -1;
    }

    // 打开输出流
    ret = avio_open(&pFormatCtx->pb, STREAM_URL, AVIO_FLAG_WRITE);
    if (ret < 0) {
        av_strerror(ret, errbuf, sizeof(errbuf));
        fprintf(stderr, "Failed to open output stream: %s\n", errbuf);
        return -1;
    }

    // 写文件头
    ret = avformat_write_header(pFormatCtx, NULL);
    if (ret < 0) {
        av_strerror(ret, errbuf, sizeof(errbuf));
        fprintf(stderr, "Failed to write file header: %s\n", errbuf);
        return -1;
    }

    // 循环发送视频帧
    gettimeofday(&start_time, NULL);
    start_time_ms = start_time.tv_sec * 1000 + start_time.tv_usec / 1000;
    for (i = 0; i < 100; i++) {
        // 填充图像数据
        pFrame->data[0] = (uint8_t *) malloc(video_width * video_height);
        pFrame->data[1] = (uint8_t *) malloc(video_width * video_height / 4);
        pFrame->data[2] = (uint8_t *) malloc(video_width * video_height / 4);
        pFrame->linesize[0] = video_width;
        pFrame->linesize[1] = video_width / 2;
        pFrame->linesize[2] = video_width / 2;
        memset(pFrame->data[0], 255, video_width * video_height);
        memset(pFrame->data[1], 128, video_width * video_height / 4);
        memset(pFrame->data[2], 128, video_width * video_height / 4);

        // 编码视频帧
        pFrame->pts = i * (pCodecCtx->time_base.den) / ((pCodecCtx->time_base.num) * video_fps);
        ret = avcodec_send_frame(pCodecCtx, pFrame);
        if (ret < 0) {
            av_strerror(ret, errbuf, sizeof(errbuf));
            fprintf(stderr, "Failed to send frame: %s\n", errbuf);
            return -1;
        }

        while (1) {
            ret = avcodec_receive_packet(pCodecCtx, &pkt);
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
                break;
            if (ret < 0) {
                av_strerror(ret, errbuf, sizeof(errbuf));
                fprintf(stderr, "Failed to receive packet: %s\n", errbuf);
                return -1;
            }

            // 写视频帧到输出流
            pkt.stream_index = pStream->index;
            av_packet_rescale_ts(&pkt, pCodecCtx->time_base, pStream->time_base);
            ret = av_interleaved_write_frame(pFormatCtx, &pkt);
            if (ret < 0) {
                av_strerror(ret, errbuf, sizeof(errbuf));
                fprintf(stderr, "Failed to write frame: %s\n", errbuf);
                return -1;
            }
            av_packet_unref(&pkt);
        }

        free(pFrame->data[0]);
        free(pFrame->data[1]);
        free(pFrame->data[2]);
    }

    // 写文件尾
    ret = av_write_trailer(pFormatCtx);
    if (ret < 0) {
        av_strerror(ret, errbuf, sizeof(errbuf));
        fprintf(stderr, "Failed to write file trailer: %s\n", errbuf);
        return -1;
    }

    // 释放资源
    avio_close(pFormatCtx->pb);
    avformat_free_context(pFormatCtx);
    avcodec_free_context(&pCodecCtx);
    av_frame_free(&pFrame);

    gettimeofday(&end_time, NULL);
    end_time_ms = end_time.tv_sec * 1000 + end_time.tv_usec / 1000;
    printf("Total time: %lldms\n", end_time_ms - start_time_ms);

    return 0;
}

要调节帧率，你需要修改以下两个参数：

int video_fps = 30; // 设置帧率为30fps

pCodecCtx->time_base.den = video_fps;

你可以将`video_fps`变量设置为你想要的帧率，例如60fps，然后重新编译代码即可。对于拉流，你可以在解码器的参数中设置帧率。