[FFmpeg-cvslog] lavc: add an Intel libmfx-based H.264 decoder
Anton Khirnov
git at videolan.org
Thu Feb 19 21:27:41 CET 2015
ffmpeg | branch: master | Anton Khirnov <anton at khirnov.net> | Tue Feb 10 10:40:59 2015 +0100| [4e08c821106fc1d6d358864abf0d8488b12f38c6] | committer: Anton Khirnov
lavc: add an Intel libmfx-based H.264 decoder
Based on the code by Luca Barbato <lu_zero at gentoo.org> and Yukinori
Yamazoe <drocon11 at gmail.com>.
> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=4e08c821106fc1d6d358864abf0d8488b12f38c6
---
Changelog | 1 +
configure | 6 +
libavcodec/Makefile | 5 +
libavcodec/allcodecs.c | 2 +
libavcodec/qsv.c | 362 +++++++++++++++++++++++++++++++++++++++++++++
libavcodec/qsv.h | 41 +++++
libavcodec/qsv_api.c | 28 ++++
libavcodec/qsv_h264.c | 313 +++++++++++++++++++++++++++++++++++++++
libavcodec/qsv_internal.h | 86 +++++++++++
libavcodec/version.h | 2 +-
10 files changed, 845 insertions(+), 1 deletion(-)
diff --git a/Changelog b/Changelog
index c755196..057e676 100644
--- a/Changelog
+++ b/Changelog
@@ -14,6 +14,7 @@ version <next>:
- Support DNx100 (960x720 at 8)
- DXVA2-accelerated HEVC decoding
- AAC ELD 480 decoding
+- Intel QSV-accelerated H.264 decoding
version 11:
diff --git a/configure b/configure
index 056f0f2..5e634ab 100755
--- a/configure
+++ b/configure
@@ -189,6 +189,7 @@ External library support:
--enable-libfreetype enable libfreetype [no]
--enable-libgsm enable GSM de/encoding via libgsm [no]
--enable-libilbc enable iLBC de/encoding via libilbc [no]
+ --enable-libmfx enable HW acceleration through libmfx
--enable-libmp3lame enable MP3 encoding via libmp3lame [no]
--enable-libopencore-amrnb enable AMR-NB de/encoding via libopencore-amrnb [no]
--enable-libopencore-amrwb enable AMR-WB decoding via libopencore-amrwb [no]
@@ -1153,6 +1154,7 @@ EXTERNAL_LIBRARY_LIST="
libfreetype
libgsm
libilbc
+ libmfx
libmp3lame
libopencore_amrnb
libopencore_amrwb
@@ -1235,6 +1237,7 @@ SUBSYSTEM_LIST="
lzo
mdct
network
+ qsv
rdft
"
@@ -1820,6 +1823,8 @@ h263i_decoder_select="h263_decoder"
h263p_encoder_select="h263_encoder"
h264_decoder_select="cabac golomb h264chroma h264dsp h264pred h264qpel startcode videodsp"
h264_decoder_suggest="error_resilience"
+h264_qsv_decoder_deps="libmfx"
+h264_qsv_decoder_select="h264_mp4toannexb_bsf h264_parser qsv h264_qsv_hwaccel"
hevc_decoder_select="bswapdsp cabac golomb videodsp"
huffyuv_decoder_select="bswapdsp huffyuvdsp"
huffyuv_encoder_select="bswapdsp huffman huffyuvencdsp"
@@ -4195,6 +4200,7 @@ enabled libgsm && { for gsm_hdr in "gsm.h" "gsm/gsm.h"; do
check_lib "${gsm_hdr}" gsm_create -lgsm && break;
done || die "ERROR: libgsm not found"; }
enabled libilbc && require libilbc ilbc.h WebRtcIlbcfix_InitDecode -lilbc
+enabled libmfx && require_pkg_config libmfx "mfx/mfxvideo.h" MFXInit
enabled libmp3lame && require "libmp3lame >= 3.98.3" lame/lame.h lame_set_VBR_quality -lmp3lame
enabled libopencore_amrnb && require libopencore_amrnb opencore-amrnb/interf_dec.h Decoder_Interface_init -lopencore-amrnb
enabled libopencore_amrwb && require libopencore_amrwb opencore-amrwb/dec_if.h D_IF_init -lopencore-amrwb
diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index de244a6..8005de5 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -4,6 +4,7 @@ HEADERS = avcodec.h \
avfft.h \
dv_profile.h \
dxva2.h \
+ qsv.h \
vaapi.h \
vda.h \
vdpau.h \
@@ -24,6 +25,7 @@ OBJS = allcodecs.o \
mathtables.o \
options.o \
parser.o \
+ qsv_api.o \
raw.o \
utils.o \
vorbis_parser.o \
@@ -78,6 +80,7 @@ OBJS-$(CONFIG_MPEGVIDEOENC) += mpegvideo_enc.o mpeg12data.o \
mpegvideoencdsp.o
OBJS-$(CONFIG_PIXBLOCKDSP) += pixblockdsp.o
OBJS-$(CONFIG_QPELDSP) += qpeldsp.o
+OBJS-$(CONFIG_QSV) += qsv.o
OBJS-$(CONFIG_RANGECODER) += rangecoder.o
RDFT-OBJS-$(CONFIG_HARDCODED_TABLES) += sin_tables.o
OBJS-$(CONFIG_RDFT) += rdft.o $(RDFT-OBJS-yes)
@@ -218,6 +221,7 @@ OBJS-$(CONFIG_H264_DECODER) += h264.o h264_cabac.o h264_cavlc.o \
h264_direct.o h264_loopfilter.o \
h264_mb.o h264_picture.o h264_ps.o \
h264_refs.o h264_sei.o h264_slice.o
+OBJS-$(CONFIG_H264_QSV_DECODER) += qsv_h264.o
OBJS-$(CONFIG_HEVC_DECODER) += hevc.o hevc_mvs.o hevc_ps.o hevc_sei.o \
hevc_cabac.o hevc_refs.o hevcpred.o \
hevcdsp.o hevc_filter.o
@@ -712,6 +716,7 @@ SKIPHEADERS += %_tablegen.h \
SKIPHEADERS-$(CONFIG_DXVA2) += dxva2.h dxva2_internal.h
SKIPHEADERS-$(CONFIG_LIBSCHROEDINGER) += libschroedinger.h
SKIPHEADERS-$(CONFIG_MPEG_XVMC_DECODER) += xvmc.h
+SKIPHEADERS-$(CONFIG_QSV) += qsv_internal.h
SKIPHEADERS-$(CONFIG_VAAPI) += vaapi_internal.h
SKIPHEADERS-$(CONFIG_VDA) += vda.h vda_internal.h
SKIPHEADERS-$(CONFIG_VDPAU) += vdpau.h vdpau_internal.h
diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
index bda8f53..fd66e20 100644
--- a/libavcodec/allcodecs.c
+++ b/libavcodec/allcodecs.c
@@ -77,6 +77,7 @@ void avcodec_register_all(void)
REGISTER_HWACCEL(H263_VAAPI, h263_vaapi);
REGISTER_HWACCEL(H263_VDPAU, h263_vdpau);
REGISTER_HWACCEL(H264_DXVA2, h264_dxva2);
+ REGISTER_HWACCEL(H264_QSV, h264_qsv);
REGISTER_HWACCEL(H264_VAAPI, h264_vaapi);
REGISTER_HWACCEL(H264_VDA, h264_vda);
REGISTER_HWACCEL(H264_VDA_OLD, h264_vda_old);
@@ -160,6 +161,7 @@ void avcodec_register_all(void)
REGISTER_DECODER(H263I, h263i);
REGISTER_ENCODER(H263P, h263p);
REGISTER_DECODER(H264, h264);
+ REGISTER_DECODER(H264_QSV, h264_qsv);
REGISTER_DECODER(HEVC, hevc);
REGISTER_DECODER(HNM4_VIDEO, hnm4_video);
REGISTER_ENCDEC (HUFFYUV, huffyuv);
diff --git a/libavcodec/qsv.c b/libavcodec/qsv.c
new file mode 100644
index 0000000..3b2a75b
--- /dev/null
+++ b/libavcodec/qsv.c
@@ -0,0 +1,362 @@
+/*
+ * Intel MediaSDK QSV codec-independent code
+ *
+ * copyright (c) 2013 Luca Barbato
+ * copyright (c) 2015 Anton Khirnov <anton at khirnov.net>
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <string.h>
+#include <sys/types.h>
+
+#include <mfx/mfxvideo.h>
+
+#include "libavutil/common.h"
+#include "libavutil/mem.h"
+#include "libavutil/log.h"
+#include "libavutil/pixfmt.h"
+#include "libavutil/time.h"
+
+#include "avcodec.h"
+#include "internal.h"
+#include "qsv_internal.h"
+
+int ff_qsv_error(int mfx_err)
+{
+ switch (mfx_err) {
+ case MFX_ERR_NONE:
+ return 0;
+ case MFX_ERR_MEMORY_ALLOC:
+ case MFX_ERR_NOT_ENOUGH_BUFFER:
+ return AVERROR(ENOMEM);
+ case MFX_ERR_INVALID_HANDLE:
+ return AVERROR(EINVAL);
+ case MFX_ERR_DEVICE_FAILED:
+ case MFX_ERR_DEVICE_LOST:
+ case MFX_ERR_LOCK_MEMORY:
+ return AVERROR(EIO);
+ case MFX_ERR_NULL_PTR:
+ case MFX_ERR_UNDEFINED_BEHAVIOR:
+ case MFX_ERR_NOT_INITIALIZED:
+ return AVERROR_BUG;
+ case MFX_ERR_UNSUPPORTED:
+ case MFX_ERR_NOT_FOUND:
+ return AVERROR(ENOSYS);
+ case MFX_ERR_MORE_DATA:
+ case MFX_ERR_MORE_SURFACE:
+ case MFX_ERR_MORE_BITSTREAM:
+ return AVERROR(EAGAIN);
+ case MFX_ERR_INCOMPATIBLE_VIDEO_PARAM:
+ case MFX_ERR_INVALID_VIDEO_PARAM:
+ return AVERROR(EINVAL);
+ case MFX_ERR_ABORTED:
+ case MFX_ERR_UNKNOWN:
+ default:
+ return AVERROR_UNKNOWN;
+ }
+}
+
+int ff_qsv_map_pixfmt(enum AVPixelFormat format)
+{
+ switch (format) {
+ case AV_PIX_FMT_YUV420P:
+ case AV_PIX_FMT_YUVJ420P:
+ return AV_PIX_FMT_NV12;
+ default:
+ return AVERROR(ENOSYS);
+ }
+}
+
+static int codec_id_to_mfx(enum AVCodecID codec_id)
+{
+ switch (codec_id) {
+ case AV_CODEC_ID_H264:
+ return MFX_CODEC_AVC;
+ case AV_CODEC_ID_MPEG1VIDEO:
+ case AV_CODEC_ID_MPEG2VIDEO:
+ return MFX_CODEC_MPEG2;
+ case AV_CODEC_ID_VC1:
+ return MFX_CODEC_VC1;
+ default:
+ break;
+ }
+
+ return AVERROR(ENOSYS);
+}
+
+static int qsv_init_session(AVCodecContext *avctx, QSVContext *q, mfxSession session)
+{
+ if (!session) {
+ if (!q->internal_session) {
+ mfxIMPL impl = MFX_IMPL_AUTO_ANY;
+ mfxVersion ver = { { QSV_VERSION_MINOR, QSV_VERSION_MAJOR } };
+
+ const char *desc;
+ int ret;
+
+ ret = MFXInit(impl, &ver, &q->internal_session);
+ if (ret < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Error initializing an internal MFX session\n");
+ return ff_qsv_error(ret);
+ }
+
+ MFXQueryIMPL(q->internal_session, &impl);
+
+ if (impl & MFX_IMPL_SOFTWARE)
+ desc = "software";
+ else if (impl & MFX_IMPL_HARDWARE)
+ desc = "hardware accelerated";
+ else
+ desc = "unknown";
+
+ av_log(avctx, AV_LOG_VERBOSE,
+ "Initialized an internal MFX session using %s implementation\n",
+ desc);
+ }
+
+ q->session = q->internal_session;
+ } else {
+ q->session = session;
+ }
+
+ /* make sure the decoder is uninitialized */
+ MFXVideoDECODE_Close(q->session);
+
+ return 0;
+}
+
+int ff_qsv_init(AVCodecContext *avctx, QSVContext *q, mfxSession session)
+{
+ mfxVideoParam param = { { 0 } };
+ int ret;
+
+ ret = qsv_init_session(avctx, q, session);
+ if (ret < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Error initializing an MFX session\n");
+ return ret;
+ }
+
+
+ ret = codec_id_to_mfx(avctx->codec_id);
+ if (ret < 0)
+ return ret;
+
+ param.mfx.CodecId = ret;
+ param.mfx.CodecProfile = avctx->profile;
+ param.mfx.CodecLevel = avctx->level;
+
+ param.mfx.FrameInfo.BitDepthLuma = 8;
+ param.mfx.FrameInfo.BitDepthChroma = 8;
+ param.mfx.FrameInfo.Shift = 0;
+ param.mfx.FrameInfo.FourCC = MFX_FOURCC_NV12;
+ param.mfx.FrameInfo.Width = avctx->coded_width;
+ param.mfx.FrameInfo.Height = avctx->coded_height;
+ param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
+
+ param.IOPattern = q->iopattern;
+ param.AsyncDepth = q->async_depth;
+ param.ExtParam = q->ext_buffers;
+ param.NumExtParam = q->nb_ext_buffers;
+
+ ret = MFXVideoDECODE_Init(q->session, ¶m);
+ if (ret < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Error initializing the MFX video decoder\n");
+ return ff_qsv_error(ret);
+ }
+
+ return 0;
+}
+
+static int alloc_frame(AVCodecContext *avctx, QSVFrame *frame)
+{
+ int ret;
+
+ ret = ff_get_buffer(avctx, frame->frame, AV_GET_BUFFER_FLAG_REF);
+ if (ret < 0)
+ return ret;
+
+ if (frame->frame->format == AV_PIX_FMT_QSV) {
+ frame->surface = (mfxFrameSurface1*)frame->frame->data[3];
+ } else {
+ frame->surface_internal.Info.BitDepthLuma = 8;
+ frame->surface_internal.Info.BitDepthChroma = 8;
+ frame->surface_internal.Info.FourCC = MFX_FOURCC_NV12;
+ frame->surface_internal.Info.Width = avctx->coded_width;
+ frame->surface_internal.Info.Height = avctx->coded_height;
+ frame->surface_internal.Info.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
+
+ frame->surface_internal.Data.PitchLow = frame->frame->linesize[0];
+ frame->surface_internal.Data.Y = frame->frame->data[0];
+ frame->surface_internal.Data.UV = frame->frame->data[1];
+
+ frame->surface = &frame->surface_internal;
+ }
+
+ return 0;
+}
+
+static void qsv_clear_unused_frames(QSVContext *q)
+{
+ QSVFrame *cur = q->work_frames;
+ while (cur) {
+ if (cur->surface && !cur->surface->Data.Locked) {
+ cur->surface = NULL;
+ av_frame_unref(cur->frame);
+ }
+ cur = cur->next;
+ }
+}
+
+static int get_surface(AVCodecContext *avctx, QSVContext *q, mfxFrameSurface1 **surf)
+{
+ QSVFrame *frame, **last;
+ int ret;
+
+ qsv_clear_unused_frames(q);
+
+ frame = q->work_frames;
+ last = &q->work_frames;
+ while (frame) {
+ if (!frame->surface) {
+ ret = alloc_frame(avctx, frame);
+ if (ret < 0)
+ return ret;
+ *surf = frame->surface;
+ return 0;
+ }
+
+ last = &frame->next;
+ frame = frame->next;
+ }
+
+ frame = av_mallocz(sizeof(*frame));
+ if (!frame)
+ return AVERROR(ENOMEM);
+ frame->frame = av_frame_alloc();
+ if (!frame->frame) {
+ av_freep(&frame);
+ return AVERROR(ENOMEM);
+ }
+ *last = frame;
+
+ ret = alloc_frame(avctx, frame);
+ if (ret < 0)
+ return ret;
+
+ *surf = frame->surface;
+
+ return 0;
+}
+
+static AVFrame *find_frame(QSVContext *q, mfxFrameSurface1 *surf)
+{
+ QSVFrame *cur = q->work_frames;
+ while (cur) {
+ if (surf == cur->surface)
+ return cur->frame;
+ cur = cur->next;
+ }
+ return NULL;
+}
+
+int ff_qsv_decode(AVCodecContext *avctx, QSVContext *q,
+ AVFrame *frame, int *got_frame,
+ AVPacket *avpkt)
+{
+ mfxFrameSurface1 *insurf;
+ mfxFrameSurface1 *outsurf;
+ mfxSyncPoint sync;
+ mfxBitstream bs = { { { 0 } } };
+ int ret;
+
+ if (avpkt->size) {
+ bs.Data = avpkt->data;
+ bs.DataLength = avpkt->size;
+ bs.MaxLength = bs.DataLength;
+ bs.TimeStamp = avpkt->pts;
+ }
+
+ do {
+ ret = get_surface(avctx, q, &insurf);
+ if (ret < 0)
+ return ret;
+
+ ret = MFXVideoDECODE_DecodeFrameAsync(q->session, avpkt->size ? &bs : NULL,
+ insurf, &outsurf, &sync);
+ if (ret == MFX_WRN_DEVICE_BUSY)
+ av_usleep(1);
+
+ } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_ERR_MORE_SURFACE);
+
+ if (ret != MFX_ERR_NONE &&
+ ret != MFX_ERR_MORE_DATA &&
+ ret != MFX_WRN_VIDEO_PARAM_CHANGED &&
+ ret != MFX_ERR_MORE_SURFACE) {
+ av_log(avctx, AV_LOG_ERROR, "Error during QSV decoding.\n");
+ return ff_qsv_error(ret);
+ }
+
+ if (sync) {
+ AVFrame *src_frame;
+
+ MFXVideoCORE_SyncOperation(q->session, sync, 60000);
+
+ src_frame = find_frame(q, outsurf);
+ if (!src_frame) {
+ av_log(avctx, AV_LOG_ERROR,
+ "The returned surface does not correspond to any frame\n");
+ return AVERROR_BUG;
+ }
+
+ ret = av_frame_ref(frame, src_frame);
+ if (ret < 0)
+ return ret;
+
+ frame->pkt_pts = frame->pts = outsurf->Data.TimeStamp;
+
+ frame->repeat_pict =
+ outsurf->Info.PicStruct & MFX_PICSTRUCT_FRAME_TRIPLING ? 4 :
+ outsurf->Info.PicStruct & MFX_PICSTRUCT_FRAME_DOUBLING ? 2 :
+ outsurf->Info.PicStruct & MFX_PICSTRUCT_FIELD_REPEATED ? 1 : 0;
+ frame->top_field_first =
+ outsurf->Info.PicStruct & MFX_PICSTRUCT_FIELD_TFF;
+ frame->interlaced_frame =
+ !(outsurf->Info.PicStruct & MFX_PICSTRUCT_PROGRESSIVE);
+
+ *got_frame = 1;
+ }
+
+ return bs.DataOffset;
+}
+
+int ff_qsv_close(QSVContext *q)
+{
+ QSVFrame *cur = q->work_frames;
+
+ while (cur) {
+ q->work_frames = cur->next;
+ av_frame_free(&cur->frame);
+ av_freep(&cur);
+ cur = q->work_frames;
+ }
+
+ if (q->internal_session)
+ MFXClose(q->internal_session);
+
+ return 0;
+}
diff --git a/libavcodec/qsv.h b/libavcodec/qsv.h
new file mode 100644
index 0000000..6532594
--- /dev/null
+++ b/libavcodec/qsv.h
@@ -0,0 +1,41 @@
+/*
+ * Intel MediaSDK QSV public API
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_QSV_H
+#define AVCODEC_QSV_H
+
+#include <mfx/mfxvideo.h>
+
+typedef struct AVQSVContext {
+ mfxSession session;
+ int iopattern;
+
+ mfxExtBuffer **ext_buffers;
+ int nb_ext_buffers;
+} AVQSVContext;
+
+/**
+ * Allocate a new context.
+ *
+ * It must be freed by the caller with av_free().
+ */
+AVQSVContext *av_qsv_alloc_context(void);
+
+#endif /* AVCODEC_QSV_H */
diff --git a/libavcodec/qsv_api.c b/libavcodec/qsv_api.c
new file mode 100644
index 0000000..8fde494
--- /dev/null
+++ b/libavcodec/qsv_api.c
@@ -0,0 +1,28 @@
+/*
+ * Intel MediaSDK QSV public API functions
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libavutil/mem.h"
+
+#include "qsv.h"
+
+AVQSVContext *av_qsv_alloc_context(void)
+{
+ return av_mallocz(sizeof(AVQSVContext));
+}
diff --git a/libavcodec/qsv_h264.c b/libavcodec/qsv_h264.c
new file mode 100644
index 0000000..a482e9c
--- /dev/null
+++ b/libavcodec/qsv_h264.c
@@ -0,0 +1,313 @@
+/*
+ * Intel MediaSDK QSV based H.264 decoder
+ *
+ * copyright (c) 2013 Luca Barbato
+ * copyright (c) 2015 Anton Khirnov
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <stdint.h>
+#include <string.h>
+
+#include <mfx/mfxvideo.h>
+
+#include "libavutil/common.h"
+#include "libavutil/fifo.h"
+#include "libavutil/opt.h"
+
+#include "avcodec.h"
+#include "internal.h"
+#include "qsv_internal.h"
+#include "qsv.h"
+
+typedef struct QSVH264Context {
+ AVClass *class;
+ QSVContext qsv;
+
+ // the internal parser and codec context for parsing the data
+ AVCodecParserContext *parser;
+ AVCodecContext *avctx_internal;
+ enum AVPixelFormat orig_pix_fmt;
+
+ // the filter for converting to Annex B
+ AVBitStreamFilterContext *bsf;
+
+ AVFifoBuffer *packet_fifo;
+
+ AVPacket input_ref;
+ AVPacket pkt_filtered;
+ uint8_t *filtered_data;
+} QSVH264Context;
+
+static void qsv_clear_buffers(QSVH264Context *s)
+{
+ AVPacket pkt;
+ while (av_fifo_size(s->packet_fifo) >= sizeof(pkt)) {
+ av_fifo_generic_read(s->packet_fifo, &pkt, sizeof(pkt), NULL);
+ av_packet_unref(&pkt);
+ }
+
+ if (s->filtered_data != s->input_ref.data)
+ av_freep(&s->filtered_data);
+ s->filtered_data = NULL;
+ av_packet_unref(&s->input_ref);
+}
+
+static av_cold int qsv_decode_close(AVCodecContext *avctx)
+{
+ QSVH264Context *s = avctx->priv_data;
+
+ ff_qsv_close(&s->qsv);
+
+ qsv_clear_buffers(s);
+
+ av_fifo_free(s->packet_fifo);
+
+ av_bitstream_filter_close(s->bsf);
+ av_parser_close(s->parser);
+ avcodec_free_context(&s->avctx_internal);
+
+ return 0;
+}
+
+static av_cold int qsv_decode_init(AVCodecContext *avctx)
+{
+ QSVH264Context *s = avctx->priv_data;
+ int ret;
+
+ s->orig_pix_fmt = AV_PIX_FMT_NONE;
+
+ s->packet_fifo = av_fifo_alloc(sizeof(AVPacket));
+ if (!s->packet_fifo) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+
+ s->bsf = av_bitstream_filter_init("h264_mp4toannexb");
+ if (!s->bsf) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+
+ s->avctx_internal = avcodec_alloc_context3(NULL);
+ if (!s->avctx_internal) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+
+ if (avctx->extradata) {
+ s->avctx_internal->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
+ if (!s->avctx_internal->extradata) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+ memcpy(s->avctx_internal->extradata, avctx->extradata,
+ avctx->extradata_size);
+ s->avctx_internal->extradata_size = avctx->extradata_size;
+ }
+
+ s->parser = av_parser_init(AV_CODEC_ID_H264);
+ if (!s->parser) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+ s->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
+
+ s->qsv.iopattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
+
+ return 0;
+fail:
+ qsv_decode_close(avctx);
+ return ret;
+}
+
+static int qsv_process_data(AVCodecContext *avctx, AVFrame *frame,
+ int *got_frame, AVPacket *pkt)
+{
+ QSVH264Context *s = avctx->priv_data;
+ uint8_t *dummy_data;
+ int dummy_size;
+ int ret;
+
+ /* we assume the packets are already split properly and want
+ * just the codec parameters here */
+ av_parser_parse2(s->parser, s->avctx_internal,
+ &dummy_data, &dummy_size,
+ pkt->data, pkt->size, pkt->pts, pkt->dts,
+ pkt->pos);
+
+ /* TODO: flush delayed frames on reinit */
+ if (s->parser->format != s->orig_pix_fmt ||
+ s->parser->coded_width != avctx->coded_width ||
+ s->parser->coded_height != avctx->coded_height) {
+ mfxSession session = NULL;
+
+ enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_QSV,
+ AV_PIX_FMT_NONE,
+ AV_PIX_FMT_NONE };
+ enum AVPixelFormat qsv_format;
+
+ qsv_format = ff_qsv_map_pixfmt(s->parser->format);
+ if (qsv_format < 0) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Only 8-bit YUV420 streams are supported.\n");
+ ret = AVERROR(ENOSYS);
+ goto reinit_fail;
+ }
+
+ s->orig_pix_fmt = s->parser->format;
+ avctx->pix_fmt = pix_fmts[1] = qsv_format;
+ avctx->width = s->parser->width;
+ avctx->height = s->parser->height;
+ avctx->coded_width = s->parser->coded_width;
+ avctx->coded_height = s->parser->coded_height;
+ avctx->level = s->avctx_internal->level;
+ avctx->profile = s->avctx_internal->profile;
+
+ ret = ff_get_format(avctx, pix_fmts);
+ if (ret < 0)
+ goto reinit_fail;
+
+ avctx->pix_fmt = ret;
+
+ if (avctx->hwaccel_context) {
+ AVQSVContext *user_ctx = avctx->hwaccel_context;
+ session = user_ctx->session;
+ s->qsv.iopattern = user_ctx->iopattern;
+ s->qsv.ext_buffers = user_ctx->ext_buffers;
+ s->qsv.nb_ext_buffers = user_ctx->nb_ext_buffers;
+ }
+
+ ret = ff_qsv_init(avctx, &s->qsv, session);
+ if (ret < 0)
+ goto reinit_fail;
+ }
+
+ return ff_qsv_decode(avctx, &s->qsv, frame, got_frame, &s->pkt_filtered);
+
+reinit_fail:
+ s->orig_pix_fmt = s->parser->format = avctx->pix_fmt = AV_PIX_FMT_NONE;
+ return ret;
+}
+
+static int qsv_decode_frame(AVCodecContext *avctx, void *data,
+ int *got_frame, AVPacket *avpkt)
+{
+ QSVH264Context *s = avctx->priv_data;
+ AVFrame *frame = data;
+ int ret;
+
+ /* buffer the input packet */
+ if (avpkt->size) {
+ AVPacket input_ref = { 0 };
+
+ if (av_fifo_space(s->packet_fifo) < sizeof(input_ref)) {
+ ret = av_fifo_realloc2(s->packet_fifo,
+ av_fifo_size(s->packet_fifo) + sizeof(input_ref));
+ if (ret < 0)
+ return ret;
+ }
+
+ ret = av_packet_ref(&input_ref, avpkt);
+ if (ret < 0)
+ return ret;
+ av_fifo_generic_write(s->packet_fifo, &input_ref, sizeof(input_ref), NULL);
+ }
+
+ /* process buffered data */
+ while (!*got_frame) {
+ /* prepare the input data -- convert to Annex B if needed */
+ if (s->pkt_filtered.size <= 0) {
+ int size;
+
+ /* no more data */
+ if (av_fifo_size(s->packet_fifo) < sizeof(AVPacket))
+ return avpkt->size ? avpkt->size : ff_qsv_decode(avctx, &s->qsv, frame, got_frame, avpkt);
+
+ if (s->filtered_data != s->input_ref.data)
+ av_freep(&s->filtered_data);
+ s->filtered_data = NULL;
+ av_packet_unref(&s->input_ref);
+
+ av_fifo_generic_read(s->packet_fifo, &s->input_ref, sizeof(s->input_ref), NULL);
+ ret = av_bitstream_filter_filter(s->bsf, avctx, NULL,
+ &s->filtered_data, &size,
+ s->input_ref.data, s->input_ref.size, 0);
+ if (ret < 0) {
+ s->filtered_data = s->input_ref.data;
+ size = s->input_ref.size;
+ }
+ s->pkt_filtered = s->input_ref;
+ s->pkt_filtered.data = s->filtered_data;
+ s->pkt_filtered.size = size;
+ }
+
+ ret = qsv_process_data(avctx, frame, got_frame, &s->pkt_filtered);
+ if (ret < 0)
+ return ret;
+
+ s->pkt_filtered.size -= ret;
+ s->pkt_filtered.data += ret;
+ }
+
+ return avpkt->size;
+}
+
+static void qsv_decode_flush(AVCodecContext *avctx)
+{
+ QSVH264Context *s = avctx->priv_data;
+
+ qsv_clear_buffers(s);
+ s->orig_pix_fmt = AV_PIX_FMT_NONE;
+}
+
+AVHWAccel ff_h264_qsv_hwaccel = {
+ .name = "h264_qsv",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = AV_CODEC_ID_H264,
+ .pix_fmt = AV_PIX_FMT_QSV,
+};
+
+#define OFFSET(x) offsetof(QSVH264Context, x)
+#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
+static const AVOption options[] = {
+ { "async_depth", "Internal parallelization depth, the higher the value the higher the latency.", OFFSET(qsv.async_depth), AV_OPT_TYPE_INT, { .i64 = ASYNC_DEPTH_DEFAULT }, 0, INT_MAX, VD },
+ { NULL },
+};
+
+static const AVClass class = {
+ .class_name = "h264_qsv",
+ .item_name = av_default_item_name,
+ .option = options,
+ .version = LIBAVUTIL_VERSION_INT,
+};
+
+AVCodec ff_h264_qsv_decoder = {
+ .name = "h264_qsv",
+ .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (Intel Quick Sync Video acceleration)"),
+ .priv_data_size = sizeof(QSVH264Context),
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = AV_CODEC_ID_H264,
+ .init = qsv_decode_init,
+ .decode = qsv_decode_frame,
+ .flush = qsv_decode_flush,
+ .close = qsv_decode_close,
+ .capabilities = CODEC_CAP_DELAY,
+ .priv_class = &class,
+};
diff --git a/libavcodec/qsv_internal.h b/libavcodec/qsv_internal.h
new file mode 100644
index 0000000..8ab149a
--- /dev/null
+++ b/libavcodec/qsv_internal.h
@@ -0,0 +1,86 @@
+/*
+ * Intel MediaSDK QSV utility functions
+ *
+ * copyright (c) 2013 Luca Barbato
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_QSV_INTERNAL_H
+#define AVCODEC_QSV_INTERNAL_H
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include <mfx/mfxvideo.h>
+
+#include "libavutil/frame.h"
+#include "libavutil/pixfmt.h"
+
+#include "avcodec.h"
+
+#define QSV_VERSION_MAJOR 1
+#define QSV_VERSION_MINOR 1
+
+#define ASYNC_DEPTH_DEFAULT 4 // internal parallelism
+
+typedef struct QSVFrame {
+ AVFrame *frame;
+ mfxFrameSurface1 *surface;
+
+ mfxFrameSurface1 surface_internal;
+
+ struct QSVFrame *next;
+} QSVFrame;
+
+typedef struct QSVContext {
+ // the session used for decoding
+ mfxSession session;
+
+ // the session we allocated internally, in case the caller did not provide
+ // one
+ mfxSession internal_session;
+
+ /**
+ * a linked list of frames currently being used by QSV
+ */
+ QSVFrame *work_frames;
+
+ // options set by the caller
+ int async_depth;
+ int iopattern;
+
+ mfxExtBuffer **ext_buffers;
+ int nb_ext_buffers;
+} QSVContext;
+
+/**
+ * Convert a libmfx error code into a libav error code.
+ */
+int ff_qsv_error(int mfx_err);
+
+int ff_qsv_map_pixfmt(enum AVPixelFormat format);
+
+int ff_qsv_init(AVCodecContext *s, QSVContext *q, mfxSession session);
+
+int ff_qsv_decode(AVCodecContext *s, QSVContext *q,
+ AVFrame *frame, int *got_frame,
+ AVPacket *avpkt);
+
+int ff_qsv_close(QSVContext *q);
+
+#endif /* AVCODEC_QSV_INTERNAL_H */
diff --git a/libavcodec/version.h b/libavcodec/version.h
index d58e329..6672986 100644
--- a/libavcodec/version.h
+++ b/libavcodec/version.h
@@ -29,7 +29,7 @@
#include "libavutil/version.h"
#define LIBAVCODEC_VERSION_MAJOR 56
-#define LIBAVCODEC_VERSION_MINOR 13
+#define LIBAVCODEC_VERSION_MINOR 14
#define LIBAVCODEC_VERSION_MICRO 0
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
More information about the ffmpeg-cvslog
mailing list