[FFmpeg-cvslog] h264dec: add a CUVID hwaccel
Anton Khirnov
git at videolan.org
Sat Nov 11 00:46:07 EET 2017
ffmpeg | branch: master | Anton Khirnov <anton at khirnov.net> | Sat Feb 11 16:49:34 2017 +0100| [b9129ec4668c511e0a79e25c6f25d748cee172c9] | committer: Anton Khirnov
h264dec: add a CUVID hwaccel
Some parts of the code are based on a patch by
Timo Rothenpieler <timo at rothenpieler.org>
> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=b9129ec4668c511e0a79e25c6f25d748cee172c9
---
Changelog | 1 +
avtools/avconv.h | 1 +
avtools/avconv_opt.c | 4 +
configure | 11 +-
libavcodec/Makefile | 2 +
libavcodec/allcodecs.c | 1 +
libavcodec/cuvid.c | 425 ++++++++++++++++++++++++++++++++++++++++++++++++
libavcodec/cuvid.h | 61 +++++++
libavcodec/cuvid_h264.c | 177 ++++++++++++++++++++
libavcodec/h264_slice.c | 6 +-
10 files changed, 687 insertions(+), 2 deletions(-)
diff --git a/Changelog b/Changelog
index 82e3e3a0ef..711506624f 100644
--- a/Changelog
+++ b/Changelog
@@ -18,6 +18,7 @@ version <next>:
- support for decoding through D3D11VA in avconv
- Cinepak encoder
- Intel QSV-accelerated MJPEG encoding
+- NVIDIA CUVID-accelerated H.264 decoding
version 12:
diff --git a/avtools/avconv.h b/avtools/avconv.h
index 4c699333a5..b5843fbc03 100644
--- a/avtools/avconv.h
+++ b/avtools/avconv.h
@@ -58,6 +58,7 @@ enum HWAccelID {
HWACCEL_QSV,
HWACCEL_VAAPI,
HWACCEL_D3D11VA,
+ HWACCEL_CUVID,
};
typedef struct HWAccel {
diff --git a/avtools/avconv_opt.c b/avtools/avconv_opt.c
index 575ce120dd..df693360a7 100644
--- a/avtools/avconv_opt.c
+++ b/avtools/avconv_opt.c
@@ -80,6 +80,10 @@ const HWAccel hwaccels[] = {
{ "vaapi", hwaccel_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI,
AV_HWDEVICE_TYPE_VAAPI },
#endif
+#if CONFIG_CUVID
+ { "cuvid", hwaccel_decode_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA,
+ AV_HWDEVICE_TYPE_CUDA },
+#endif
{ 0 },
};
int hwaccel_lax_profile_check = 0;
diff --git a/configure b/configure
index 35ae03182a..7a7fbb2906 100755
--- a/configure
+++ b/configure
@@ -237,6 +237,7 @@ External library support:
The following libraries provide various hardware acceleration features:
--enable-cuda Nvidia CUDA (dynamically linked)
+ --enable-cuvid Nvidia CUVID video decode acceleration
--enable-d3d11va Microsoft Direct3D 11 video acceleration [auto]
--enable-dxva2 Microsoft DirectX 9 video acceleration [auto]
--enable-libmfx Intel MediaSDK (AKA Quick Sync Video)
@@ -1266,6 +1267,7 @@ EXTRALIBS_LIST="
HWACCEL_LIBRARY_NONFREE_LIST="
cuda
+ cuvid
libnpp
"
HWACCEL_LIBRARY_LIST="
@@ -1686,6 +1688,7 @@ TOOLCHAIN_FEATURES="
TYPES_LIST="
CONDITION_VARIABLE_Ptr
+ CUVIDDECODECREATEINFO_bitDepthMinus8
socklen_t
struct_addrinfo
struct_group_source_req
@@ -2189,6 +2192,8 @@ vda_extralibs="-framework CoreFoundation -framework VideoDecodeAcceleration -fra
h263_vaapi_hwaccel_deps="vaapi"
h263_vaapi_hwaccel_select="h263_decoder"
+h264_cuvid_hwaccel_deps="cuvid CUVIDH264PICPARAMS"
+h264_cuvid_hwaccel_select="h264_decoder"
h264_d3d11va_hwaccel_deps="d3d11va"
h264_d3d11va_hwaccel_select="h264_decoder"
h264_d3d11va2_hwaccel_deps="d3d11va"
@@ -2556,7 +2561,7 @@ avdevice_extralibs="libm_extralibs"
avformat_extralibs="libm_extralibs"
avfilter_extralibs="pthreads_extralibs libm_extralibs"
avresample_extralibs="libm_extralibs"
-avutil_extralibs="clock_gettime_extralibs cuda_extralibs libm_extralibs libmfx_extralibs nanosleep_extralibs pthreads_extralibs user32_extralibs vaapi_extralibs vaapi_drm_extralibs vaapi_x11_extralibs vdpau_x11_extralibs wincrypt_extralibs"
+avutil_extralibs="clock_gettime_extralibs cuda_extralibs cuvid_extralibs libm_extralibs libmfx_extralibs nanosleep_extralibs pthreads_extralibs user32_extralibs vaapi_extralibs vaapi_drm_extralibs vaapi_x11_extralibs vdpau_x11_extralibs wincrypt_extralibs"
swscale_extralibs="libm_extralibs"
# programs
@@ -4694,6 +4699,9 @@ check_lib psapi "windows.h psapi.h" GetProcessMemoryInfo -lpsapi
check_struct "sys/time.h sys/resource.h" "struct rusage" ru_maxrss
+check_type "cuviddec.h" "CUVIDH264PICPARAMS"
+check_struct "cuviddec.h" "CUVIDDECODECREATEINFO" bitDepthMinus8
+
check_type "windows.h dxva.h" "DXVA_PicParams_HEVC" -DWINAPI_FAMILY=WINAPI_FAMILY_DESKTOP_APP -D_CRT_BUILD_DESKTOP_APP=0
check_type "windows.h d3d11.h" "ID3D11VideoDecoder"
check_type "d3d9.h dxva2api.h" DXVA2_ConfigPictureDecode -D_WIN32_WINNT=0x0602
@@ -4753,6 +4761,7 @@ done
enabled avisynth && require_header avisynth/avisynth_c.h
enabled avxsynth && require_header avxsynth/avxsynth_c.h
enabled cuda && require cuda cuda.h cuInit -lcuda
+enabled cuvid && require cuvid cuviddec.h cuvidCreateDecoder -lnvcuvid
enabled frei0r && require_header frei0r.h
enabled gnutls && require_pkg_config gnutls gnutls gnutls/gnutls.h gnutls_global_init
enabled libbs2b && require_pkg_config libbs2b libbs2b bs2b.h bs2b_open
diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index 12bf8fecb7..ac13166891 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -626,6 +626,7 @@ OBJS-$(CONFIG_ADPCM_YAMAHA_DECODER) += adpcm.o adpcm_data.o
OBJS-$(CONFIG_ADPCM_YAMAHA_ENCODER) += adpcmenc.o adpcm_data.o
# hardware accelerators
+OBJS-$(CONFIG_CUVID) += cuvid.o
OBJS-$(CONFIG_D3D11VA) += dxva2.o
OBJS-$(CONFIG_DXVA2) += dxva2.o
OBJS-$(CONFIG_VAAPI) += vaapi_decode.o
@@ -633,6 +634,7 @@ OBJS-$(CONFIG_VDA) += vda.o
OBJS-$(CONFIG_VDPAU) += vdpau.o
OBJS-$(CONFIG_H263_VAAPI_HWACCEL) += vaapi_mpeg4.o
+OBJS-$(CONFIG_H264_CUVID_HWACCEL) += cuvid_h264.o
OBJS-$(CONFIG_H264_D3D11VA_HWACCEL) += dxva2_h264.o
OBJS-$(CONFIG_H264_DXVA2_HWACCEL) += dxva2_h264.o
OBJS-$(CONFIG_H264_QSV_HWACCEL) += qsvdec_h2645.o
diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
index 3fcea5be0d..ea3a6b9702 100644
--- a/libavcodec/allcodecs.c
+++ b/libavcodec/allcodecs.c
@@ -68,6 +68,7 @@ void avcodec_register_all(void)
/* hardware accelerators */
REGISTER_HWACCEL(H263_VAAPI, h263_vaapi);
+ REGISTER_HWACCEL(H264_CUVID, h264_cuvid);
REGISTER_HWACCEL(H264_D3D11VA, h264_d3d11va);
REGISTER_HWACCEL(H264_D3D11VA2, h264_d3d11va2);
REGISTER_HWACCEL(H264_DXVA2, h264_dxva2);
diff --git a/libavcodec/cuvid.c b/libavcodec/cuvid.c
new file mode 100644
index 0000000000..69f624c373
--- /dev/null
+++ b/libavcodec/cuvid.c
@@ -0,0 +1,425 @@
+/*
+ * HW decode acceleration through CUVID
+ *
+ * Copyright (c) 2016 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 <cuda.h>
+#include <cuviddec.h>
+
+#include "config.h"
+
+#include "libavutil/common.h"
+#include "libavutil/error.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_cuda.h"
+#include "libavutil/pixdesc.h"
+#include "libavutil/pixfmt.h"
+
+#include "avcodec.h"
+#include "decode.h"
+#include "cuvid.h"
+#include "internal.h"
+
+typedef struct CUVIDDecoder {
+ CUvideodecoder decoder;
+
+ AVBufferRef *hw_device_ref;
+ CUcontext cuda_ctx;
+} CUVIDDecoder;
+
+typedef struct CUVIDFramePool {
+ unsigned int dpb_size;
+ unsigned int nb_allocated;
+} CUVIDFramePool;
+
+static int map_avcodec_id(enum AVCodecID id)
+{
+ switch (id) {
+ case AV_CODEC_ID_H264: return cudaVideoCodec_H264;
+ }
+ return -1;
+}
+
+static int map_chroma_format(enum AVPixelFormat pix_fmt)
+{
+ int shift_h = 0, shift_v = 0;
+
+ av_pix_fmt_get_chroma_sub_sample(pix_fmt, &shift_h, &shift_v);
+
+ if (shift_h == 1 && shift_v == 1)
+ return cudaVideoChromaFormat_420;
+ else if (shift_h == 1 && shift_v == 0)
+ return cudaVideoChromaFormat_422;
+ else if (shift_h == 0 && shift_v == 0)
+ return cudaVideoChromaFormat_444;
+
+ return -1;
+}
+
+static void cuvid_decoder_free(void *opaque, uint8_t *data)
+{
+ CUVIDDecoder *decoder = (CUVIDDecoder*)data;
+
+ if (decoder->decoder)
+ cuvidDestroyDecoder(decoder->decoder);
+
+ av_buffer_unref(&decoder->hw_device_ref);
+
+ av_freep(&decoder);
+}
+
+static int cuvid_decoder_create(AVBufferRef **out, AVBufferRef *hw_device_ref,
+ CUVIDDECODECREATEINFO *params, void *logctx)
+{
+ AVHWDeviceContext *hw_device_ctx = (AVHWDeviceContext*)hw_device_ref->data;
+ AVCUDADeviceContext *device_hwctx = hw_device_ctx->hwctx;
+
+ AVBufferRef *decoder_ref;
+ CUVIDDecoder *decoder;
+
+ CUcontext dummy;
+ CUresult err;
+ int ret;
+
+ decoder = av_mallocz(sizeof(*decoder));
+ if (!decoder)
+ return AVERROR(ENOMEM);
+
+ decoder_ref = av_buffer_create((uint8_t*)decoder, sizeof(*decoder),
+ cuvid_decoder_free, NULL, AV_BUFFER_FLAG_READONLY);
+ if (!decoder_ref) {
+ av_freep(&decoder);
+ return AVERROR(ENOMEM);
+ }
+
+ decoder->hw_device_ref = av_buffer_ref(hw_device_ref);
+ if (!decoder->hw_device_ref) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+ decoder->cuda_ctx = device_hwctx->cuda_ctx;
+
+ err = cuCtxPushCurrent(decoder->cuda_ctx);
+ if (err != CUDA_SUCCESS) {
+ ret = AVERROR_UNKNOWN;
+ goto fail;
+ }
+
+ err = cuvidCreateDecoder(&decoder->decoder, params);
+
+ cuCtxPopCurrent(&dummy);
+
+ if (err != CUDA_SUCCESS) {
+ av_log(logctx, AV_LOG_ERROR, "Error creating a CUVID decoder: %d\n", err);
+ ret = AVERROR_UNKNOWN;
+ goto fail;
+ }
+
+ *out = decoder_ref;
+
+ return 0;
+fail:
+ av_buffer_unref(&decoder_ref);
+ return ret;
+}
+
+static AVBufferRef *cuvid_decoder_frame_alloc(void *opaque, int size)
+{
+ CUVIDFramePool *pool = opaque;
+ AVBufferRef *ret;
+
+ if (pool->nb_allocated >= pool->dpb_size)
+ return NULL;
+
+ ret = av_buffer_alloc(sizeof(unsigned int));
+ if (!ret)
+ return NULL;
+
+ *(unsigned int*)ret->data = pool->nb_allocated++;
+
+ return ret;
+}
+
+int ff_cuvid_decode_uninit(AVCodecContext *avctx)
+{
+ CUVIDContext *ctx = avctx->internal->hwaccel_priv_data;
+
+ av_freep(&ctx->bitstream);
+ ctx->bitstream_len = 0;
+ ctx->bitstream_allocated = 0;
+
+ av_freep(&ctx->slice_offsets);
+ ctx->nb_slices = 0;
+ ctx->slice_offsets_allocated = 0;
+
+ av_buffer_unref(&ctx->decoder_ref);
+ av_buffer_pool_uninit(&ctx->decoder_pool);
+
+ return 0;
+}
+
+int ff_cuvid_decode_init(AVCodecContext *avctx, unsigned int dpb_size)
+{
+ CUVIDContext *ctx = avctx->internal->hwaccel_priv_data;
+
+ CUVIDFramePool *pool;
+ AVHWFramesContext *frames_ctx;
+ const AVPixFmtDescriptor *sw_desc;
+
+ CUVIDDECODECREATEINFO params = { 0 };
+
+ int cuvid_codec_type, cuvid_chroma_format;
+ int ret = 0;
+
+ sw_desc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
+ if (!sw_desc)
+ return AVERROR_BUG;
+
+ cuvid_codec_type = map_avcodec_id(avctx->codec_id);
+ if (cuvid_codec_type < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Unsupported codec ID\n");
+ return AVERROR_BUG;
+ }
+
+ cuvid_chroma_format = map_chroma_format(avctx->sw_pix_fmt);
+ if (cuvid_chroma_format < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Unsupported chroma format\n");
+ return AVERROR(ENOSYS);
+ }
+
+ if (avctx->thread_type & FF_THREAD_FRAME)
+ dpb_size += avctx->thread_count;
+
+ if (!avctx->hw_frames_ctx) {
+ AVHWFramesContext *frames_ctx;
+
+ if (!avctx->hw_device_ctx) {
+ av_log(avctx, AV_LOG_ERROR, "A hardware device or frames context "
+ "is required for CUVID decoding.\n");
+ return AVERROR(EINVAL);
+ }
+
+ avctx->hw_frames_ctx = av_hwframe_ctx_alloc(avctx->hw_device_ctx);
+ if (!avctx->hw_frames_ctx)
+ return AVERROR(ENOMEM);
+ frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+
+ frames_ctx->format = AV_PIX_FMT_CUDA;
+ frames_ctx->width = avctx->coded_width;
+ frames_ctx->height = avctx->coded_height;
+ frames_ctx->sw_format = AV_PIX_FMT_NV12;
+ frames_ctx->sw_format = sw_desc->comp[0].depth > 8 && HAVE_CUVIDDECODECREATEINFO_BITDEPTHMINUS8 ?
+ AV_PIX_FMT_P010 : AV_PIX_FMT_NV12;
+ frames_ctx->initial_pool_size = dpb_size;
+
+ ret = av_hwframe_ctx_init(avctx->hw_frames_ctx);
+ if (ret < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Error initializing internal frames context\n");
+ return ret;
+ }
+ }
+ frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+
+ params.ulWidth = avctx->coded_width;
+ params.ulHeight = avctx->coded_height;
+ params.ulTargetWidth = avctx->coded_width;
+ params.ulTargetHeight = avctx->coded_height;
+#if HAVE_CUVIDDECODECREATEINFO_BITDEPTHMINUS8
+ params.bitDepthMinus8 = sw_desc->comp[0].depth - 8;
+ params.OutputFormat = params.bitDepthMinus8 ?
+ cudaVideoSurfaceFormat_P016 : cudaVideoSurfaceFormat_NV12;
+#else
+ params.OutputFormat = cudaVideoSurfaceFormat_NV12;
+#endif
+ params.CodecType = cuvid_codec_type;
+ params.ChromaFormat = cuvid_chroma_format;
+ params.ulNumDecodeSurfaces = dpb_size;
+ params.ulNumOutputSurfaces = 1;
+
+ ret = cuvid_decoder_create(&ctx->decoder_ref, frames_ctx->device_ref, ¶ms, avctx);
+ if (ret < 0)
+ return ret;
+
+ pool = av_mallocz(sizeof(*pool));
+ if (!pool) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+ pool->dpb_size = dpb_size;
+
+ ctx->decoder_pool = av_buffer_pool_init2(sizeof(int), pool,
+ cuvid_decoder_frame_alloc, av_free);
+ if (!ctx->decoder_pool) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+
+ return 0;
+fail:
+ ff_cuvid_decode_uninit(avctx);
+ return ret;
+}
+
+static void cuvid_fdd_priv_free(void *priv)
+{
+ CUVIDFrame *cf = priv;
+
+ if (!cf)
+ return;
+
+ av_buffer_unref(&cf->idx_ref);
+ av_buffer_unref(&cf->decoder_ref);
+
+ av_freep(&priv);
+}
+
+static int cuvid_retrieve_data(void *logctx, AVFrame *frame)
+{
+ FrameDecodeData *fdd = (FrameDecodeData*)frame->opaque_ref->data;
+ CUVIDFrame *cf = (CUVIDFrame*)fdd->hwaccel_priv;
+ CUVIDDecoder *decoder = (CUVIDDecoder*)cf->decoder_ref->data;
+
+ CUVIDPROCPARAMS vpp = { .progressive_frame = 1 };
+
+ CUresult err;
+ CUcontext dummy;
+ CUdeviceptr devptr;
+
+ unsigned int pitch, i;
+ unsigned int offset = 0;
+ int ret = 0;
+
+ err = cuCtxPushCurrent(decoder->cuda_ctx);
+ if (err != CUDA_SUCCESS)
+ return AVERROR_UNKNOWN;
+
+ err = cuvidMapVideoFrame(decoder->decoder, cf->idx, &devptr, &pitch, &vpp);
+ if (err != CUDA_SUCCESS) {
+ av_log(logctx, AV_LOG_ERROR, "Error mapping a picture with CUVID: %d\n",
+ err);
+ ret = AVERROR_UNKNOWN;
+ goto finish;
+ }
+
+ for (i = 0; frame->data[i]; i++) {
+ CUDA_MEMCPY2D cpy = {
+ .srcMemoryType = CU_MEMORYTYPE_DEVICE,
+ .dstMemoryType = CU_MEMORYTYPE_DEVICE,
+ .srcDevice = devptr,
+ .dstDevice = (CUdeviceptr)frame->data[i],
+ .srcPitch = pitch,
+ .dstPitch = frame->linesize[i],
+ .srcY = offset,
+ .WidthInBytes = FFMIN(pitch, frame->linesize[i]),
+ .Height = frame->height >> (i ? 1 : 0),
+ };
+
+ err = cuMemcpy2D(&cpy);
+ if (err != CUDA_SUCCESS) {
+ av_log(logctx, AV_LOG_ERROR, "Error copying decoded frame: %d\n",
+ err);
+ ret = AVERROR_UNKNOWN;
+ goto copy_fail;
+ }
+
+ offset += cpy.Height;
+ }
+
+copy_fail:
+ cuvidUnmapVideoFrame(decoder->decoder, devptr);
+
+finish:
+ cuCtxPopCurrent(&dummy);
+ return ret;
+}
+
+int ff_cuvid_start_frame(AVCodecContext *avctx, AVFrame *frame)
+{
+ CUVIDContext *ctx = avctx->internal->hwaccel_priv_data;
+ FrameDecodeData *fdd = (FrameDecodeData*)frame->opaque_ref->data;
+ CUVIDFrame *cf = NULL;
+ int ret;
+
+ ctx->bitstream_len = 0;
+ ctx->nb_slices = 0;
+
+ if (fdd->hwaccel_priv)
+ return 0;
+
+ cf = av_mallocz(sizeof(*cf));
+ if (!cf)
+ return AVERROR(ENOMEM);
+
+ cf->decoder_ref = av_buffer_ref(ctx->decoder_ref);
+ if (!cf->decoder_ref)
+ goto fail;
+
+ cf->idx_ref = av_buffer_pool_get(ctx->decoder_pool);
+ if (!cf->idx_ref) {
+ av_log(avctx, AV_LOG_ERROR, "No decoder surfaces left\n");
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+ cf->idx = *(unsigned int*)cf->idx_ref->data;
+
+ fdd->hwaccel_priv = cf;
+ fdd->hwaccel_priv_free = cuvid_fdd_priv_free;
+ fdd->post_process = cuvid_retrieve_data;
+
+ return 0;
+fail:
+ cuvid_fdd_priv_free(cf);
+ return ret;
+
+}
+
+int ff_cuvid_end_frame(AVCodecContext *avctx)
+{
+ CUVIDContext *ctx = avctx->internal->hwaccel_priv_data;
+ CUVIDDecoder *decoder = (CUVIDDecoder*)ctx->decoder_ref->data;
+ CUVIDPICPARAMS *pp = &ctx->pic_params;
+
+ CUresult err;
+ CUcontext dummy;
+
+ int ret = 0;
+
+ pp->nBitstreamDataLen = ctx->bitstream_len;
+ pp->pBitstreamData = ctx->bitstream;
+ pp->nNumSlices = ctx->nb_slices;
+ pp->pSliceDataOffsets = ctx->slice_offsets;
+
+ err = cuCtxPushCurrent(decoder->cuda_ctx);
+ if (err != CUDA_SUCCESS)
+ return AVERROR_UNKNOWN;
+
+ err = cuvidDecodePicture(decoder->decoder, &ctx->pic_params);
+ if (err != CUDA_SUCCESS) {
+ av_log(avctx, AV_LOG_ERROR, "Error decoding a picture with CUVID: %d\n",
+ err);
+ ret = AVERROR_UNKNOWN;
+ goto finish;
+ }
+
+finish:
+ cuCtxPopCurrent(&dummy);
+
+ return ret;
+}
diff --git a/libavcodec/cuvid.h b/libavcodec/cuvid.h
new file mode 100644
index 0000000000..62e376bca2
--- /dev/null
+++ b/libavcodec/cuvid.h
@@ -0,0 +1,61 @@
+/*
+ * HW decode acceleration through CUVID
+ *
+ * Copyright (c) 2016 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
+ */
+
+#ifndef AVCODEC_CUVID_H
+#define AVCODEC_CUVID_H
+
+#include <cuviddec.h>
+#include <stdint.h>
+
+#include "libavutil/buffer.h"
+#include "libavutil/frame.h"
+
+#include "avcodec.h"
+
+typedef struct CUVIDFrame {
+ unsigned int idx;
+ AVBufferRef *idx_ref;
+ AVBufferRef *decoder_ref;
+} CUVIDFrame;
+
+typedef struct CUVIDContext {
+ CUVIDPICPARAMS pic_params;
+
+ AVBufferPool *decoder_pool;
+
+ AVBufferRef *decoder_ref;
+
+ uint8_t *bitstream;
+ int bitstream_len;
+ unsigned int bitstream_allocated;
+
+ unsigned *slice_offsets;
+ int nb_slices;
+ unsigned int slice_offsets_allocated;
+} CUVIDContext;
+
+int ff_cuvid_decode_init(AVCodecContext *avctx, unsigned int dpb_size);
+int ff_cuvid_decode_uninit(AVCodecContext *avctx);
+int ff_cuvid_start_frame(AVCodecContext *avctx, AVFrame *frame);
+int ff_cuvid_end_frame(AVCodecContext *avctx);
+
+#endif /* AVCODEC_CUVID_H */
diff --git a/libavcodec/cuvid_h264.c b/libavcodec/cuvid_h264.c
new file mode 100644
index 0000000000..a83e4ffba0
--- /dev/null
+++ b/libavcodec/cuvid_h264.c
@@ -0,0 +1,177 @@
+/*
+ * MPEG-4 Part 10 / AVC / H.264 HW decode acceleration through CUVID
+ *
+ * Copyright (c) 2016 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 <cuviddec.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "avcodec.h"
+#include "cuvid.h"
+#include "decode.h"
+#include "internal.h"
+#include "h264dec.h"
+
+static void dpb_add(const H264Context *h, CUVIDH264DPBENTRY *dst, const H264Picture *src,
+ int frame_idx)
+{
+ FrameDecodeData *fdd = (FrameDecodeData*)src->f->opaque_ref->data;
+ const CUVIDFrame *cf = fdd->hwaccel_priv;
+
+ dst->PicIdx = cf ? cf->idx : -1;
+ dst->FrameIdx = frame_idx;
+ dst->is_long_term = src->long_ref;
+ dst->not_existing = 0;
+ dst->used_for_reference = src->reference & 3;
+ dst->FieldOrderCnt[0] = src->field_poc[0];
+ dst->FieldOrderCnt[1] = src->field_poc[1];
+}
+
+static int cuvid_h264_start_frame(AVCodecContext *avctx,
+ const uint8_t *buffer, uint32_t size)
+{
+ const H264Context *h = avctx->priv_data;
+ const PPS *pps = h->ps.pps;
+ const SPS *sps = h->ps.sps;
+
+ CUVIDContext *ctx = avctx->internal->hwaccel_priv_data;
+ CUVIDPICPARAMS *pp = &ctx->pic_params;
+ CUVIDH264PICPARAMS *ppc = &pp->CodecSpecific.h264;
+ FrameDecodeData *fdd;
+ CUVIDFrame *cf;
+
+ int i, dpb_size, ret;
+
+ ret = ff_cuvid_start_frame(avctx, h->cur_pic_ptr->f);
+ if (ret < 0)
+ return ret;
+
+ fdd = (FrameDecodeData*)h->cur_pic_ptr->f->opaque_ref->data;
+ cf = (CUVIDFrame*)fdd->hwaccel_priv;
+
+ *pp = (CUVIDPICPARAMS) {
+ .PicWidthInMbs = h->mb_width,
+ .FrameHeightInMbs = h->mb_height,
+ .CurrPicIdx = cf->idx,
+ .field_pic_flag = FIELD_PICTURE(h),
+ .bottom_field_flag = h->picture_structure == PICT_BOTTOM_FIELD,
+ .second_field = FIELD_PICTURE(h) && !h->first_field,
+ .ref_pic_flag = h->nal_ref_idc != 0,
+ .intra_pic_flag = 0,
+
+ .CodecSpecific.h264 = {
+ .log2_max_frame_num_minus4 = sps->log2_max_frame_num - 4,
+ .pic_order_cnt_type = sps->poc_type,
+ .log2_max_pic_order_cnt_lsb_minus4 = FFMAX(sps->log2_max_poc_lsb - 4, 0),
+ .delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag,
+ .frame_mbs_only_flag = sps->frame_mbs_only_flag,
+ .direct_8x8_inference_flag = sps->direct_8x8_inference_flag,
+ .num_ref_frames = sps->ref_frame_count,
+ .residual_colour_transform_flag = sps->residual_color_transform_flag,
+ .bit_depth_luma_minus8 = sps->bit_depth_luma - 8,
+ .bit_depth_chroma_minus8 = sps->bit_depth_chroma - 8,
+ .qpprime_y_zero_transform_bypass_flag = sps->transform_bypass,
+
+ .entropy_coding_mode_flag = pps->cabac,
+ .pic_order_present_flag = pps->pic_order_present,
+ .num_ref_idx_l0_active_minus1 = pps->ref_count[0] - 1,
+ .num_ref_idx_l1_active_minus1 = pps->ref_count[1] - 1,
+ .weighted_pred_flag = pps->weighted_pred,
+ .weighted_bipred_idc = pps->weighted_bipred_idc,
+ .pic_init_qp_minus26 = pps->init_qp - 26,
+ .deblocking_filter_control_present_flag = pps->deblocking_filter_parameters_present,
+ .redundant_pic_cnt_present_flag = pps->redundant_pic_cnt_present,
+ .transform_8x8_mode_flag = pps->transform_8x8_mode,
+ .MbaffFrameFlag = sps->mb_aff && !FIELD_PICTURE(h),
+ .constrained_intra_pred_flag = pps->constrained_intra_pred,
+ .chroma_qp_index_offset = pps->chroma_qp_index_offset[0],
+ .second_chroma_qp_index_offset = pps->chroma_qp_index_offset[1],
+ .ref_pic_flag = h->nal_ref_idc != 0,
+ .frame_num = h->poc.frame_num,
+ .CurrFieldOrderCnt[0] = h->cur_pic_ptr->field_poc[0],
+ .CurrFieldOrderCnt[1] = h->cur_pic_ptr->field_poc[1],
+ },
+ };
+
+ memcpy(ppc->WeightScale4x4, pps->scaling_matrix4, sizeof(ppc->WeightScale4x4));
+ memcpy(ppc->WeightScale8x8[0], pps->scaling_matrix8[0], sizeof(ppc->WeightScale8x8[0]));
+ memcpy(ppc->WeightScale8x8[1], pps->scaling_matrix8[3], sizeof(ppc->WeightScale8x8[0]));
+
+ dpb_size = 0;
+ for (i = 0; i < h->short_ref_count; i++)
+ dpb_add(h, &ppc->dpb[dpb_size++], h->short_ref[i], h->short_ref[i]->frame_num);
+ for (i = 0; i < 16; i++) {
+ if (h->long_ref[i])
+ dpb_add(h, &ppc->dpb[dpb_size++], h->long_ref[i], i);
+ }
+
+ for (i = dpb_size; i < FF_ARRAY_ELEMS(ppc->dpb); i++)
+ ppc->dpb[i].PicIdx = -1;
+
+ return 0;
+}
+
+static int cuvid_h264_decode_slice(AVCodecContext *avctx, const uint8_t *buffer,
+ uint32_t size)
+{
+ CUVIDContext *ctx = avctx->internal->hwaccel_priv_data;
+ void *tmp;
+
+ tmp = av_fast_realloc(ctx->bitstream, &ctx->bitstream_allocated,
+ ctx->bitstream_len + size + 3);
+ if (!tmp)
+ return AVERROR(ENOMEM);
+ ctx->bitstream = tmp;
+
+ tmp = av_fast_realloc(ctx->slice_offsets, &ctx->slice_offsets_allocated,
+ (ctx->nb_slices + 1) * sizeof(*ctx->slice_offsets));
+ if (!tmp)
+ return AVERROR(ENOMEM);
+ ctx->slice_offsets = tmp;
+
+ AV_WB24(ctx->bitstream + ctx->bitstream_len, 1);
+ memcpy(ctx->bitstream + ctx->bitstream_len + 3, buffer, size);
+ ctx->slice_offsets[ctx->nb_slices] = ctx->bitstream_len ;
+ ctx->bitstream_len += size + 3;
+ ctx->nb_slices++;
+
+ return 0;
+}
+
+static int cuvid_h264_decode_init(AVCodecContext *avctx)
+{
+ const H264Context *h = avctx->priv_data;
+ const SPS *sps = h->ps.sps;
+ return ff_cuvid_decode_init(avctx, sps->ref_frame_count + sps->num_reorder_frames);
+}
+
+AVHWAccel ff_h264_cuvid_hwaccel = {
+ .name = "h264_cuvid",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = AV_CODEC_ID_H264,
+ .pix_fmt = AV_PIX_FMT_CUDA,
+ .start_frame = cuvid_h264_start_frame,
+ .end_frame = ff_cuvid_end_frame,
+ .decode_slice = cuvid_h264_decode_slice,
+ .init = cuvid_h264_decode_init,
+ .uninit = ff_cuvid_decode_uninit,
+ .priv_data_size = sizeof(CUVIDContext),
+};
diff --git a/libavcodec/h264_slice.c b/libavcodec/h264_slice.c
index e7408b24b5..c6309b298c 100644
--- a/libavcodec/h264_slice.c
+++ b/libavcodec/h264_slice.c
@@ -724,7 +724,8 @@ static enum AVPixelFormat get_pixel_format(H264Context *h)
(CONFIG_H264_D3D11VA_HWACCEL * 2) + \
CONFIG_H264_VAAPI_HWACCEL + \
(CONFIG_H264_VDA_HWACCEL * 2) + \
- CONFIG_H264_VDPAU_HWACCEL)
+ CONFIG_H264_VDPAU_HWACCEL + \
+ CONFIG_H264_CUVID_HWACCEL)
enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
const enum AVPixelFormat *choices = pix_fmts;
@@ -755,6 +756,9 @@ static enum AVPixelFormat get_pixel_format(H264Context *h)
#if CONFIG_H264_VDPAU_HWACCEL
*fmt++ = AV_PIX_FMT_VDPAU;
#endif
+#if CONFIG_H264_CUVID_HWACCEL
+ *fmt++ = AV_PIX_FMT_CUDA;
+#endif
if (CHROMA444(h)) {
if (h->avctx->colorspace == AVCOL_SPC_RGB)
*fmt++ = AV_PIX_FMT_GBRP;
More information about the ffmpeg-cvslog
mailing list