探索FFmpeg：实现自定义播放速度的全方位指南（二）

extern "C" {
#include <libavformat/avformat.h>
}
int main() {
    AVFormatContext *pFormatCtx = nullptr;
    // Register all formats and codecs
    av_register_all();
    // Open video file
    if(avformat_open_input(&pFormatCtx, "your_video.mp4", nullptr, nullptr) != 0)
        return -1; // Couldn't open file
    // Retrieve stream information
    if(avformat_find_stream_info(pFormatCtx, nullptr) < 0)
        return -1; // Couldn't find stream information
    // ... to be continued
}

// ... continuing from above
AVPacket packet;
while(av_read_frame(pFormatCtx, &packet) >= 0) {
    // Let's pretend packet.stream_index is the video stream
    if(packet.stream_index == videoStream) {
        // Modify the packet's timestamp (DTS and PTS)
        packet.dts /= 2;
        packet.pts /= 2;
        // ... then feed the packet into the decoder
        // ... and retrieve the decoded frames
    }
    // Free the packet that was allocated by av_read_frame
    av_packet_unref(&packet);
}
// ... to be continued

// ... continuing from above
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavutil/imgutils.h>
#include <libswscale/swscale.h>
}
// Find the decoder for the video stream
AVCodecParameters *pCodecParameters = pFormatCtx->streams[videoStream]->codecpar;
AVCodec *pCodec = avcodec_find_decoder(pCodecParameters->codec_id);
if(pCodec == nullptr) {
    fprintf(stderr, "Unsupported codec!\n");
    return -1; // Codec not found
}
// Open codec
AVCodecContext *pCodecCtx = avcodec_alloc_context3(pCodec);
if(avcodec_open2(pCodecCtx, pCodec, nullptr) < 0)
    return -1; // Could not open codec
// Allocate video frame
AVFrame *pFrame = av_frame_alloc();
// Allocate an AVFrame structure
AVFrame *pFrameRGB = av_frame_alloc();
if(pFrameRGB == nullptr)
    return -1;
// Determine required buffer size and allocate buffer
int numBytes = av_image_get_buffer_size(AV_PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height, 1);
uint8_t *buffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));
// Assign appropriate parts of buffer to image planes in pFrameRGB
av_image_fill_arrays(pFrameRGB->data, pFrameRGB->linesize, buffer, AV_PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height, 1);
// Read frames and save first five frames to disk
int frameFinished;
AVPacket packet;
struct SwsContext *sws_ctx = nullptr;
sws_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_RGB24, SWS_BILINEAR, nullptr, nullptr, nullptr);
while(av_read_frame(pFormatCtx, &packet) >= 0) {
    // Is this a packet from the video stream?
    if(packet.stream_index == videoStream) {
        // Decode video frame
        avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
        // Did we get a video frame?
        if(frameFinished) {
            // Convert the image from its native format to RGB
            sws_scale(sws_ctx, (uint8_t const * const *)pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameRGB->data, pFrameRGB->linesize);
            // Modify the time_base of the video stream to control the playback speed
            // Here we assume that we want to double the speed of the video
            pCodecCtx->time_base.num /= 2;
            // Save the frame to disk
            // Here we're just saving the first 5 frames, you could change this to save whichever frames you want
            if(++i <= 5)
                SaveFrame(pFrameRGB, pCodecCtx->width, pCodecCtx->height, i);
        }
    }
    // Free the packet that was allocated by av_read_frame
    av_packet_unref(&packet);
}
// Free the RGB image
av_free(buffer);
av_frame_free(&pFrameRGB);
// Free the YUV frame
av_frame_free(&pFrame);
// Close the codec
avcodec_close(pCodecCtx);
// Close the video file
avformat_close_input(&pFormatCtx);
return 0;
}

// ... continuing from above
// For simplicity, we assume that we want to upscale from 20FPS to 30FPS
// That means we need to add a frame every 2 frames
int counter = 2;
while(av_read_frame(pFormatCtx, &packet) >= 0) {
    // Is this a packet from the video stream?
    if(packet.stream_index == videoStream) {
        // Decode video frame
        avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
        // Did we get a video frame?
        if(frameFinished) {
            // Convert the image from its native format to RGB
            sws_scale(sws_ctx, (uint8_t const * const *)pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameRGB->data, pFrameRGB->linesize);
            // Encode the frame and add it to the output stream
            // Here we assume that we have a function called encode_frame that takes care of the encoding
            encode_frame(pFrameRGB);
            // If the counter hits zero, encode the same frame again (but with an increased PTS) and reset the counter
          if(--counter == 0) {
              pFrameRGB->pts += av_rescale_q(1, pCodecCtx->time_base, time_base);
              encode_frame(pFrameRGB);
              counter = 2;
          }
}

ffmpeg -i <input> -filter:v fps=30 <output>

sudo apt-get install libsamplerate0-dev

#include <stdio.h>
#include <stdlib.h>
#include <samplerate.h>
#define INPUT_RATE 44100.0
#define OUTPUT_RATE 48000.0
#define INPUT_BUFFER_SIZE 1024
int main() {
    SRC_STATE *src_state;
    SRC_DATA src_data;
    int error;
    // 创建重采样器
    src_state = src_new(SRC_SINC_FASTEST, 1, &error);
    if (src_state == NULL) {
        printf("Error creating the resampler: %s\n", src_strerror(error));
        exit(1);
    }
    // 初始化SRC_DATA结构
    float input_buffer[INPUT_BUFFER_SIZE];
    float output_buffer[(int)(INPUT_BUFFER_SIZE * (OUTPUT_RATE / INPUT_RATE)) + 1];
    src_data.data_in = input_buffer;
    src_data.input_frames = INPUT_BUFFER_SIZE;
    src_data.data_out = output_buffer;
    src_data.output_frames = sizeof(output_buffer) / sizeof(*output_buffer);
    src_data.src_ratio = OUTPUT_RATE / INPUT_RATE;
    // 从某处获取输入数据，例如文件、设备等。
    // 执行重采样
    error = src_process(src_state, &src_data);
    if (error) {
        printf("Error resampling: %s\n", src_strerror(error));
        exit(1);
    }
    // 使用输出数据，例如写入文件、发送到设备等。
    // 删除重采样器
    src_delete(src_state);
    return 0;
}