ffmpeg+qsv 硬编码成yuv420p的数据

你可以使用以下命令将视频文件硬编码为YUV420P格式的数据：

ffmpeg -hwaccel qsv -c:v h264_qsv -i input.mp4 -pix_fmt yuv420p -f rawvideo output.yuv

这里使用了QSV硬件加速器来进行编码，并选择了H.264编码器。输入文件是input.mp4，输出文件是output.yuv。通过设置-pix_fmt选项，可以将输出的像素格式设置为YUV420P。最后，-f rawvideo选项将输出数据格式设置为原始视频数据。

相关问题

ffmpeg+qsv 硬编码成yuv420p的数据，给些代码示例

这里提供一个使用FFmpeg和QSV硬编码器将视频文件编码为YUV420P格式数据的C++代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/avutil.h>
#include <libavutil/pixdesc.h>
#include <libavutil/opt.h>
}

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

    AVFormatContext* input_ctx = NULL;
    int ret = avformat_open_input(&input_ctx, argv[1], NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Failed to open input file: %s\n", argv[1]);
        return 1;
    }

    ret = avformat_find_stream_info(input_ctx, NULL);
    if (ret < 0) {
        fprintf(stderr, "Failed to find stream information\n");
        return 1;
    }

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

    if (video_stream_idx < 0) {
        fprintf(stderr, "No video stream found\n");
        return 1;
    }

    AVCodec* codec = avcodec_find_decoder(input_ctx->streams[video_stream_idx]->codecpar->codec_id);
    if (!codec) {
        fprintf(stderr, "Unsupported codec!\n");
        return 1;
    }

    AVCodecContext* codec_ctx = avcodec_alloc_context3(codec);
    if (!codec_ctx) {
        fprintf(stderr, "Failed to allocate codec context\n");
        return 1;
    }

    ret = avcodec_parameters_to_context(codec_ctx, input_ctx->streams[video_stream_idx]->codecpar);
    if (ret < 0) {
        fprintf(stderr, "Failed to copy codec parameters to context\n");
        return 1;
    }

    ret = avcodec_open2(codec_ctx, codec, NULL);
    if (ret < 0) {
        fprintf(stderr, "Failed to open codec\n");
        return 1;
    }

    AVFrame* frame = av_frame_alloc();
    if (!frame) {
        fprintf(stderr, "Failed to allocate frame\n");
        return 1;
    }

    AVPacket packet;
    av_init_packet(&packet);

    AVCodec* enc_codec = avcodec_find_encoder_by_name("h264_qsv");
    if (!enc_codec) {
        fprintf(stderr, "Failed to find QSV encoder\n");
        return 1;
    }

    AVCodecContext* enc_ctx = avcodec_alloc_context3(enc_codec);
    if (!enc_ctx) {
        fprintf(stderr, "Failed to allocate encoder context\n");
        return 1;
    }

    enc_ctx->width = codec_ctx->width;
    enc_ctx->height = codec_ctx->height;
    enc_ctx->time_base = codec_ctx->time_base;
    enc_ctx->framerate = codec_ctx->framerate;
    enc_ctx->pix_fmt = AV_PIX_FMT_NV12; // set output pixel format to NV12
    enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

    ret = avcodec_open2(enc_ctx, enc_codec, NULL);
    if (ret < 0) {
        fprintf(stderr, "Failed to open encoder\n");
        return 1;
    }

    FILE* output_file = fopen("output.yuv", "wb");
    if (!output_file) {
        fprintf(stderr, "Failed to open output file\n");
        return 1;
    }

    while (av_read_frame(input_ctx, &packet) >= 0) {
        if (packet.stream_index != video_stream_idx) {
            av_packet_unref(&packet);
            continue;
        }

        ret = avcodec_send_packet(codec_ctx, &packet);
        if (ret < 0) {
            fprintf(stderr, "Failed to send packet to decoder\n");
            break;
        }

        while (ret >= 0) {
            ret = avcodec_receive_frame(codec_ctx, frame);
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                break;
            }
            else if (ret < 0) {
                fprintf(stderr, "Failed to receive frame from decoder\n");
                goto end;
            }

            AVFrame* enc_frame = av_frame_alloc();
            if (!enc_frame) {
                fprintf(stderr, "Failed to allocate encoder frame\n");
                goto end;
            }

            enc_frame->format = enc_ctx->pix_fmt;
            enc_frame->width = enc_ctx->width;
            enc_frame->height = enc_ctx->height;

            ret = av_frame_get_buffer(enc_frame, 32);
            if (ret < 0) {
                fprintf(stderr, "Failed to allocate encoder frame buffer\n");
                av_frame_free(&enc_frame);
                goto end;
            }

            ret = av_hwframe_transfer_data(enc_frame, frame, 0);
            if (ret < 0) {
                fprintf(stderr, "Failed to transfer frame data to encoder\n");
                av_frame_free(&enc_frame);
                goto end;
            }

            AVPacket enc_packet;
            av_init_packet(&enc_packet);

            ret = avcodec_send_frame(enc_ctx, enc_frame);
            if (ret < 0) {
                fprintf(stderr, "Failed to send frame to encoder\n");
                av_packet_unref(&enc_packet);
                av_frame_free(&enc_frame);
                goto end;
            }

            while (ret >= 0) {
                ret = avcodec_receive_packet(enc_ctx, &enc_packet);
                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                    break;
                }
                else if (ret < 0) {
                    fprintf(stderr, "Failed to receive packet from encoder\n");
                    av_packet_unref(&enc_packet);
                    av_frame_free(&enc_frame);
                    goto end;
                }

                fwrite(enc_packet.data, 1, enc_packet.size, output_file);

                av_packet_unref(&enc_packet);
            }

            av_frame_free(&enc_frame);
        }

        av_packet_unref(&packet);
    }

end:
    fclose(output_file);

    avcodec_free_context(&enc_ctx);
    avcodec_free_context(&codec_ctx);
    avformat_close_input(&input_ctx);
    av_frame_free(&frame);

    return 0;
}

这个示例代码使用H.264 QSV硬编码器将输入文件编码为YUV420P格式数据，并将结果保存到输出文件output.yuv中。

windows下qt+ffmpeg+qsv解码显示

在Windows平台上，可以使用Qt和FFmpeg以及Intel Quick Sync Video（QSV）来进行视频解码和显示。首先，需要在Qt中集成FFmpeg库，以便能够使用其功能进行视频解码。可以使用QMediaPlayer类来实现视频的播放和显示，并利用FFmpeg的解码能力将视频文件解析成视频帧，然后使用QImage将视频帧显示在Qt的窗口中。

同时，QSV是Intel提供的一种硬件加速视频编解码技术，可以在支持Intel集显的计算机上利用QSV来加速视频处理。可以使用Intel提供的Media SDK来实现QSV的功能，通过集成Media SDK和Qt来实现视频解码和显示。在使用QSV时，可以利用QSV提供的硬件加速功能来加速视频解码和显示，提高视频处理的效率和性能。

使用Qt、FFmpeg和QSV进行视频解码和显示可以实现高效的视频处理和播放功能，在Windows平台上可以充分利用硬件加速技术以及丰富的多媒体库来实现视频播放和显示的需求。通过将这些组件结合起来，可以实现高质量、高性能的视频解码和显示，为用户提供流畅的观影体验。