From 4a6d9312cc1c9d62d66c4def71246d9faae29edb Mon Sep 17 00:00:00 2001
From: zhangmeng <775834166@qq.com>
Date: 星期三, 03 三月 2021 14:26:16 +0800
Subject: [PATCH] environment settings
---
module/VideoPlayer/lib/linux/ffmpeg/share/ffmpeg/examples/qsvdec.c | 271 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 271 insertions(+), 0 deletions(-)
diff --git a/module/VideoPlayer/lib/linux/ffmpeg/share/ffmpeg/examples/qsvdec.c b/module/VideoPlayer/lib/linux/ffmpeg/share/ffmpeg/examples/qsvdec.c
new file mode 100644
index 0000000..7415eef
--- /dev/null
+++ b/module/VideoPlayer/lib/linux/ffmpeg/share/ffmpeg/examples/qsvdec.c
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) 2015 Anton Khirnov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/**
+ * @file
+ * Intel QSV-accelerated H.264 decoding example.
+ *
+ * @example qsvdec.c
+ * This example shows how to do QSV-accelerated H.264 decoding with output
+ * frames in the GPU video surfaces.
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+
+#include "libavformat/avformat.h"
+#include "libavformat/avio.h"
+
+#include "libavcodec/avcodec.h"
+
+#include "libavutil/buffer.h"
+#include "libavutil/error.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_qsv.h"
+#include "libavutil/mem.h"
+
+typedef struct DecodeContext {
+ AVBufferRef *hw_device_ref;
+} DecodeContext;
+
+static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
+{
+ while (*pix_fmts != AV_PIX_FMT_NONE) {
+ if (*pix_fmts == AV_PIX_FMT_QSV) {
+ DecodeContext *decode = avctx->opaque;
+ AVHWFramesContext *frames_ctx;
+ AVQSVFramesContext *frames_hwctx;
+ int ret;
+
+ /* create a pool of surfaces to be used by the decoder */
+ avctx->hw_frames_ctx = av_hwframe_ctx_alloc(decode->hw_device_ref);
+ if (!avctx->hw_frames_ctx)
+ return AV_PIX_FMT_NONE;
+ frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+ frames_hwctx = frames_ctx->hwctx;
+
+ frames_ctx->format = AV_PIX_FMT_QSV;
+ frames_ctx->sw_format = avctx->sw_pix_fmt;
+ frames_ctx->width = FFALIGN(avctx->coded_width, 32);
+ frames_ctx->height = FFALIGN(avctx->coded_height, 32);
+ frames_ctx->initial_pool_size = 32;
+
+ frames_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
+
+ ret = av_hwframe_ctx_init(avctx->hw_frames_ctx);
+ if (ret < 0)
+ return AV_PIX_FMT_NONE;
+
+ return AV_PIX_FMT_QSV;
+ }
+
+ pix_fmts++;
+ }
+
+ fprintf(stderr, "The QSV pixel format not offered in get_format()\n");
+
+ return AV_PIX_FMT_NONE;
+}
+
+static int decode_packet(DecodeContext *decode, AVCodecContext *decoder_ctx,
+ AVFrame *frame, AVFrame *sw_frame,
+ AVPacket *pkt, AVIOContext *output_ctx)
+{
+ int ret = 0;
+
+ ret = avcodec_send_packet(decoder_ctx, pkt);
+ if (ret < 0) {
+ fprintf(stderr, "Error during decoding\n");
+ return ret;
+ }
+
+ while (ret >= 0) {
+ int i, j;
+
+ ret = avcodec_receive_frame(decoder_ctx, frame);
+ if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+ break;
+ else if (ret < 0) {
+ fprintf(stderr, "Error during decoding\n");
+ return ret;
+ }
+
+ /* A real program would do something useful with the decoded frame here.
+ * We just retrieve the raw data and write it to a file, which is rather
+ * useless but pedagogic. */
+ ret = av_hwframe_transfer_data(sw_frame, frame, 0);
+ if (ret < 0) {
+ fprintf(stderr, "Error transferring the data to system memory\n");
+ goto fail;
+ }
+
+ for (i = 0; i < FF_ARRAY_ELEMS(sw_frame->data) && sw_frame->data[i]; i++)
+ for (j = 0; j < (sw_frame->height >> (i > 0)); j++)
+ avio_write(output_ctx, sw_frame->data[i] + j * sw_frame->linesize[i], sw_frame->width);
+
+fail:
+ av_frame_unref(sw_frame);
+ av_frame_unref(frame);
+
+ if (ret < 0)
+ return ret;
+ }
+
+ return 0;
+}
+
+int main(int argc, char **argv)
+{
+ AVFormatContext *input_ctx = NULL;
+ AVStream *video_st = NULL;
+ AVCodecContext *decoder_ctx = NULL;
+ const AVCodec *decoder;
+
+ AVPacket pkt = { 0 };
+ AVFrame *frame = NULL, *sw_frame = NULL;
+
+ DecodeContext decode = { NULL };
+
+ AVIOContext *output_ctx = NULL;
+
+ int ret, i;
+
+ if (argc < 3) {
+ fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
+ return 1;
+ }
+
+ /* open the input file */
+ ret = avformat_open_input(&input_ctx, argv[1], NULL, NULL);
+ if (ret < 0) {
+ fprintf(stderr, "Cannot open input file '%s': ", argv[1]);
+ goto finish;
+ }
+
+ /* find the first H.264 video stream */
+ for (i = 0; i < input_ctx->nb_streams; i++) {
+ AVStream *st = input_ctx->streams[i];
+
+ if (st->codecpar->codec_id == AV_CODEC_ID_H264 && !video_st)
+ video_st = st;
+ else
+ st->discard = AVDISCARD_ALL;
+ }
+ if (!video_st) {
+ fprintf(stderr, "No H.264 video stream in the input file\n");
+ goto finish;
+ }
+
+ /* open the hardware device */
+ ret = av_hwdevice_ctx_create(&decode.hw_device_ref, AV_HWDEVICE_TYPE_QSV,
+ "auto", NULL, 0);
+ if (ret < 0) {
+ fprintf(stderr, "Cannot open the hardware device\n");
+ goto finish;
+ }
+
+ /* initialize the decoder */
+ decoder = avcodec_find_decoder_by_name("h264_qsv");
+ if (!decoder) {
+ fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
+ goto finish;
+ }
+
+ decoder_ctx = avcodec_alloc_context3(decoder);
+ if (!decoder_ctx) {
+ ret = AVERROR(ENOMEM);
+ goto finish;
+ }
+ decoder_ctx->codec_id = AV_CODEC_ID_H264;
+ if (video_st->codecpar->extradata_size) {
+ decoder_ctx->extradata = av_mallocz(video_st->codecpar->extradata_size +
+ AV_INPUT_BUFFER_PADDING_SIZE);
+ if (!decoder_ctx->extradata) {
+ ret = AVERROR(ENOMEM);
+ goto finish;
+ }
+ memcpy(decoder_ctx->extradata, video_st->codecpar->extradata,
+ video_st->codecpar->extradata_size);
+ decoder_ctx->extradata_size = video_st->codecpar->extradata_size;
+ }
+
+ decoder_ctx->opaque = &decode;
+ decoder_ctx->get_format = get_format;
+
+ ret = avcodec_open2(decoder_ctx, NULL, NULL);
+ if (ret < 0) {
+ fprintf(stderr, "Error opening the decoder: ");
+ goto finish;
+ }
+
+ /* open the output stream */
+ ret = avio_open(&output_ctx, argv[2], AVIO_FLAG_WRITE);
+ if (ret < 0) {
+ fprintf(stderr, "Error opening the output context: ");
+ goto finish;
+ }
+
+ frame = av_frame_alloc();
+ sw_frame = av_frame_alloc();
+ if (!frame || !sw_frame) {
+ ret = AVERROR(ENOMEM);
+ goto finish;
+ }
+
+ /* actual decoding */
+ while (ret >= 0) {
+ ret = av_read_frame(input_ctx, &pkt);
+ if (ret < 0)
+ break;
+
+ if (pkt.stream_index == video_st->index)
+ ret = decode_packet(&decode, decoder_ctx, frame, sw_frame, &pkt, output_ctx);
+
+ av_packet_unref(&pkt);
+ }
+
+ /* flush the decoder */
+ pkt.data = NULL;
+ pkt.size = 0;
+ ret = decode_packet(&decode, decoder_ctx, frame, sw_frame, &pkt, output_ctx);
+
+finish:
+ if (ret < 0) {
+ char buf[1024];
+ av_strerror(ret, buf, sizeof(buf));
+ fprintf(stderr, "%s\n", buf);
+ }
+
+ avformat_close_input(&input_ctx);
+
+ av_frame_free(&frame);
+ av_frame_free(&sw_frame);
+
+ avcodec_free_context(&decoder_ctx);
+
+ av_buffer_unref(&decode.hw_device_ref);
+
+ avio_close(output_ctx);
+
+ return ret;
+}
--
Gitblit v1.8.0